Changeset 1613:37cb1f6775c0


Ignore:
Timestamp:
03/05/10 09:10:00 (5 months ago)
Author:
Howard Butler <hobu.inc@…>
Branch:
default
Message:

refactor away LAS prefix from all variables that are already within the liblas:: namespace

Files:
43 edited

Legend:

Unmodified
Added
Removed

  • apps/las2oci.cpp

    r1611 r1613  
    313313 
    314314} 
    315 bool GetPointData(  LASPoint const& p,  
     315bool GetPointData(  liblas::Point const& p,  
    316316                    bool bTime,  
    317317                    std::vector<liblas::uint8_t>& point_data) 
    … …  
    367367} 
    368368bool GetResultData( const LASQueryResult& result,  
    369                     LASReader* reader,  
     369                    liblas::Reader* reader,  
    370370                    std::vector<liblas::uint8_t>& data,  
    371371                    int nDimension) 
    … …  
    399399        bool doRead = reader->ReadPointAt(id); 
    400400        if (doRead) { 
    401             LASPoint const& p = reader->GetPoint(); 
     401            liblas::Point const& p = reader->GetPoint(); 
    402402 
    403403            // d 8-byte IEEE  big-endian doubles, where d is the PC_TOT_DIMENSIONS value 
    … …  
    496496    return e;     
    497497} 
     498 
    498499blocks* CreateBlock(int size) 
    499500{ 
    … …  
    509510 
    510511    b->element_arrays = (OCIArray**) malloc ( size * sizeof(OCIArray*)); 
     512 
    511513    b->coordinate_arrays = (OCIArray**) malloc ( size * sizeof(OCIArray*)); 
    512514    return b; 
    513515} 
     516 
    514517bool FillBlock( OWConnection* connection,  
    515518                OWStatement* statement, 
    516519                const LASQueryResult& result,  
    517                 LASReader* reader, 
     520                liblas::Reader* reader, 
    518521                blocks* b, 
    519522                long index, 
    … …  
    529532 
    530533    list<SpatialIndex::id_type> const& ids = result.GetIDs(); 
    531     
    532     b->pc_ids[index] = pc_id; 
    533     b->srids[index] = srid; 
    534     b->block_ids[index] = result.GetID(); 
    535     b->num_points[index] = (long)ids.size(); 
    536534     
    537535    // TODO: This probably is a memory leak if the gotdata == false --mloskot 
    538536    std::vector<liblas::uint8_t>* blob = new std::vector<liblas::uint8_t>; 
    539537     
    540     bool gotdata = GetResultData(result, reader, *blob, nDimensions); 
    541     if (! gotdata) throw std::runtime_error("unable to fetch point data byte array"); 
    542     b->blobs[index] = blob; 
    543     // FIXME: null srids not supported  
    544     b->srids[index] = srid; 
    545     b->gtypes[index] = gtype; 
    546  
    547     OCIArray* sdo_elem_info=0; 
    548     connection->CreateType(&sdo_elem_info, connection->GetElemInfoType()); 
    549     SetElements(statement, sdo_elem_info, bUseSolidGeometry); 
    550      
    551     b->element_arrays[index] = sdo_elem_info; 
    552  
    553     OCIArray* sdo_ordinates=0; 
    554     connection->CreateType(&sdo_ordinates, connection->GetOrdinateType()); 
    555  
    556  
    557  
    558     extent* e = GetExtent(result.GetBounds(), bUse3d); 
    559     SetOrdinates(statement, sdo_ordinates, e); 
    560  
    561     b->coordinate_arrays[index] = sdo_ordinates; 
     538    // b->pc_ids[index] = pc_id; 
     539    printf("Index: %d\n", index); 
     540    b->srids[index] = (long)srid; 
     541    // b->block_ids[index] = result.GetID(); 
     542    // b->num_points[index] = (long)ids.size(); 
     543     
     544    // std::vector<liblas::uint8_t>* blob = new std::vector<liblas::uint8_t>; 
     545     
     546    // bool gotdata = GetResultData(result, reader, *blob, nDimensions); 
     547    // if (! gotdata) throw std::runtime_error("unable to fetch point data byte array"); 
     548    // b->blobs[index] = blob; 
     549    // // FIXME: null srids not supported  
     550    // b->srids[index] = srid; 
     551    // b->gtypes[index] = gtype; 
     552    //  
     553    // OCIArray* sdo_elem_info=0; 
     554    // connection->CreateType(&sdo_elem_info, connection->GetElemInfoType()); 
     555    // SetElements(statement, sdo_elem_info, bUseSolidGeometry); 
     556    //  
     557    // b->element_arrays[index] = sdo_elem_info; 
     558    //  
     559    // OCIArray* sdo_ordinates=0; 
     560    // connection->CreateType(&sdo_ordinates, connection->GetOrdinateType()); 
     561    //  
     562    //  
     563    //  
     564    // extent* e = GetExtent(result.GetBounds(), bUse3d); 
     565    // SetOrdinates(statement, sdo_ordinates, e); 
     566    //  
     567    // b->coordinate_arrays[index] = sdo_ordinates; 
    562568     
    563569    return true; 
    … …  
    643649                long block_index, 
    644650                int srid,  
    645                 LASReader* reader,  
     651                liblas::Reader* reader,  
    646652                const char* tableName,  
    647653                long precision, 
    … …  
    758764                long nCommitInterval,  
    759765                int srid,  
    760                 LASReader* reader2,  
     766                liblas::Reader* reader2,  
    761767                const std::string& table_name,  
    762768                long precision, 
    … …  
    785791    long j = 0; 
    786792    bool inserted = false; 
     793 
     794     
     795    for (int t = 0; t < commit_interval; t++) { 
     796        FillBlock( con,  
     797                        statement, 
     798                        *i,  
     799                        reader2, 
     800                        b, 
     801                        t, 
     802                        srid,  
     803                         pc_id, 
     804                         GetGType(bUse3d, bUseSolidGeometry), 
     805                         bUseSolidGeometry, 
     806                         bUse3d, 
     807                         nDimensions 
     808                         ); 
     809         
     810    } 
     811         
     812 
     813 
    787814    for (i=results.begin(); i!=results.end(); i++) 
    788     { 
    789         j++; 
    790         //  
    791         // FillBlock( con,  
    792         //                 statement, 
    793         //                 *i,  
    794         //                 reader2, 
    795         //                 b, 
    796         //                 j, 
    797         //                 srid,  
    798         //                  pc_id, 
    799         //                  GetGType(bUse3d, bUseSolidGeometry), 
    800         //                  bUseSolidGeometry, 
    801         //                  bUse3d, 
    802         //                  nDimensions 
    803         //                  ); 
    804          
     815    {         
    805816        inserted = InsertBlock(con,  
    806817                                    *i, 
    … …  
    814825                                    bUseSolidGeometry,  
    815826                                    bUse3d); 
     827        j++; 
    816828    } 
    817829    return inserted; 
    … …  
    15211533    } 
    15221534 
    1523     LASReader* reader = new LASReader(*istrm); 
     1535    liblas::Reader* reader = new liblas::Reader(*istrm); 
    15241536    LASQuery* query = 0; 
    15251537    if (!KDTreeIndexExists(input)) { 
    … …  
    15531565    std::istream* istrm2; 
    15541566    istrm2 = OpenInput(input, false); 
    1555     LASReader* reader2 = new LASReader(*istrm2); 
     1567    liblas::Reader* reader2 = new liblas::Reader(*istrm2); 
    15561568     
    15571569 

  • apps/las2ogr.cpp

    r1409 r1613  
    296296            throw std::runtime_error(std::string("Can not open \'") + in_file + "\'"); 
    297297        } 
    298         liblas::LASReader reader(ifs); 
     298        liblas::Reader reader(ifs); 
    299299 
    300300        // 
    … …  
    342342        while (reader.ReadNextPoint()) 
    343343        { 
    344             liblas::LASPoint const& p = reader.GetPoint();    
     344            liblas::Point const& p = reader.GetPoint();    
    345345 
    346346            OGR_F_SetFieldInteger(feat, 0, p.GetReturnNumber()); 

  • apps/lasindex.cpp

    r1427 r1613  
    5050using namespace liblas; 
    5151 
    52 void LoadIndex (LASIndex* index, LASReader* reader, long dimension)  
     52void LoadIndex (LASIndex* index, liblas::Reader* reader, long dimension)  
    5353{ 
    5454 
    … …  
    5656    liblas::int64_t id = 0; 
    5757    if (read) { 
    58         const LASPoint& p = reader->GetPoint(); 
    59         index->insert(const_cast<LASPoint&>(p), id); 
     58        const liblas::Point& p = reader->GetPoint(); 
     59        index->insert(const_cast<liblas::Point&>(p), id); 
    6060    } 
    6161    while (reader->ReadNextPoint()) { 
    6262        id += 1; 
    63         const LASPoint& p = reader->GetPoint(); 
    64         index->insert(const_cast<LASPoint&>(p), id); 
     63        const liblas::Point& p = reader->GetPoint(); 
     64        index->insert(const_cast<liblas::Point&>(p), id); 
    6565    } 
    6666} 
    … …  
    135135    // FIXME: Missing RAII and try-catch, no LAS throws exceptions. 
    136136    std::istream* istrm = OpenInput(input); 
    137     LASReader* reader = new LASReader(*istrm); 
     137    liblas::Reader* reader = new liblas::Reader(*istrm); 
    138138    std::cout << "Indexing " << input<< " "<<std::endl; 
    139139 

  • apps/ts2las.cpp

    r1512 r1613  
    6767} 
    6868 
    69 LASHeader CreateHeader(ScanHdr* hdr) 
    70 { 
    71     LASHeader header; 
     69liblas::Header CreateHeader(ScanHdr* hdr) 
     70{ 
     71    liblas::Header header; 
    7272     
    7373    // Checks for time and color values 
    74     liblas::PointFormat format = liblas::ePointFormat0; 
     74    liblas::PointFormatName format = liblas::ePointFormat0; 
    7575     
    7676    if (hdr->Time) { 
    … …  
    124124} 
    125125 
    126 bool WritePoints(LASWriter* writer, std::istream* strm, ScanHdr* hdr)  
     126bool WritePoints(liblas::Writer* writer, std::istream* strm, ScanHdr* hdr)  
    127127{ 
    128128    ScanPnt* point = new ScanPnt; 
    … …  
    148148                    point->Echo = (row->EchoInt >> 14); 
    149149                } 
    150                 LASPoint p; 
     150                Point p; 
    151151 
    152152                p.SetCoordinates(writer->GetHeader(), 
    … …  
    172172                if (hdr->Color) { 
    173173                    liblas::uint8_t r, g, b, a = 0; 
    174                     LASColor color; 
     174                    liblas::Color color; 
    175175                    detail::read_n(r, *strm, sizeof(r)); 
    176176                    detail::read_n(b, *strm, sizeof(b)); 
    … …  
    307307     
    308308    // std::cout << "stream position is: " << istrm->tellg() << std::endl; 
    309     LASHeader header = CreateHeader(hdr); 
    310     LASWriter* writer = new LASWriter(*ostrm, header); 
     309    liblas::Header header = CreateHeader(hdr); 
     310    liblas::Writer* writer = new liblas::Writer(*ostrm, header); 
    311311     
    312312    success = WritePoints(writer, istrm, hdr); 

  • include/liblas/detail/fwd.hpp

    r1547 r1613  
    4646namespace liblas { 
    4747 
    48 class LASHeader; 
    49 class LASPoint; 
    50 class LASReader; 
    51 class LASWriter; 
    52 class LASColor; 
    53 class LASSpatialReference; 
    54 class LASPointFormat; 
     48class Header; 
     49class Point; 
     50class Reader; 
     51class Writer; 
     52class Color; 
     53class SpatialReference; 
     54class PointFormat; 
    5555 
    5656namespace detail { 

  • include/liblas/detail/reader/header.hpp

    r1561 r1613  
    6161    virtual ~Header(); 
    6262 
    63     const LASHeader& GetHeader() const { return m_header; } 
     63    const liblas::Header& GetHeader() const { return m_header; } 
    6464    void read(); 
    6565    void readvlrs(); 
    … …  
    6969     
    7070    std::istream& m_ifs; 
    71     LASHeader m_header; 
     71    liblas::Header m_header; 
    7272 
    7373private: 

  • include/liblas/detail/reader/point.hpp

    r1535 r1613  
    6666public: 
    6767 
    68     Point(std::istream& ifs, const LASHeader& header); 
     68    Point(std::istream& ifs, const liblas::Header& header); 
    6969    Point(  std::istream& ifs,  
    70             const LASHeader& header,  
     70            const liblas::Header& header,  
    7171            OGRCoordinateTransformationH transform); 
    7272    virtual ~Point(); 
    7373 
    7474    std::istream& GetStream() const; 
    75     const LASPoint& GetPoint() const { return m_point; } 
     75    const liblas::Point& GetPoint() const { return m_point; } 
    7676    void read(); 
    7777     
    … …  
    9191 
    9292    std::istream& m_ifs; 
    93     const LASHeader& m_header; 
    94     LASPoint m_point; 
     93    const liblas::Header& m_header; 
     94    liblas::Point m_point; 
    9595    OGRCoordinateTransformationH m_transform; 
    9696     

  • include/liblas/detail/reader/reader.hpp

    r1601 r1613  
    6767    ~ReaderImpl(); 
    6868 
    69     LASHeader const& ReadHeader(); 
    70     LASPoint const& ReadNextPoint(const LASHeader& header); 
    71     LASPoint const& ReadPointAt(std::size_t n, const LASHeader& header); 
     69    liblas::Header const& ReadHeader(); 
     70    liblas::Point const& ReadNextPoint(const liblas::Header& header); 
     71    liblas::Point const& ReadPointAt(std::size_t n, const liblas::Header& header); 
    7272 
    7373    std::istream& GetStream() const; 
    74     void Reset(LASHeader const& header); 
    75     void SetSRS(const LASSpatialReference& srs, const LASHeader& header); 
    76     void SetInputSRS(const LASSpatialReference& srs); 
    77     void SetOutputSRS(const LASSpatialReference& srs, const LASHeader& header); 
     74    void Reset(liblas::Header const& header); 
     75    void SetSRS(const SpatialReference& srs, const liblas::Header& header); 
     76    void SetInputSRS(const SpatialReference& srs); 
     77    void SetOutputSRS(const SpatialReference& srs, const liblas::Header& header); 
    7878 
    7979protected: 
    … …  
    8585    uint32_t m_size; 
    8686    uint32_t m_current; 
    87     LASSpatialReference m_out_srs; 
    88     LASSpatialReference m_in_srs;     
     87    SpatialReference m_out_srs; 
     88    SpatialReference m_in_srs;     
    8989    OGRCoordinateTransformationH m_transform; 
    9090    OGRSpatialReferenceH m_in_ref; 

  • include/liblas/detail/writer/header.hpp

    r1573 r1613  
    6060    typedef WriterBase Base; 
    6161 
    62     Header(std::ostream& ofs, liblas::uint32_t& count, LASHeader const& header ); 
     62    Header(std::ostream& ofs, liblas::uint32_t& count, liblas::Header const& header ); 
    6363 
    64     const LASHeader& GetHeader() const { return m_header; } 
     64    const liblas::Header& GetHeader() const { return m_header; } 
    6565    void write(); 
    6666     
    … …  
    7171    int32_t WriteVLRs(); 
    7272    void WriteLAS10PadSignature(); 
    73     LASHeader m_header; 
     73    liblas::Header m_header; 
    7474     
    7575}; 

  • include/liblas/detail/writer/point.hpp

    r1560 r1613  
    7070    typedef WriterBase Base; 
    7171     
    72     Point(std::ostream& ofs, liblas::uint32_t& count, LASHeader const& header); 
     72    Point(std::ostream& ofs, liblas::uint32_t& count, liblas::Header const& header); 
    7373    Point(  std::ostream& ofs,  
    7474            liblas::uint32_t& count,  
    75             LASHeader const& header, 
     75            liblas::Header const& header, 
    7676            OGRCoordinateTransformationH transform); 
    7777    virtual ~Point(); 
    7878 
    79     const LASPoint& GetPoint() const { return m_point; } 
    80     void write( const LASPoint& ); 
     79    const liblas::Point& GetPoint() const { return m_point; } 
     80    void write( const liblas::Point& ); 
    8181     
    8282protected: 
    … …  
    9595 
    9696    std::ostream& m_ofs; 
    97     const LASHeader& m_header; 
    98     LASPoint m_point; 
     97    const liblas::Header& m_header; 
     98    liblas::Point m_point; 
    9999    OGRCoordinateTransformationH m_transform; 
    100100     

  • include/liblas/detail/writer/writer.hpp

    r1601 r1613  
    5959    ~WriterImpl(); 
    6060    LASVersion GetVersion() const; 
    61     LASHeader const& WriteHeader(LASHeader const& header); 
    62     void UpdateHeader(LASHeader const& header); 
    63     void WritePoint(LASPoint const& record, const LASHeader& header); 
     61    liblas::Header const& WriteHeader(liblas::Header const& header); 
     62    void UpdateHeader(liblas::Header const& header); 
     63    void WritePoint(liblas::Point const& record, const liblas::Header& header); 
    6464 
    6565    std::ostream& GetStream() const; 
    6666 
    67     void SetInputSRS(const LASSpatialReference& srs); 
    68     void SetOutputSRS(const LASSpatialReference& srs, const LASHeader& header); 
     67    void SetInputSRS(const SpatialReference& srs); 
     68    void SetOutputSRS(const SpatialReference& srs, const liblas::Header& header); 
    6969 
    7070protected: 
    … …  
    7272    std::ostream& m_ofs; 
    7373      
    74     LASSpatialReference m_out_srs; 
    75     LASSpatialReference m_in_srs; 
     74    SpatialReference m_out_srs; 
     75    SpatialReference m_in_srs; 
    7676     
    7777    OGRCoordinateTransformationH m_transform; 
    … …  
    9292public: 
    9393 
    94     static WriterImpl* Create(std::ostream& ofs, LASHeader const& header); 
     94    static WriterImpl* Create(std::ostream& ofs, liblas::Header const& header); 
    9595    static void Destroy(WriterImpl* p); 
    9696}; 

  • include/liblas/index/datastream.hpp

    r1433 r1613  
    6666{ 
    6767public: 
    68     LASIndexDataStream(LASReader* reader, long dimension); 
     68    LASIndexDataStream(Reader* reader, long dimension); 
    6969    ~LASIndexDataStream(); 
    7070 
    … …  
    8484     
    8585protected: 
    86     liblas::LASReader* m_reader; 
     86    liblas::Reader* m_reader; 
    8787    SpatialIndex::RTree::Data* m_pNext; 
    8888    SpatialIndex::id_type m_id; 

  • include/liblas/index/index.hpp

    r1421 r1613  
    9292 
    9393     
    94     /// Inserts a LASPoint into the index with a given id 
    95     /// \param p the LASPoint to insert 
     94    /// Inserts a Point into the index with a given id 
     95    /// \param p the Point to insert 
    9696    /// \param id the id to associate with the point 
    97     void insert(LASPoint& p, int64_t id); 
     97    void insert(Point& p, int64_t id); 
    9898     
    9999    /// Intersects the index with the given cube and returns a  
    … …  
    156156    uint32_t GetDimension() { return m_idxDimension; } 
    157157     
    158     LASVariableRecord* GetVLR(); 
     158    liblas::VariableRecord* GetVLR(); 
    159159     
    160160    void Query(LASQuery& query); 

  • include/liblas/index/storage.hpp

    r1402 r1613  
    7575    virtual void deleteByteArray(const SpatialIndex::id_type id); 
    7676     
    77     LASVariableRecord* getVLR() const; 
     77    liblas::VariableRecord* getVLR() const; 
    7878 
    7979private: 
    8080     
    81     LASVariableRecord m_data; 
    82     LASVariableRecord m_ids; 
     81    liblas::VariableRecord m_data; 
     82    liblas::VariableRecord m_ids; 
    8383 
    8484    // class Entry 
    … …  
    9797    // }; // Entry 
    9898     
    99     typedef std::vector<LASVariableRecord*> vlrbuffer_t; 
     99    typedef std::vector<liblas::VariableRecord*> vlrbuffer_t; 
    100100    vlrbuffer_t m_vlrbuffer; 
    101101    std::stack<SpatialIndex::id_type> m_emptyPages; 
    102102 
    103     LASVariableRecord* makeVLR(const std::size_t len, const ::uint8_t* data); 
     103    liblas::VariableRecord* makeVLR(const std::size_t len, const ::uint8_t* data); 
    104104 
    105105}; // MemoryStorageManager 

  • include/liblas/lasclassification.hpp

    r1577 r1613  
    5757/// Class definition to manipulate properties of point record classification. 
    5858/// 
    59 class LASClassification 
     59class Classification 
    6060{ 
    6161public: 
    … …  
    8484    /// Initializes all flags of classification as set to 0. 
    8585    /// Operation semantic is equivalent to bitset_type::reset(). 
    86     LASClassification() {} 
     86    Classification() {} 
    8787 
    8888    /// Initializes classification flags using given set of 8 bits. 
    8989    /// @param flags [in] - contains 8 bits representing classification flags. 
    90     explicit LASClassification(bitset_type const& flags) 
     90    explicit Classification(bitset_type const& flags) 
    9191        : m_flags(flags) 
    9292    {} 
    … …  
    9494    /// Initializes classification flags using 8 bits of integral type. 
    9595    /// @param flags [in] - contains 8 bits representing classification flags. 
    96     explicit LASClassification(uint8_t const& flags) 
     96    explicit Classification(uint8_t const& flags) 
    9797        : m_flags(flags) 
    9898    {} 
    … …  
    106106    /// thus generally should not be withheld in a thinning algorithm. 
    107107    /// @param w [in] - If set, this point should not be included in processing. 
    108     LASClassification(uint8_t cls, bool s, bool k, bool w) 
     108    Classification(uint8_t cls, bool s, bool k, bool w) 
    109109    { 
    110110        SetClass(cls); 
    … …  
    115115 
    116116    /// Copy constructor. 
    117     LASClassification(LASClassification const& other) 
     117    Classification(Classification const& other) 
    118118    { 
    119119        m_flags = other.m_flags; 
    … …  
    121121 
    122122    /// Assignment operator. 
    123     LASClassification& operator=(LASClassification const& rhs) 
     123    Classification& operator=(Classification const& rhs) 
    124124    { 
    125125        if (&rhs != this ) 
    … …  
    219219    /// Comparison is preformed against set of bit flags stored  
    220220    /// in both objects. 
    221     bool equal(LASClassification const& other) const 
     221    bool equal(Classification const& other) const 
    222222    { 
    223223        return (other.m_flags == m_flags); 
    … …  
    240240}; 
    241241 
    242 /// Equal-to operator implemented in terms of LASClassification::equal. 
    243 inline bool operator==(LASClassification const& lhs, LASClassification const& rhs) 
     242/// Equal-to operator implemented in terms of Classification::equal. 
     243inline bool operator==(Classification const& lhs, Classification const& rhs) 
    244244{ 
    245245    return lhs.equal(rhs); 
    246246} 
    247247 
    248 /// Not-equal-to operator implemented in terms of LASClassification::equal. 
    249 inline bool operator!=(LASClassification const& lhs, LASClassification const& rhs) 
     248/// Not-equal-to operator implemented in terms of Classification::equal. 
     249inline bool operator!=(Classification const& lhs, Classification const& rhs) 
    250250{ 
    251251    return (!(lhs == rhs)); 
    … …  
    262262/// bit positions. Bit value zero becomes the character 0, bit value one 
    263263/// becomes the character 1. 
    264 inline std::ostream& operator<<(std::ostream& os, LASClassification const& cls) 
    265 { 
    266     LASClassification::bitset_type flags(cls); 
     264inline std::ostream& operator<<(std::ostream& os, Classification const& cls) 
     265{ 
     266    Classification::bitset_type flags(cls); 
    267267    return (os << flags); 
    268268} 
    269269 
     270// typedef liblas::Classification LASClassification ; 
     271 
     272 
    270273} // namespace liblas 
    271274 

  • include/liblas/lascolor.hpp

    r1577 r1613  
    5454 
    5555/// RGB color container 
    56 class LASColor 
     56class Color 
    5757{ 
    5858public: 
    … …  
    6060    /// Default constructor. 
    6161    /// Initializes with black color using RGB {0, 0, 0}. 
    62     LASColor(); 
     62    Color(); 
    6363 
    6464    // User-defined constructor. 
    6565    // Initializes object with given RGB values. 
    66     LASColor(uint16_t red, uint16_t green, uint16_t blue) 
     66    Color(uint16_t red, uint16_t green, uint16_t blue) 
    6767        : m_red(red), m_green(green), m_blue(blue) 
    6868    {} 
    6969 
    7070    /// Copy constructor. 
    71     LASColor(LASColor const& other); 
     71    Color(Color const& other); 
    7272 
    7373    /// Assignment opreator. 
    74     LASColor& operator=(LASColor const& rhs); 
     74    Color& operator=(Color const& rhs); 
    7575 
    7676    /// Comparison operator. 
    77     bool operator==(const LASColor& other) const; 
     77    bool operator==(const Color& other) const; 
    7878     
    7979    /// Fetch value of the red image channel  
    … …  
    119119 
    120120 
    121 inline uint16_t LASColor::GetRed() const 
     121inline uint16_t Color::GetRed() const 
    122122{ 
    123123    return m_red; 
    124124} 
    125125 
    126 inline void LASColor::SetRed(uint16_t const& value) 
     126inline void Color::SetRed(uint16_t const& value) 
    127127{ 
    128128    m_red = value; 
    129129} 
    130130 
    131 inline uint16_t LASColor::GetBlue() const 
     131inline uint16_t Color::GetBlue() const 
    132132{ 
    133133    return m_blue; 
    134134} 
    135135 
    136 inline void LASColor::SetBlue(uint16_t const& value) 
     136inline void Color::SetBlue(uint16_t const& value) 
    137137{ 
    138138    m_blue = value; 
    139139} 
    140140 
    141 inline uint16_t LASColor::GetGreen() const 
     141inline uint16_t Color::GetGreen() const 
    142142{ 
    143143    return m_green; 
    144144} 
    145145 
    146 inline void LASColor::SetGreen(uint16_t const& value) 
     146inline void Color::SetGreen(uint16_t const& value) 
    147147{ 
    148148    m_green = value; 
    149149} 
    150150 
    151 inline uint16_t& LASColor::operator[](std::size_t const& n) 
     151inline uint16_t& Color::operator[](std::size_t const& n) 
    152152{ 
    153153    if (n == 0) { return m_red; } 
    … …  
    158158} 
    159159 
    160 inline uint16_t const& LASColor::operator[](std::size_t const& n) const 
     160inline uint16_t const& Color::operator[](std::size_t const& n) const 
    161161{ 
    162162    if (n == 0) { return m_red; } 
    … …  
    167167} 
    168168 
     169// typedef liblas::Color LASColor; 
     170 
    169171} // namespace liblas 
    170172 

  • include/liblas/lasformat.hpp

    r1577 r1613  
    5353 
    5454 
    55 class LASPointFormat 
     55class PointFormat 
    5656{ 
    5757public: 
    5858 
    59     LASPointFormat( liblas::uint8_t major,  
     59    PointFormat( liblas::uint8_t major,  
    6060                    liblas::uint8_t minor,  
    6161                    liblas::uint32_t size); 
    6262 
    63     LASPointFormat( liblas::uint8_t major,  
     63    PointFormat( liblas::uint8_t major,  
    6464                    liblas::uint8_t minor,  
    6565                    liblas::uint32_t size, 
    6666                    bool bColor, 
    6767                    bool bTime); 
    68     LASPointFormat& operator=(LASPointFormat const& rhs); 
    69     LASPointFormat(LASPointFormat const& other); 
     68    PointFormat& operator=(PointFormat const& rhs); 
     69    PointFormat(PointFormat const& other); 
    7070     
    71     ~LASPointFormat() {}; 
     71    ~PointFormat() {}; 
    7272 
    7373    /// Fetch byte size 
    … …  
    102102}; 
    103103 
    104 inline uint32_t LASPointFormat::GetByteSize() const 
     104inline uint32_t PointFormat::GetByteSize() const 
    105105{ 
    106106    return m_size; 
    107107} 
    108108 
    109 inline void LASPointFormat::SetByteSize(uint32_t const& value) 
     109inline void PointFormat::SetByteSize(uint32_t const& value) 
    110110{ 
    111111    m_size = value; 
    112112} 
    113113 
    114 inline uint8_t LASPointFormat::GetVersionMajor() const 
     114inline uint8_t PointFormat::GetVersionMajor() const 
    115115{ 
    116116    return m_versionmajor; 
    117117} 
    118118 
    119 inline void LASPointFormat::SetVersionMajor(uint8_t const& value) 
     119inline void PointFormat::SetVersionMajor(uint8_t const& value) 
    120120{ 
    121121    m_versionmajor = value; 
    122122} 
    123123 
    124 inline uint8_t LASPointFormat::GetVersionMinor() const 
     124inline uint8_t PointFormat::GetVersionMinor() const 
    125125{ 
    126126    return m_versionminor; 
    127127} 
    128128 
    129 inline void LASPointFormat::SetVersionMinor(uint8_t const& value) 
     129inline void PointFormat::SetVersionMinor(uint8_t const& value) 
    130130{ 
    131131    m_versionminor = value; 
    132132} 
    133133 
    134 inline bool LASPointFormat::HasColor() const 
     134inline bool PointFormat::HasColor() const 
    135135{ 
    136136    return m_hasColor; 
    137137} 
    138138 
    139 inline void LASPointFormat::Color(bool const& value) 
     139inline void PointFormat::Color(bool const& value) 
    140140{ 
    141141    m_hasColor = value; 
    … …  
    143143} 
    144144 
    145 inline bool LASPointFormat::HasTime() const 
     145inline bool PointFormat::HasTime() const 
    146146{ 
    147147    return m_hasTime; 
    148148} 
    149149 
    150 inline void LASPointFormat::Time(bool const& value) 
     150inline void PointFormat::Time(bool const& value) 
    151151{ 
    152152    m_hasTime = value; 
    153153    updatesize(); 
    154154} 
     155 
     156typedef liblas::PointFormat LASPointFormat ; 
    155157} // namespace liblas 
    156158 

  • include/liblas/lasheader.hpp

    r1577 r1613  
    6868///        with std::string and return const-reference to string object. 
    6969/// 
    70 class LASHeader 
     70class Header 
    7171{ 
    7272public: 
    … …  
    9090    /// LAS 1.2 Specification, point data format set to 0. 
    9191    /// Other fields filled with 0. 
    92     LASHeader(); 
     92    Header(); 
    9393 
    9494    /// Copy constructor. 
    95     LASHeader(LASHeader const& other); 
     95    Header(Header const& other); 
    9696 
    9797    /// Assignment operator. 
    98     LASHeader& operator=(LASHeader const& rhs); 
     98    Header& operator=(Header const& rhs); 
    9999     
    100100    /// Comparison operator. 
    101     bool operator==(const LASHeader& other) const; 
     101    bool operator==(const Header& other) const; 
    102102 
    103103    /// Get ASPRS LAS file signature. 
    … …  
    222222     
    223223    /// Get identifier of point data (record) format. 
    224     PointFormat GetDataFormatId() const; 
     224    PointFormatName GetDataFormatId() const; 
    225225 
    226226    /// Set identifier of point data (record) format. 
    227     void SetDataFormatId(PointFormat v); 
     227    void SetDataFormatId(PointFormatName v); 
    228228 
    229229    /// \todo To be documented 
    … …  
    299299 
    300300    /// Adds a variable length record to the header 
    301     void AddVLR(LASVariableRecord const& v); 
     301    void AddVLR(VariableRecord const& v); 
    302302     
    303303    /// Returns a VLR  
    304     LASVariableRecord const& GetVLR(uint32_t index) const; 
     304    VariableRecord const& GetVLR(uint32_t index) const; 
    305305     
    306306    /// Returns all of the VLRs 
    307     const std::vector<LASVariableRecord>& GetVLRs() const; 
     307    const std::vector<VariableRecord>& GetVLRs() const; 
    308308 
    309309    /// Removes a VLR from the the header. 
    … …  
    314314     
    315315    /// Fetch the georeference 
    316     LASSpatialReference GetSRS() const; 
     316    SpatialReference GetSRS() const; 
    317317     
    318318    /// Set the georeference 
    319     void SetSRS(LASSpatialReference& srs); 
    320  
    321     LASPointFormat GetPointFormat() const; 
    322     void SetPointFormat(const LASPointFormat& format); 
     319    void SetSRS(SpatialReference& srs); 
     320 
     321    PointFormat GetPointFormat() const; 
     322    void SetPointFormat(const PointFormat& format); 
    323323     
    324324private: 
    … …  
    375375    PointOffsets m_offsets; 
    376376    PointExtents m_extents; 
    377     std::vector<LASVariableRecord> m_vlrs; 
    378     LASSpatialReference m_srs; 
     377    std::vector<VariableRecord> m_vlrs; 
     378    SpatialReference m_srs; 
    379379}; 
    380380 
     381// typedef liblas::Header LASHeader ; 
    381382} // namespace liblas 
    382383 

  • include/liblas/laspoint.hpp

    r1540 r1613  
    5757 
    5858/// Point data record composed with X, Y, Z coordinates and attributes. 
    59 class LASPoint 
     59class Point 
    6060{ 
    6161public: 
    … …  
    9797    }; 
    9898 
    99     LASPoint(); 
    100     LASPoint(LASPoint const& other); 
    101     LASPoint& operator=(LASPoint const& rhs); 
     99    Point(); 
     100    Point(Point const& other); 
     101    Point& operator=(Point const& rhs); 
    102102 
    103103    double GetX() const; 
    … …  
    105105    double GetZ() const; 
    106106    void SetCoordinates(double const& x, double const& y, double const& z); 
    107     void SetCoordinates(LASHeader const& header, double x, double y, double z); 
     107    void SetCoordinates(Header const& header, double x, double y, double z); 
    108108     
    109109    void SetX(double const& value); 
    … …  
    138138    void SetFlightLineEdge(uint16_t const& edge); 
    139139 
    140     //LASClassification& GetClassification(); 
    141     LASClassification const& GetClassification() const; 
    142     void SetClassification(LASClassification const& cls); 
    143     void SetClassification(LASClassification::bitset_type const& flags); 
     140    //Classification& GetClassification(); 
     141    Classification const& GetClassification() const; 
     142    void SetClassification(Classification const& cls); 
     143    void SetClassification(Classification::bitset_type const& flags); 
    144144    void SetClassification(liblas::uint8_t const& flags); 
    145145 
    … …  
    160160 
    161161    /// Fetch color value associated with this point (LAS 1.2) 
    162     LASColor const& GetColor() const; 
     162    Color const& GetColor() const; 
    163163 
    164164    /// Set color value associated with this point (LAS 1.2) 
    165     void SetColor(LASColor const& value); 
     165    void SetColor(Color const& value); 
    166166 
    167167                 
    … …  
    180180 
    181181    /// \todo TODO: Should we compare other data members, but not only coordinates? 
    182     bool equal(LASPoint const& other) const; 
     182    bool equal(Point const& other) const; 
    183183 
    184184    bool Validate() const; 
    … …  
    195195    double m_coords[coords_size]; 
    196196    double m_gpsTime; 
    197     LASColor m_color; 
    198     LASClassification m_cls; 
     197    Color m_color; 
     198    Classification m_cls; 
    199199    uint16_t m_intensity; 
    200200    uint16_t m_pointSourceId; 
    … …  
    211211}; 
    212212 
    213 /// Equal-to operator implemented in terms of LASPoint::equal method. 
    214 inline bool operator==(LASPoint const& lhs, LASPoint const& rhs) 
     213/// Equal-to operator implemented in terms of Point::equal method. 
     214inline bool operator==(Point const& lhs, Point const& rhs) 
    215215{ 
    216216    return lhs.equal(rhs); 
    217217} 
    218218 
    219 /// Not-equal-to operator implemented in terms of LASPoint::equal method. 
    220 inline bool operator!=(LASPoint const& lhs, LASPoint const& rhs) 
     219/// Not-equal-to operator implemented in terms of Point::equal method. 
     220inline bool operator!=(Point const& lhs, Point const& rhs) 
    221221{ 
    222222    return (!(lhs == rhs)); 
    223223} 
    224224 
    225 inline void LASPoint::SetCoordinates(double const& x, double const& y, double const& z) 
     225inline void Point::SetCoordinates(double const& x, double const& y, double const& z) 
    226226{ 
    227227    m_coords[0] = x; 
    … …  
    230230} 
    231231 
    232 inline double LASPoint::GetX() const 
     232inline double Point::GetX() const 
    233233{ 
    234234    return m_coords[0]; 
    235235} 
    236236 
    237 inline void LASPoint::SetX( double const& value )  
     237inline void Point::SetX( double const& value )  
    238238{ 
    239239    m_coords[0] = value; 
    240240} 
    241241 
    242 inline double LASPoint::GetY() const 
     242inline double Point::GetY() const 
    243243{ 
    244244    return m_coords[1]; 
    245245} 
    246246 
    247 inline void LASPoint::SetY( double const& value )  
     247inline void Point::SetY( double const& value )  
    248248{ 
    249249    m_coords[1] = value; 
    250250} 
    251251 
    252 inline double LASPoint::GetZ() const 
     252inline double Point::GetZ() const 
    253253{ 
    254254    return m_coords[2]; 
    255255} 
    256256 
    257 inline void LASPoint::SetZ( double const& value )  
     257inline void Point::SetZ( double const& value )  
    258258{ 
    259259    m_coords[2] = value; 
    260260} 
    261261 
    262 inline uint16_t LASPoint::GetIntensity() const 
     262inline uint16_t Point::GetIntensity() const 
    263263{ 
    264264    return m_intensity; 
    265265} 
    266266 
    267 inline void LASPoint::SetIntensity(uint16_t const& intensity) 
     267inline void Point::SetIntensity(uint16_t const& intensity) 
    268268{ 
    269269    m_intensity = intensity; 
    270270} 
    271271 
    272 inline uint16_t LASPoint::GetReturnNumber() const 
     272inline uint16_t Point::GetReturnNumber() const 
    273273{ 
    274274    // Read bits 1,2,3 (first 3 bits) 
    … …  
    276276} 
    277277 
    278 inline uint16_t LASPoint::GetNumberOfReturns() const 
     278inline uint16_t Point::GetNumberOfReturns() const 
    279279{ 
    280280    // Read bits 4,5,6 
    … …  
    282282} 
    283283 
    284 inline uint16_t LASPoint::GetScanDirection() const 
     284inline uint16_t Point::GetScanDirection() const 
    285285{ 
    286286    // Read 7th bit 
    … …  
    288288} 
    289289 
    290 inline uint16_t LASPoint::GetFlightLineEdge() const 
     290inline uint16_t Point::GetFlightLineEdge() const 
    291291{ 
    292292    // Read 8th bit 
    … …  
    294294} 
    295295 
    296 inline uint8_t LASPoint::GetScanFlags() const 
     296inline uint8_t Point::GetScanFlags() const 
    297297{ 
    298298    return m_flags; 
    299299} 
    300300 
    301 inline void LASPoint::SetScanFlags(uint8_t const& flags) 
     301inline void Point::SetScanFlags(uint8_t const& flags) 
    302302{ 
    303303    m_flags = flags; 
    304304} 
    305305 
    306 inline int8_t LASPoint::GetScanAngleRank() const 
     306inline int8_t Point::GetScanAngleRank() const 
    307307{ 
    308308    return m_angleRank; 
    309309} 
    310310 
    311 inline uint8_t LASPoint::GetUserData() const 
     311inline uint8_t Point::GetUserData() const 
    312312{ 
    313313    return m_userData; 
    314314} 
    315315 
    316 inline uint16_t LASPoint::GetPointSourceID() const 
     316inline uint16_t Point::GetPointSourceID() const 
    317317{ 
    318318    return m_pointSourceId; 
    319319} 
    320320 
    321 inline void LASPoint::SetPointSourceID(uint16_t const& id) 
     321inline void Point::SetPointSourceID(uint16_t const& id) 
    322322{ 
    323323    m_pointSourceId = id; 
    324324} 
    325325 
    326 inline double LASPoint::GetTime() const 
     326inline double Point::GetTime() const 
    327327{ 
    328328    return m_gpsTime; 
    329329} 
    330330 
    331 inline void LASPoint::SetTime(double const& time) 
     331inline void Point::SetTime(double const& time) 
    332332{ 
    333333    m_gpsTime = time; 
    334334} 
    335335 
    336 inline LASColor const& LASPoint::GetColor() const 
     336inline Color const& Point::GetColor() const 
    337337{ 
    338338    return m_color; 
    339339} 
    340340 
    341 inline void LASPoint::SetColor(LASColor const& value) 
     341inline void Point::SetColor(Color const& value) 
    342342{ 
    343343    m_color = value; 
    … …  
    345345 
    346346 
    347 inline double& LASPoint::operator[](std::size_t const& n) 
     347inline double& Point::operator[](std::size_t const& n) 
    348348{ 
    349349    if (coords_size <= n) 
    … …  
    353353} 
    354354 
    355 inline double const& LASPoint::operator[](std::size_t const& n) const 
     355inline double const& Point::operator[](std::size_t const& n) const 
    356356{ 
    357357    if (coords_size <= n) 
    … …  
    361361} 
    362362 
     363// typedef liblas::Point LASPoint; 
     364 
    363365} // namespace liblas 
    364366 

  • include/liblas/lasreader.hpp

    r1601 r1613  
    6363 
    6464/// Defines public interface to LAS reader implementation. 
    65 class LASReader 
     65class Reader 
    6666{ 
    6767public: 
    … …  
    7070    /// @param ifs - stream used as source of LAS records. 
    7171    /// @excepion std::runtime_error - on failure state of the input stream. 
    72     LASReader(std::istream& ifs); 
     72    Reader(std::istream& ifs); 
    7373 
    74     LASReader(ReaderI* reader); 
     74    Reader(ReaderI* reader); 
    7575     
    7676    /// User-defined consructor initializes reader with input stream and 
    7777    /// a header to override the values in the file 
    7878    /// @excepion std::runtime_error - on failure state of the input stream. 
    79     LASReader(std::istream& ifs, LASHeader& header); 
     79    Reader(std::istream& ifs, Header& header); 
    8080     
    8181    /// Destructor. 
    8282    /// @excepion nothrow 
    83     ~LASReader(); 
     83    ~Reader(); 
    8484     
    8585    /// Provides read-only access to header of LAS file being read. 
    8686    /// @excepion nothrow 
    87     LASHeader const& GetHeader() const; 
     87    Header const& GetHeader() const; 
    8888 
    8989    /// Provides read-only access to current point record. 
    9090    /// @excepion nothrow 
    91     LASPoint const& GetPoint() const; 
     91    Point const& GetPoint() const; 
    9292 
    9393    /// Provides read-only access to collection of variable-length records. 
    9494    /// @excepion nothrow 
    95     std::vector<LASVariableRecord> const& GetVLRs() const; 
     95    std::vector<VariableRecord> const& GetVLRs() const; 
    9696 
    9797    /// Allow fetching of the stream attached to the reader. 
    … …  
    114114    void Reset(); 
    115115 
    116     /// Reproject data as they are written if the LASReader's reference is 
    117     /// different than the LASHeader's. 
     116    /// Reproject data as they are written if the Reader's reference is 
     117    /// different than the Header's. 
    118118    /// @excepion may throw std::exception 
    119     bool SetSRS(const LASSpatialReference& ref); 
     119    bool SetSRS(const SpatialReference& ref); 
    120120     
    121     /// Override the spatial reference of the LASReader's LASHeader for  
     121    /// Override the spatial reference of the Reader's Header for  
    122122    /// writing purposes. 
    123123    /// @excepion may throw std::exception 
    124     bool SetInputSRS(const LASSpatialReference& ref); 
     124    bool SetInputSRS(const SpatialReference& ref); 
    125125 
    126     /// Override the spatial reference of the LASReader's LASHeader for  
     126    /// Override the spatial reference of the Reader's Header for  
    127127    /// writing purposes. 
    128128    /// @excepion may throw std::exception 
    129     bool SetOutputSRS(const LASSpatialReference& ref); 
     129    bool SetOutputSRS(const SpatialReference& ref); 
    130130 
    131131    /// Provides index-based access to point records. 
    … …  
    133133    /// and is not const-qualified because it updates file stream position. 
    134134    /// @excepion may throw std::exception 
    135     LASPoint const& operator[](std::size_t n); 
     135    Point const& operator[](std::size_t n); 
    136136 
    137137private: 
    138138 
    139139    // Blocked copying operations, declared but not defined. 
    140     LASReader(LASReader const& other); 
    141     LASReader& operator=(LASReader const& rhs); 
     140    Reader(Reader const& other); 
     141    Reader& operator=(Reader const& rhs); 
    142142 
    143143    void Init(); // throws on error 
    144144 
    145145    const std::auto_ptr<ReaderI> m_pimpl; 
    146     LASHeader m_header; 
    147     LASPoint* m_point; 
    148     LASPoint* m_empty_point; 
     146    Header m_header; 
     147    Point* m_point; 
     148    Point* m_empty_point; 
    149149     
    150150    // Set if the user provides a header to override the header as  
    … …  
    157157 
    158158 
     159// typedef liblas::Reader LASReader; 
    159160 
    160161} // namespace liblas 

  • include/liblas/lasspatialreference.hpp

    r1577 r1613  
    9191 
    9292/// Spatial Reference System container for libLAS 
    93 class LASSpatialReference 
     93class SpatialReference 
    9494{ 
    9595public: 
    … …  
    101101 
    102102    /// Default constructor. 
    103     LASSpatialReference(); 
     103    SpatialReference(); 
    104104 
    105105    /// Destructor. 
    106106    /// If libgeotiff is enabled, deallocates libtiff and libgeotiff objects used internally. 
    107     ~LASSpatialReference(); 
    108  
    109     /// Constructor creating LASSpatialReference instance from given Variable-Length Record. 
    110     LASSpatialReference(const std::vector<LASVariableRecord>& vlrs); 
     107    ~SpatialReference(); 
     108 
     109    /// Constructor creating SpatialReference instance from given Variable-Length Record. 
     110    SpatialReference(const std::vector<VariableRecord>& vlrs); 
    111111 
    112112    /// Copy constryctor. 
    113     LASSpatialReference(LASSpatialReference const& other); 
     113    SpatialReference(SpatialReference const& other); 
    114114 
    115115    /// Assignment operator. 
    116     LASSpatialReference& operator=(LASSpatialReference const& rhs); 
     116    SpatialReference& operator=(SpatialReference const& rhs); 
    117117     
    118118    /// Returns a pointer to the internal GTIF*.  Only available if  
    … …  
    174174    void SetProj4(std::string const& v); 
    175175     
    176     /// Set the LASVLRs for the LASSpatialReference.  SetVLRs will only copy  
     176    /// Set the LASVLRs for the SpatialReference.  SetVLRs will only copy  
    177177    /// VLR records that pertain to the GeoTIFF keys, and extraneous  
    178178    /// VLR records will not be copied. 
    179179    /// \param vlrs - A list of VLRs that contains VLRs describing GeoTIFF keys 
    180     void SetVLRs(const std::vector<LASVariableRecord>& vlrs); 
     180    void SetVLRs(const std::vector<VariableRecord>& vlrs); 
    181181     
    182182    /// Add a VLR representing GeoTIFF keys to the SRS 
    183     void AddVLR(const LASVariableRecord& vlr); 
    184      
    185     /// Return a copy of the LASVLRs that LASSpatialReference maintains 
    186     std::vector<LASVariableRecord> GetVLRs() const; 
     183    void AddVLR(const VariableRecord& vlr); 
     184     
     185    /// Return a copy of the LASVLRs that SpatialReference maintains 
     186    std::vector<VariableRecord> GetVLRs() const; 
    187187 
    188188private: 
    … …  
    191191    ST_TIFF* m_tiff; 
    192192 
    193     std::vector<LASVariableRecord> m_vlrs; 
    194     bool IsGeoVLR(const LASVariableRecord& vlr) const; 
    195  
    196     /// Reset the VLRs of the LASSpatialReference using the existing GTIF* and ST_TIF* 
     193    std::vector<VariableRecord> m_vlrs; 
     194    bool IsGeoVLR(const VariableRecord& vlr) const; 
     195 
     196    /// Reset the VLRs of the SpatialReference using the existing GTIF* and ST_TIF* 
    197197    /// Until this method is called,  
    198     /// the LASSpatialReference will only contain a SRS description using the VLRs  
     198    /// the SpatialReference will only contain a SRS description using the VLRs  
    199199    /// that it was first instantiated with.  SetWKT and SetProj4 can  
    200200    /// be used to change the GTIF*  
    … …  
    202202}; 
    203203 
     204// typedef liblas::SpatialReference LASSpatialReference; 
    204205} // namespace liblas 
    205206 

  • include/liblas/lasvariablerecord.hpp

    r1577 r1613  
    5555 
    5656/// Representation of variable-length record data. 
    57 class LASVariableRecord 
     57class VariableRecord 
    5858{ 
    5959public: 
    … …  
    6262    /// Zero-initialization of record data. 
    6363    /// \exception No throw 
    64     LASVariableRecord();  
     64    VariableRecord();  
    6565 
    6666    /// Copy constructor. 
    6767    /// Construction of new record object as a copy of existing one. 
    6868    /// \exception No throw 
    69     LASVariableRecord(LASVariableRecord const& other); 
     69    VariableRecord(VariableRecord const& other); 
    7070     
    71     ~LASVariableRecord(); 
     71    ~VariableRecord(); 
    7272 
    7373    /// Assignment operator. 
    … …  
    7575    /// assignment of another one. 
    7676    /// \exception No throw 
    77     LASVariableRecord& operator=(LASVariableRecord const& rhs); 
     77    VariableRecord& operator=(VariableRecord const& rhs); 
    7878 
    7979    /// Get record signature (LAS 1.0) or reserved bytes (LAS 1.1). 
    … …  
    117117    /// Compare actual header object against the other. 
    118118    /// \exception No throw 
    119     bool equal(LASVariableRecord const& other) const; 
     119    bool equal(VariableRecord const& other) const; 
    120120 
    121121    /// Get the total size of the VLR in bytes 
    … …  
    141141 
    142142/// Equality operator. 
    143 /// Implemented in terms of LASVariableRecord::equal member function. 
     143/// Implemented in terms of VariableRecord::equal member function. 
    144144/// \exception No throw 
    145 inline bool operator==(LASVariableRecord const& lhs, LASVariableRecord const& rhs) 
     145inline bool operator==(VariableRecord const& lhs, VariableRecord const& rhs) 
    146146{ 
    147147    return lhs.equal(rhs); 
    … …  
    151151/// Implemented in terms of LASRecordHeader::equal member function. 
    152152/// \exception No throw 
    153 inline bool operator!=(LASVariableRecord const& lhs, LASVariableRecord const& rhs) 
     153inline bool operator!=(VariableRecord const& lhs, VariableRecord const& rhs) 
    154154{ 
    155155    return (!(lhs == rhs)); 
    156156} 
    157157 
     158// typedef liblas::VariableRecord LASVariableRecord ; 
     159 
    158160} // namespace liblas 
    159161 

  • include/liblas/laswriter.hpp

    r1601 r1613  
    5858{ 
    5959 
     60 
     61 
    6062/// Defines public interface to LAS writer implementation. 
    6163/// This class  
    62 class LASWriter 
     64class Writer 
    6365{ 
    6466public: 
    … …  
    6870    /// @param header - specifies obligatory properties of LAS file. 
    6971    /// @excepion std::runtime_error - on failure state of the input stream. 
    70     LASWriter(std::ostream& ofs, LASHeader const& header); 
     72    Writer(std::ostream& ofs, Header const& header); 
    7173 
    7274    /// Destructor does not close file attached to the output stream 
    7375    /// Header may be updated after writing operation completed, if necessary 
    7476    /// in order to maintain data consistency. 
    75     ~LASWriter(); 
     77    ~Writer(); 
    7678     
    7779    /// Provides access to header structure. 
    78     LASHeader const& GetHeader() const; 
     80    Header const& GetHeader() const; 
    7981 
    8082    /// \todo TODO: Move point record composition deep into writer implementation. 
    8183    /// \todo TODO: How to handle point_source_id in portable way, for LAS 1.0 and 1.1 
    82     bool WritePoint(LASPoint const& point); 
     84    bool WritePoint(Point const& point); 
    8385 
    8486    /// Allow fetching of the stream 
    … …  
    8688     
    8789    /// Allow in-place writing of header 
    88     void WriteHeader(LASHeader& header); 
     90    void WriteHeader(Header& header); 
    8991 
    90     /// Reproject data as they are written if the LASWriter's reference is 
    91     /// different than the LASHeader's 
    92     bool SetSRS(const LASSpatialReference& ref); 
    93     bool SetInputSRS(const LASSpatialReference& ref); 
    94     bool SetOutputSRS(const LASSpatialReference& ref); 
     92    /// Reproject data as they are written if the Writer's reference is 
     93    /// different than the Header's 
     94    bool SetSRS(const SpatialReference& ref); 
     95    bool SetInputSRS(const SpatialReference& ref); 
     96    bool SetOutputSRS(const SpatialReference& ref); 
    9597     
    9698private: 
    9799     
    98100    // Blocked copying operations, declared but not defined. 
    99     LASWriter(LASWriter const& other); 
    100     LASWriter& operator=(LASWriter const& rhs); 
     101    Writer(Writer const& other); 
     102    Writer& operator=(Writer const& rhs); 
    101103 
    102104    const std::auto_ptr<WriterI> m_pimpl; 
    103105 
    104     LASHeader m_header; 
     106    Header m_header; 
    105107    detail::PointRecord m_record; 
    106108    std::ostream& m_ofs; 
    … …  
    108110}; 
    109111 
     112// typedef liblas::Writer LASWriter ; 
     113 
    110114} // namespace liblas 
    111115 

  • include/liblas/liblas.hpp

    r1601 r1613  
    129129 
    130130/// Versions of point record format. 
    131 enum PointFormat 
     131enum PointFormatName 
    132132{ 
    133133    ePointFormat0 = 0, ///< Point Data Format \e 0 
    … …  
    153153public: 
    154154 
    155     virtual LASHeader const& ReadHeader() = 0; 
    156     virtual LASPoint const& ReadNextPoint(const LASHeader& header) = 0; 
    157     virtual LASPoint const& ReadPointAt(std::size_t n, const LASHeader& header) = 0; 
     155    virtual Header const& ReadHeader() = 0; 
     156    virtual Point const& ReadNextPoint(const Header& header) = 0; 
     157    virtual Point const& ReadPointAt(std::size_t n, const Header& header) = 0; 
    158158 
    159     virtual void Reset(const LASHeader& header) = 0; 
    160     virtual void SetInputSRS(const LASSpatialReference& srs) = 0; 
    161     virtual void SetOutputSRS(const LASSpatialReference& srs, const LASHeader& header) = 0; 
     159    virtual void Reset(const Header& header) = 0; 
     160    virtual void SetInputSRS(const SpatialReference& srs) = 0; 
     161    virtual void SetOutputSRS(const SpatialReference& srs, const Header& header) = 0; 
    162162 
    163163    virtual ~ReaderI() {};     
    … …  
    168168public: 
    169169 
    170     virtual LASHeader const& WriteHeader(const LASHeader& header) = 0; 
    171     virtual void UpdateHeader(const LASHeader& header) = 0; 
    172     virtual void WritePoint(const LASPoint& point, const LASHeader& header) = 0; 
     170    virtual Header const& WriteHeader(const Header& header) = 0; 
     171    virtual void UpdateHeader(const Header& header) = 0; 
     172    virtual void WritePoint(const Point& point, const Header& header) = 0; 
    173173 
    174     virtual void SetInputSRS(const LASSpatialReference& srs) = 0; 
    175     virtual void SetOutputSRS(const LASSpatialReference& srs, const LASHeader& header) = 0; 
     174    virtual void SetInputSRS(const SpatialReference& srs) = 0; 
     175    virtual void SetOutputSRS(const SpatialReference& srs, const Header& header) = 0; 
    176176 
    177177    virtual ~WriterI() {};     
    178178 
    179179}; 
     180 
     181 
     182 
    180183} // namespace liblas 
    181184 

  • src/detail/reader/header.cpp

    r1561 r1613  
    297297        read_n(data.front(), m_ifs, length); 
    298298          
    299         LASVariableRecord vlr; 
     299        VariableRecord vlr; 
    300300        vlr.SetReserved(vlrh.reserved); 
    301301        vlr.SetUserId(std::string(vlrh.userId)); 
    … …  
    308308    } 
    309309 
    310     LASSpatialReference srs(m_header.GetVLRs());     
     310    liblas::SpatialReference srs(m_header.GetVLRs());     
    311311    m_header.SetSRS(srs); 
    312312 

  • src/detail/reader/point.cpp

    r1562 r1613  
    4444#include <liblas/detail/utility.hpp> 
    4545#include <liblas/lasheader.hpp> 
    46 #include <liblas/lasvariablerecord.hpp> 
    4746 
    4847#include <sstream>  
    … …  
    5554} 
    5655 
    57 Point::Point(std::istream& ifs, const LASHeader& header) : 
    58     m_ifs(ifs), m_header(header), m_point(LASPoint()), m_transform(0) 
     56Point::Point(std::istream& ifs, const liblas::Header& header) : 
     57    m_ifs(ifs), m_header(header), m_point(liblas::Point()), m_transform(0) 
    5958{ 
    6059    setup(); 
    … …  
    6261 
    6362Point::Point(   std::istream& ifs,  
    64                 const LASHeader& header,  
     63                const liblas::Header& header,  
    6564                OGRCoordinateTransformationH transform) : 
    66     m_ifs(ifs), m_header(header), m_point(LASPoint()), m_transform(transform) 
     65    m_ifs(ifs), m_header(header), m_point(liblas::Point()), m_transform(transform) 
    6766{ 
    6867    setup(); 
    … …  
    121120            detail::read_n(blue, m_ifs, sizeof(uint16_t)); 
    122121 
    123             LASColor color(red, green, blue); 
     122            liblas::Color color(red, green, blue); 
    124123            m_point.SetColor(color); 
    125124             
    … …  
    133132            detail::read_n(blue, m_ifs, sizeof(uint16_t)); 
    134133 
    135             LASColor color(red, green, blue); 
     134            liblas::Color color(red, green, blue); 
    136135            m_point.SetColor(color); 
    137136             

  • src/detail/reader/reader.cpp

    r1568 r1613  
    4343 
    4444#include <liblas/detail/utility.hpp> 
    45 #include <liblas/lasvariablerecord.hpp> 
    4645#include <liblas/liblas.hpp> 
    4746#include <liblas/lasheader.hpp> 
    … …  
    9493} 
    9594 
    96 void ReaderImpl::Reset(LASHeader const& header) 
     95void ReaderImpl::Reset(liblas::Header const& header) 
    9796{ 
    9897    m_ifs.clear(); 
    … …  
    114113} 
    115114 
    116 void ReaderImpl::SetOutputSRS(const LASSpatialReference& srs, const LASHeader& header) 
     115void ReaderImpl::SetOutputSRS(const SpatialReference& srs, const liblas::Header& header) 
    117116{ 
    118117    m_out_srs = srs; 
    … …  
    127126} 
    128127 
    129 void ReaderImpl::SetSRS(const LASSpatialReference& srs, const LASHeader& header) 
     128void ReaderImpl::SetSRS(const SpatialReference& srs, const liblas::Header& header) 
    130129{ 
    131130    SetOutputSRS(srs, header); 
    132131} 
    133132 
    134 void ReaderImpl::SetInputSRS(const LASSpatialReference& srs) 
     133void ReaderImpl::SetInputSRS(const SpatialReference& srs) 
    135134{ 
    136135    m_in_srs = srs; 
    … …  
    181180 
    182181 
    183 LASHeader const& ReaderImpl::ReadHeader() 
     182liblas::Header const& ReaderImpl::ReadHeader() 
    184183{ 
    185184    m_header_reader->read(); 
    186     const LASHeader& header = m_header_reader->GetHeader(); 
     185    const liblas::Header& header = m_header_reader->GetHeader(); 
    187186     
    188187    Reset(header); 
    … …  
    195194} 
    196195 
    197 LASPoint const& ReaderImpl::ReadNextPoint(const LASHeader& header) 
     196liblas::Point const& ReaderImpl::ReadNextPoint(const liblas::Header& header) 
    198197{ 
    199198    if (0 == m_current) 
    … …  
    207206    { 
    208207        m_point_reader->read(); 
    209         const LASPoint& point = m_point_reader->GetPoint(); 
     208        const liblas::Point& point = m_point_reader->GetPoint(); 
    210209        ++m_current; 
    211210        return point; 
    … …  
    220219} 
    221220 
    222 LASPoint const& ReaderImpl::ReadPointAt(std::size_t n, const LASHeader& header) 
     221liblas::Point const& ReaderImpl::ReadPointAt(std::size_t n, const liblas::Header& header) 
    223222{ 
    224223    // FIXME: Throw in this case. 
    … …  
    238237 
    239238    m_point_reader->read(); 
    240     const LASPoint& point = m_point_reader->GetPoint(); 
     239        const liblas::Point& point = m_point_reader->GetPoint(); 
    241240     
    242241    return point; 

  • src/detail/writer/header.cpp

    r1553 r1613  
    5959namespace liblas { namespace detail { namespace writer { 
    6060 
    61 Header::Header(std::ostream& ofs, liblas::uint32_t& count, LASHeader const& header) : 
     61Header::Header(std::ostream& ofs, liblas::uint32_t& count, liblas::Header const& header) : 
    6262    Base(ofs, count) 
    6363{ 
    … …  
    282282    for (uint32_t i = 0; i < m_header.GetRecordsCount(); ++i) 
    283283    { 
    284         LASVariableRecord vlr = m_header.GetVLR(i); 
     284        VariableRecord vlr = m_header.GetVLR(i); 
    285285        vlr_total_size += vlr.GetTotalSize(); 
    286286    } 
    … …  
    295295    for (uint32_t i = 0; i < m_header.GetRecordsCount(); ++i) 
    296296    { 
    297         LASVariableRecord vlr = m_header.GetVLR(i); 
     297        VariableRecord vlr = m_header.GetVLR(i); 
    298298 
    299299        detail::write_n(GetStream(), vlr.GetReserved(), sizeof(uint16_t)); 

  • src/detail/writer/point.cpp

    r1569 r1613  
    5858Point::Point(   std::ostream& ofs,  
    5959                liblas::uint32_t& count,  
    60                 const LASHeader& header) :  
     60                const liblas::Header& header) :  
    6161    Base(ofs, count),  
    6262    m_ofs(ofs),  
    6363    m_header(header),  
    64     m_point(LASPoint()),  
     64    m_point(liblas::Point()),  
    6565    m_transform(0) 
    6666{ 
    … …  
    7070Point::Point(   std::ostream& ofs,  
    7171                liblas::uint32_t& count, 
    72                 const LASHeader& header,  
     72                const liblas::Header& header,  
    7373                OGRCoordinateTransformationH transform) : Base(ofs, count), 
    74     m_ofs(ofs), m_header(header), m_point(LASPoint()), m_transform(transform) 
     74    m_ofs(ofs), m_header(header), m_point(liblas::Point()), m_transform(transform) 
    7575 
    7676{ 
    … …  
    8484 
    8585 
    86 void Point::write(const LASPoint& point) 
     86void Point::write(const liblas::Point& point) 
    8787{ 
    8888    double t = 0; 
    … …  
    9090    uint16_t blue = 0; 
    9191    uint16_t green = 0; 
    92     LASColor color; 
     92    liblas::Color color; 
    9393     
    9494    // std::size_t byteswritten(0); 
    … …  
    155155     
    156156    int ret = 0; 
    157     LASPoint& p = m_point; 
     157    liblas::Point& p = m_point; 
    158158     
    159159    double x = p.GetX(); 
    … …  
    178178void Point::fill()  
    179179{ 
    180     LASPoint& p = m_point; 
     180    liblas::Point& p = m_point; 
    181181    if (m_transform) { 
    182182         
    … …  
    191191    } 
    192192 
    193     LASClassification::bitset_type clsflags(p.GetClassification()); 
     193    Classification::bitset_type clsflags(p.GetClassification()); 
    194194    m_record.classification = static_cast<uint8_t>(clsflags.to_ulong()); 
    195195 

  • src/detail/writer/writer.cpp

    r1573 r1613  
    6868 
    6969 
    70 LASHeader const&  WriterImpl::WriteHeader(LASHeader const& header) 
     70liblas::Header const&  WriterImpl::WriteHeader(liblas::Header const& header) 
    7171{ 
    7272    m_header_writer = new detail::writer::Header(m_ofs,m_pointCount, header ); 
    … …  
    7575} 
    7676 
    77 void WriterImpl::UpdateHeader(LASHeader const& header) 
     77void WriterImpl::UpdateHeader(liblas::Header const& header) 
    7878{ 
    7979    if (m_pointCount != header.GetPointRecordsCount()) 
    … …  
    8787} 
    8888 
    89 void WriterImpl::WritePoint(LASPoint const& point, const LASHeader& header) 
     89void WriterImpl::WritePoint(liblas::Point const& point, const liblas::Header& header) 
    9090{ 
    9191    if (m_point_writer == 0) { 
    … …  
    129129 
    130130 
    131 void WriterImpl::SetOutputSRS(const LASSpatialReference& srs, const LASHeader& header ) 
     131void WriterImpl::SetOutputSRS(const liblas::SpatialReference& srs, const liblas::Header& header ) 
    132132{ 
    133133    m_out_srs = srs; 
    … …  
    143143 
    144144 
    145 void WriterImpl::SetInputSRS(const LASSpatialReference& srs ) 
     145void WriterImpl::SetInputSRS(const liblas::SpatialReference& srs ) 
    146146{ 
    147147    m_in_srs = srs; 
    … …  
    191191 
    192192 
    193 WriterImpl* WriterFactory::Create(std::ostream& ofs, LASHeader const& header) 
     193WriterImpl* WriterFactory::Create(std::ostream& ofs, liblas::Header const& header) 
    194194{ 
    195195    if (!ofs) 

  • src/index/datastream.cpp

    r1433 r1613  
    5858 
    5959 
    60 LASIndexDataStream::LASIndexDataStream(LASReader *reader, long dimension) : m_reader(reader), m_pNext(0), m_id(0), m_idxDimension(dimension) 
     60LASIndexDataStream::LASIndexDataStream(liblas::Reader *reader, long dimension) : m_reader(reader), m_pNext(0), m_id(0), m_idxDimension(dimension) 
    6161{ 
    6262    bool read = readPoint(); 
    … …  
    7474     
    7575    bool doRead = m_reader->ReadNextPoint(); 
    76     LASPoint* p; 
     76    Point* p; 
    7777    if (doRead) 
    78         p = (LASPoint*) &(m_reader->GetPoint()); 
     78        p = (Point*) &(m_reader->GetPoint()); 
    7979    else 
    8080        return false; 

  • src/index/index.cpp

    r1427 r1613  
    156156} 
    157157 
    158 LASVariableRecord* LASIndex::GetVLR() 
     158liblas::VariableRecord* LASIndex::GetVLR() 
    159159{ 
    160160    if (m_idxType == eMemoryIndex) { return static_cast<VLRStorageManager*>(m_storage)->getVLR();} 
    161161    else 
    162         return new LASVariableRecord(); 
     162        return new liblas::VariableRecord(); 
    163163} 
    164164 
    … …  
    343343} 
    344344 
    345 void LASIndex::insert(LASPoint& p, int64_t id)  
     345void LASIndex::insert(Point& p, int64_t id)  
    346346{ 
    347347    double min[3]; 

  • src/index/storage.cpp

    r1402 r1613  
    8282void VLRStorageManager::loadByteArray(const SpatialIndex::id_type id, ::uint32_t& len, ::uint8_t** data) 
    8383{ 
    84     LASVariableRecord* v = 0; 
     84    liblas::VariableRecord* v = 0; 
    8585    try 
    8686    { 
    … …  
    105105    if (id == SpatialIndex::StorageManager::NewPage) 
    106106    { 
    107         LASVariableRecord* v = makeVLR(len, data); 
     107        liblas::VariableRecord* v = makeVLR(len, data); 
    108108        assert(0 != v); 
    109109 
    … …  
    122122    else 
    123123    { 
    124         LASVariableRecord* v_old = 0; 
     124        liblas::VariableRecord* v_old = 0; 
    125125        try 
    126126        { 
    … …  
    134134        } 
    135135 
    136         LASVariableRecord* v = makeVLR(len, data); 
     136        liblas::VariableRecord* v = makeVLR(len, data); 
    137137        assert(0 != v); 
    138138 
    … …  
    144144void VLRStorageManager::deleteByteArray(const SpatialIndex::id_type id) 
    145145{ 
    146     LASVariableRecord* v = 0; 
     146    liblas::VariableRecord* v = 0; 
    147147    try 
    148148    { 
    … …  
    163163 
    164164 
    165 LASVariableRecord* VLRStorageManager::makeVLR(const std::size_t len, const uint8_t* data) 
     165liblas::VariableRecord* VLRStorageManager::makeVLR(const std::size_t len, const uint8_t* data) 
    166166{ 
    167     LASVariableRecord* v = new LASVariableRecord(); 
     167    liblas::VariableRecord* v = new liblas::VariableRecord(); 
    168168    v->SetRecordLength(static_cast<uint16_t>(len)); 
    169169    v->SetUserId("liblas.org"); 
    … …  
    180180} 
    181181 
    182 LASVariableRecord* VLRStorageManager::getVLR() const 
     182liblas::VariableRecord* VLRStorageManager::getVLR() const 
    183183{ 
    184184    return m_vlrbuffer[0]; 

  • src/las_c_api.cpp

    r1607 r1613  
    221221         
    222222        std::istream* istrm = OpenInput(std::string(filename)); 
    223         return (LASReaderH) new LASReader(*istrm); 
     223        return (LASReaderH) new liblas::Reader(*istrm); 
    224224 
    225225     
    … …  
    243243        std::istream* istrm = OpenInput(std::string(filename)); 
    244244         
    245         LASHeader* header = ((LASHeader*) hHeader); 
    246         return (LASReaderH) new LASReader(*istrm, *header); 
     245        liblas::Header* header = ((liblas::Header*) hHeader); 
     246        return (LASReaderH) new liblas::Reader(*istrm, *header); 
    247247 
    248248     
    … …  
    260260 
    261261    try {  
    262         LASReader* reader = (LASReader*)hReader; 
     262        liblas::Reader* reader = (liblas::Reader*)hReader; 
    263263        std::istream* istrm = &(reader->GetStream()); 
    264264 
    … …  
    288288 
    289289    try { 
    290         LASReader *reader = ((LASReader*) hReader); 
     290        liblas::Reader *reader = ((liblas::Reader*) hReader); 
    291291        if (reader->ReadNextPoint())  
    292292            // return (LASPointH) new LASPoint(reader->GetPoint()); 
    … …  
    309309 
    310310    try { 
    311         LASReader *reader = ((LASReader*) hReader); 
     311        liblas::Reader *reader = ((liblas::Reader*) hReader); 
    312312        if (reader->ReadPointAt((std::size_t) position))  
    313313            // return (LASPointH) new LASPoint(reader->GetPoint()); 
    … …  
    329329    VALIDATE_LAS_POINTER1(hReader, "LASReader_GetHeader", NULL); 
    330330 
    331     LASHeader header = ((LASReader*) hReader)->GetHeader(); 
    332     return (LASHeaderH) new LASHeader( header ); 
     331    liblas::Header header = ((liblas::Reader*) hReader)->GetHeader(); 
     332    return (LASHeaderH) new liblas::Header( header ); 
    333333} 
    334334 
    … …  
    339339 
    340340    try { 
    341         ((LASReader*) hReader)->SetSRS(*((LASSpatialReference*)hSRS)); 
     341        ((liblas::Reader*) hReader)->SetSRS(*((liblas::SpatialReference*)hSRS)); 
    342342    } 
    343343    catch (std::exception const& e) { 
    … …  
    355355 
    356356    try { 
    357         ((LASReader*) hReader)->SetInputSRS(*((LASSpatialReference*)hSRS)); 
     357        ((liblas::Reader*) hReader)->SetInputSRS(*((liblas::SpatialReference*)hSRS)); 
    358358    } 
    359359    catch (std::exception const& e) { 
    … …  
    371371 
    372372    try { 
    373         ((LASReader*) hReader)->SetOutputSRS(*((LASSpatialReference*)hSRS)); 
     373        ((liblas::Reader*) hReader)->SetOutputSRS(*((liblas::SpatialReference*)hSRS)); 
    374374    } 
    375375    catch (std::exception const& e) { 
    … …  
    382382 
    383383LAS_DLL LASHeaderH LASHeader_Create(void) { 
    384         return (LASHeaderH) new LASHeader(); 
     384        return (LASHeaderH) new liblas::Header(); 
    385385} 
    386386 
    387387LAS_DLL LASPointH LASPoint_Create(void) { 
    388         return (LASPointH) new LASPoint(); 
     388        return (LASPointH) new liblas::Point(); 
    389389} 
    390390 
    391391LAS_DLL LASPointH LASPoint_Copy(const LASPointH hPoint) { 
    392         return (LASPointH) new LASPoint(*((LASPoint*) hPoint)); 
     392        return (LASPointH) new liblas::Point(*((liblas::Point*) hPoint)); 
    393393} 
    394394 
    395395LAS_DLL void LASPoint_Destroy(LASPointH hPoint) { 
    396396    VALIDATE_LAS_POINTER0(hPoint, "LASPoint_Destroy"); 
    397     delete (LASPoint*) hPoint; 
     397    delete (liblas::Point*) hPoint; 
    398398    hPoint = NULL; 
    399399} 
    … …  
    403403    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetX", 0.0); 
    404404     
    405     double value = ((LASPoint*) hPoint)->GetX(); 
     405    double value = ((liblas::Point*) hPoint)->GetX(); 
    406406    return value; 
    407407} 
    … …  
    412412 
    413413    try { 
    414             ((LASPoint*) hPoint)->SetX(value); 
     414            ((liblas::Point*) hPoint)->SetX(value); 
    415415    } catch (std::exception const& e) 
    416416    { 
    … …  
    427427    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetY", 0.0); 
    428428     
    429     double value = ((LASPoint*) hPoint)->GetY(); 
     429    double value = ((liblas::Point*) hPoint)->GetY(); 
    430430    return value; 
    431431} 
    … …  
    436436 
    437437    try { 
    438             ((LASPoint*) hPoint)->SetY(value); 
     438            ((liblas::Point*) hPoint)->SetY(value); 
    439439    } catch (std::exception const& e) 
    440440    { 
    … …  
    451451    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetZ", 0.0); 
    452452     
    453     double value = ((LASPoint*) hPoint)->GetZ(); 
     453    double value = ((liblas::Point*) hPoint)->GetZ(); 
    454454    return value; 
    455455} 
    … …  
    460460 
    461461    try { 
    462             ((LASPoint*) hPoint)->SetZ(value); 
     462            ((liblas::Point*) hPoint)->SetZ(value); 
    463463    } catch (std::exception const& e) 
    464464    { 
    … …  
    475475    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetIntensity", 0); 
    476476     
    477     liblas::uint16_t value = ((LASPoint*) hPoint)->GetIntensity(); 
     477    liblas::uint16_t value = ((liblas::Point*) hPoint)->GetIntensity(); 
    478478    return value; 
    479479} 
    … …  
    484484 
    485485    try { 
    486             ((LASPoint*) hPoint)->SetIntensity(value); 
     486            ((liblas::Point*) hPoint)->SetIntensity(value); 
    487487    } catch (std::exception const& e) 
    488488    { 
    … …  
    499499    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetReturnNumber", 0); 
    500500     
    501     liblas::uint16_t value = ((LASPoint*) hPoint)->GetReturnNumber(); 
     501    liblas::uint16_t value = ((liblas::Point*) hPoint)->GetReturnNumber(); 
    502502    return value; 
    503503} 
    … …  
    508508 
    509509    try { 
    510             ((LASPoint*) hPoint)->SetReturnNumber(value); 
     510            ((liblas::Point*) hPoint)->SetReturnNumber(value); 
    511511    } catch (std::exception const& e) 
    512512    { 
    … …  
    523523    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetNumberOfReturns", 0); 
    524524     
    525     liblas::uint16_t value = ((LASPoint*) hPoint)->GetNumberOfReturns(); 
     525    liblas::uint16_t value = ((liblas::Point*) hPoint)->GetNumberOfReturns(); 
    526526    return value; 
    527527} 
    … …  
    532532 
    533533    try { 
    534             ((LASPoint*) hPoint)->SetNumberOfReturns(value); 
     534            ((liblas::Point*) hPoint)->SetNumberOfReturns(value); 
    535535    } catch (std::exception const& e) 
    536536    { 
    … …  
    547547    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetScanDirection", 0); 
    548548     
    549     liblas::uint16_t value = ((LASPoint*) hPoint)->GetScanDirection(); 
     549    liblas::uint16_t value = ((liblas::Point*) hPoint)->GetScanDirection(); 
    550550    return value; 
    551551} 
    … …  
    556556 
    557557    try { 
    558             ((LASPoint*) hPoint)->SetScanDirection(value); 
     558            ((liblas::Point*) hPoint)->SetScanDirection(value); 
    559559    } catch (std::exception const& e) 
    560560    { 
    … …  
    571571    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetFlightLineEdge", 0); 
    572572     
    573     liblas::uint16_t value = ((LASPoint*) hPoint)->GetFlightLineEdge(); 
     573    liblas::uint16_t value = ((liblas::Point*) hPoint)->GetFlightLineEdge(); 
    574574    return value; 
    575575} 
    … …  
    580580 
    581581    try { 
    582             ((LASPoint*) hPoint)->SetFlightLineEdge(value); 
     582            ((liblas::Point*) hPoint)->SetFlightLineEdge(value); 
    583583    } catch (std::exception const& e) 
    584584    { 
    … …  
    595595    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetScanFlags", 0); 
    596596     
    597     liblas::uint8_t value = ((LASPoint*) hPoint)->GetScanFlags(); 
     597    liblas::uint8_t value = ((liblas::Point*) hPoint)->GetScanFlags(); 
    598598    return value; 
    599599} 
    … …  
    604604 
    605605    try { 
    606             ((LASPoint*) hPoint)->SetScanFlags(value); 
     606            ((liblas::Point*) hPoint)->SetScanFlags(value); 
    607607    } catch (std::exception const& e) 
    608608    { 
    … …  
    619619    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetClassification", 0); 
    620620 
    621     LASClassification::bitset_type clsflags(((LASPoint*) hPoint)->GetClassification()); 
     621    liblas::Classification::bitset_type clsflags(((liblas::Point*) hPoint)->GetClassification()); 
    622622    liblas::uint8_t value = static_cast<liblas::uint8_t>(clsflags.to_ulong()); 
    623623    return value; 
    … …  
    629629 
    630630    try { 
    631             ((LASPoint*) hPoint)->SetClassification(value); 
     631            ((liblas::Point*) hPoint)->SetClassification(value); 
    632632    } catch (std::exception const& e) 
    633633    { 
    … …  
    645645 
    646646    try { 
    647             ((LASPoint*) hPoint)->SetTime(value); 
     647            ((liblas::Point*) hPoint)->SetTime(value); 
    648648    } catch (std::exception const& e) 
    649649    { 
    … …  
    660660    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetTime", 0.0); 
    661661     
    662     double value = ((LASPoint*) hPoint)->GetTime(); 
     662    double value = ((liblas::Point*) hPoint)->GetTime(); 
    663663    return value; 
    664664} 
    … …  
    668668    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetScanAngleRank", 0); 
    669669     
    670     liblas::int8_t value = ((LASPoint*) hPoint)->GetScanAngleRank(); 
     670    liblas::int8_t value = ((liblas::Point*) hPoint)->GetScanAngleRank(); 
    671671    return value; 
    672672} 
    … …  
    677677 
    678678    try { 
    679             ((LASPoint*) hPoint)->SetScanAngleRank(value); 
     679            ((liblas::Point*) hPoint)->SetScanAngleRank(value); 
    680680    } catch (std::exception const& e) 
    681681    { 
    … …  
    692692    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetPointSourceId", 0); 
    693693     
    694     liblas::uint16_t value = ((LASPoint*) hPoint)->GetPointSourceID(); 
     694    liblas::uint16_t value = ((liblas::Point*) hPoint)->GetPointSourceID(); 
    695695    return value; 
    696696} 
    … …  
    701701 
    702702    try { 
    703             ((LASPoint*) hPoint)->SetPointSourceID(value); 
     703            ((liblas::Point*) hPoint)->SetPointSourceID(value); 
    704704    } catch (std::exception const& e) 
    705705    { 
    … …  
    717717    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetUserData", 0); 
    718718     
    719     liblas::uint8_t value = ((LASPoint*) hPoint)->GetUserData(); 
     719    liblas::uint8_t value = ((liblas::Point*) hPoint)->GetUserData(); 
    720720    return value; 
    721721} 
    … …  
    726726 
    727727    try { 
    728             ((LASPoint*) hPoint)->SetUserData(value); 
     728            ((liblas::Point*) hPoint)->SetUserData(value); 
    729729    } catch (std::exception const& e) 
    730730    { 
    … …  
    742742 
    743743    try { 
    744         LASPoint* p = ((LASPoint*) hPoint); 
     744        liblas::Point* p = ((liblas::Point*) hPoint); 
    745745        std::vector<liblas::uint8_t> d = p->GetExtraData(); 
    746746        *length = d.size(); 
    … …  
    764764 
    765765    try { 
    766         LASPoint* p = ((LASPoint*) hPoint); 
     766        liblas::Point* p = ((liblas::Point*) hPoint); 
    767767        std::vector<liblas::uint8_t> d; 
    768768        d.resize(length); 
    … …  
    784784    VALIDATE_LAS_POINTER1(hPoint2, "LASPoint_Equal", 0); 
    785785 
    786     LASPoint* point1 = ((LASPoint*) hPoint1); 
    787     LASPoint* point2 = ((LASPoint*) hPoint2); 
     786    liblas::Point* point1 = ((liblas::Point*) hPoint1); 
     787    liblas::Point* point2 = ((liblas::Point*) hPoint2); 
    788788 
    789789    return (point1 == point2); 
    … …  
    796796 
    797797    try { 
    798             ((LASPoint*) hPoint)->Validate(); 
     798            ((liblas::Point*) hPoint)->Validate(); 
    799799    } catch (invalid_point_data const& e /*e */) { 
    800800        return e.who(); 
    … …  
    811811 
    812812    VALIDATE_LAS_POINTER1(hPoint, "LASPoint_IsValid", LE_Failure); 
    813     return ((LASPoint*) hPoint)->IsValid(); 
     813    return ((liblas::Point*) hPoint)->IsValid(); 
    814814} 
    815815 
    … …  
    818818    VALIDATE_LAS_POINTER1(hHeader, "LASHeader_GetFileSignature", NULL); 
    819819     
    820     std::string signature = ((LASHeader*) hHeader)->GetFileSignature(); 
     820    std::string signature = ((liblas::Header*) hHeader)->GetFileSignature(); 
    821821    return strdup(signature.c_str()); 
    822822} 
    … …  
    825825    VALIDATE_LAS_POINTER1(hHeader, "LASHeader_GetFileSourceId", 0); 
    826826 
    827     unsigned short value = ((LASHeader*) hHeader)->GetFileSourceId(); 
     827    unsigned short value = ((liblas::Header*) hHeader)->GetFileSourceId(); 
    828828    return value; 
    829829} 
    … …  
    831831LAS_DLL LASErrorEnum LASHeader_SetFileSourceId(LASHeaderH hHeader, liblas::uint16_t value) { 
    832832    VALIDATE_LAS_POINTER1(hHeader, "LASHeader_SetFileSourceId", LE_Failure); 
    833     ((LASHeader*) hHeader)->SetFileSourceId(value);     
     833    ((liblas::Header*) hHeader)->SetFileSourceId(value);     
    834834    return LE_None; 
    835835} 
    … …  
    839839    VALIDATE_LAS_POINTER1(hHeader, "LASHeader_GetReserved", 0); 
    840840 
    841     unsigned short value = ((LASHeader*) hHeader)->GetReserved(); 
     841    unsigned short value = ((liblas::Header*) hHeader)->GetReserved(); 
    842842    return value; 
    843843} 
    … …  
    845845LAS_DLL LASErrorEnum LASHeader_SetReserved(LASHeaderH hHeader, liblas::uint16_t value) { 
    846846    VALIDATE_LAS_POINTER1(hHeader, "LASHeader_SetReserved", LE_Failure); 
    847     ((LASHeader*) hHeader)->SetReserved(value);     
     847    ((liblas::Header*) hHeader)->SetReserved(value);     
    848848    return LE_None; 
    849849} 
    … …  
    852852    VALIDATE_LAS_POINTER1(hHeader, "LASHeader_GetProjectId", 0); 
    853853     
    854     liblas::guid id = ((LASHeader*) hHeader)->GetProjectId(); 
     854    liblas::guid id = ((liblas::Header*) hHeader)->GetProjectId(); 
    855855    return strdup(id.to_string().c_str()); 
    856856} 
    … …  
    862862        liblas::guid id; 
    863863        id = liblas::guid(value); 
    864         ((LASHeader*) hHeader)->SetProjectId(id);     
     864        ((liblas::Header*) hHeader)->SetProjectId(id);     
    865865    } catch (std::exception const& e) 
    866866    { 
    … …  
    875875    VALIDATE_LAS_POINTER1(hHeader, "LASHeader_GetVersionMajor", 0); 
    876876 
    877     long value = ((LASHeader*) hHeader)->GetVersionMajor(); 
     877    long value = ((liblas::Header*) hHeader)->GetVersionMajor(); 
    878878    return liblas::uint8_t(value); 
    879879} 
    … …  
    883883 
    884884    try { 
    885         ((LASHeader*) hHeader)->SetVersionMajor(value);     
     885        ((liblas::Header*) hHeader)->SetVersionMajor(value);     
    886886    } catch (std::exception const& e) 
    887887    { 
    … …  
    896896    VALIDATE_LAS_POINTER1(hHeader, "LASHeader_GetVersionMinor", 0); 
    897897 
    898     long value = ((LASHeader*) hHeader)->GetVersionMinor(); 
     898    long value = ((liblas::Header*) hHeader)->GetVersionMinor(); 
    899899    return liblas::uint8_t(value); 
    900900} 
    … …  
    905905    // TODO: Maybe this should be a fatal error -- hobu 
    906906    try { 
    907         ((LASHeader*) hHeader)->SetVersionMinor(value);     
     907        ((liblas::Header*) hHeader)->SetVersionMinor(value);     
    908908    } catch (std::exception const& e) 
    909909    { 
    … …  
    919919 
    920920    // caller owns it 
    921     std::string sysid = ((LASHeader*) hHeader)->GetSystemId(); 
     921    std::string sysid = ((liblas::Header*) hHeader)->GetSystemId(); 
    922922    return strdup(sysid.c_str()); 
    923923} 
    … …  
    927927 
    928928    try { 
    929             ((LASHeader*) hHeader)->SetSystemId(value); 
     929            ((liblas::Header*) hHeader)->SetSystemId(value); 
    930930    } catch (std::exception const& e) 
    931931    { 
    … …  
    941941 
    942942    // caller owns it 
    943     std::string softid = ((LASHeader*) hHeader)->GetSoftwareId(); 
     943    std::string softid = ((liblas::Header*) hHeader)->GetSoftwareId(); 
    944944    return strdup(softid.c_str()); 
    945945} 
    … …  
    949949 
    950950    try { 
    951             ((LASHeader*) hHeader)->SetSoftwareId(value); 
     951            ((liblas::Header*) hHeader)->SetSoftwareId(value); 
    952952    } catch (std::exception const& e) 
    953953    { 
    … …  
    962962    VALIDATE_LAS_POINTER1(hHeader, "LASHeader_GetCreationDOY", 0); 
    963963 
    964     unsigned short value = ((LASHeader*) hHeader)->GetCreationDOY(); 
     964    unsigned short value = ((liblas::Header*) hHeader)->GetCreationDOY(); 
    965965    return value; 
    966966} 
    … …  
    968968LAS_DLL LASErrorEnum LASHeader_SetCreationDOY(LASHeaderH hHeader, liblas::uint16_t value) { 
    969969    VALIDATE_LAS_POINTER1(hHeader, "LASHeader_SetCreationDOY", LE_Failure); 
    970     ((LASHeader*) hHeader)->SetCreationDOY(value);     
     970    ((liblas::Header*) hHeader)->SetCreationDOY(value);     
    971971    return LE_None;