Changeset 641:7f52a619352d


Ignore:
Timestamp:
05/13/08 21:43:08 (2 years ago)
Author:
Howard Butler <hobu.inc@…>
Branch:
default
Convert:
svn:1766ff46-f334-0410-ab20-d63176f87757/trunk@708
Message:

an attempt at ReadVLR/AddVLR with some updates to ReadGeoreference? #50

Files:
12 edited

Legend:

Unmodified
Added
Removed

  • include/liblas/detail/reader.hpp

    r586 r641  
    6464    virtual bool ReadPointAt(std::size_t n, PointRecord& record) = 0; 
    6565    virtual bool ReadPointAt(std::size_t n, PointRecord& record, double& time) = 0; 
     66    virtual bool ReadVLR(LASHeader& header) = 0; 
    6667 
    6768    virtual std::istream& GetStream() = 0; 

  • include/liblas/detail/reader10.hpp

    r586 r641  
    6464    bool ReadPointAt(std::size_t n, PointRecord& record); 
    6565    bool ReadPointAt(std::size_t n, PointRecord& record, double& time); 
     66    bool ReadVLR(LASHeader& header); 
    6667 
    6768    std::istream& GetStream(); 

  • include/liblas/detail/reader11.hpp

    r586 r641  
    6363    bool ReadPointAt(std::size_t n, PointRecord& record); 
    6464    bool ReadPointAt(std::size_t n, PointRecord& record, double& time); 
     65    bool ReadVLR(LASHeader& header); 
    6566 
    6667    std::istream& GetStream(); 

  • include/liblas/detail/utility.hpp

    r586 r641  
    7878}; 
    7979 
    80 struct VariableLengthRecordHeader 
    81 { 
    82     VariableLengthRecordHeader() 
     80class VariableLengthRecord 
     81{ 
     82    VariableLengthRecord() 
    8383        : reserved(0), record_id(0), record_length_after_header(0) 
    8484    { 
    … …  
    9898    uint16_t record_length_after_header; 
    9999    int8_t description[eDescriptionSize]; 
     100    uint8_t data; 
    100101}; 
    101102 

  • include/liblas/lasheader.hpp

    r585 r641  
    4747#include <liblas/guid.hpp> 
    4848#include <liblas/detail/utility.hpp> 
     49#include <liblas/lasrecordheader.hpp> 
    4950//std 
    5051#include <string> 
    … …  
    291292    void SetMin(double x, double y, double z); 
    292293 
     294    void AddVLR(LASVLR const& v); 
     295    LASVLR const& GetVLR(int index) const; 
     296     
    293297private: 
    294298     
    … …  
    343347    PointOffsets m_offsets; 
    344348    PointExtents m_extents; 
     349    std::vector<LASVLR> m_vlrs; 
    345350}; 
    346351 

  • include/liblas/lasreader.hpp

    r585 r641  
    4646#include <liblas/lasheader.hpp> 
    4747#include <liblas/laspoint.hpp> 
     48#include <liblas/lasrecordheader.hpp> 
    4849#include <liblas/detail/fwd.hpp> 
    4950// std 
    … …  
    6667    LASHeader const& GetHeader() const; 
    6768    LASPoint const& GetPoint() const; 
     69    std::vector<LASVLR> const& GetVLRs() const; 
    6870     
    6971    bool ReadNextPoint(); 
    7072    bool ReadPointAt(std::size_t n); 
     73    bool ReadVLR(); 
    7174 
    7275    // The operator is not const because it updates file stream position. 
    … …  
    8992    LASPoint m_point; 
    9093    detail::PointRecord m_record; 
     94    std::vector<LASVLR> m_vlrs; 
    9195 
    9296}; 

  • include/liblas/lasrecordheader.hpp

    r587 r641  
    4646// std 
    4747#include <string> 
     48#include <vector> 
    4849 
    4950namespace liblas { 
    5051 
    5152/// Representation of variable-length record data. 
    52 class LASRecordHeader 
     53class LASVLR 
    5354{ 
    5455public: 
    … …  
    5758    /// Zero-initialization of record data. 
    5859    /// \exception No throw 
    59     LASRecordHeader(); 
     60    LASVLR();  
    6061 
    6162    /// Copy constructor. 
    6263    /// Construction of new record object as a copy of existing one. 
    6364    /// \exception No throw 
    64     LASRecordHeader(LASRecordHeader const& other); 
     65    LASVLR(LASVLR const& other); 
     66     
     67    ~LASVLR(); 
    6568 
    6669    /// Assignment operator. 
    … …  
    6871    /// assignment of another one. 
    6972    /// \exception No throw 
    70     LASRecordHeader& operator=(LASRecordHeader const& rhs); 
     73    LASVLR& operator=(LASVLR const& rhs); 
    7174 
    7275    /// Get record signature (LAS 1.0) or reserved bytes (LAS 1.1). 
    7376    /// \exception No throw 
    7477    uint16_t GetReserved() const; 
     78     
     79    void SetReserved(uint16_t); 
    7580 
    7681    /// Get identifier of user which created the record. 
    7782    /// The character data is up to 16 bytes long. 
    7883    /// \exception No throw 
    79     std::string const& GetUserId() const; 
     84    std::string GetUserId(bool pad /*= false*/); 
     85     
     86    void SetUserId(std::string const&); 
    8087 
    8188    /// Get identifier of record. 
    … …  
    8390    /// \exception No throw 
    8491    uint16_t GetRecordId() const; 
     92     
     93    void SetRecordId(uint16_t); 
    8594 
    8695    /// Get record length after the header. 
    8796    /// \exception No throw 
    88     uint16_t GeRecordLength() const; 
     97    uint16_t GetRecordLength() const; 
     98     
     99    void SetRecordLength(uint16_t); 
    89100 
    90101    /// Get text description of data in the record. 
    91102    /// The character data is up to 32 bytes long. 
    92103    /// \exception No throw 
    93     std::string const& GetDescription() const; 
     104    std::string GetDescription(bool pad /*= false*/); 
     105     
     106    void SetDescription(std::string const&); 
     107 
     108    /// Get the data for this VLR 
     109    std::vector<uint8_t> GetData() const; 
     110     
     111    void SetData(std::vector<uint8_t> const&); 
    94112 
    95113    /// Compare actual header object against the other. 
    96114    /// \exception No throw 
    97     bool equal(LASRecordHeader const& other) const; 
     115    bool equal(LASVLR const& other) const; 
    98116 
    99117private: 
    100118 
     119    enum 
     120    { 
     121        eUIDSize = 16, 
     122        eDescriptionSize = 32 
     123    }; 
     124     
    101125    uint16_t m_reserved; 
    102126    uint16_t m_recordId; 
    103127    uint16_t m_recordLength; // after header 
    104     std::string m_userId; // [16] 
    105     std::string m_desc; // [32] 
     128 
     129    char m_userId[eUIDSize]; 
     130    char m_desc[eDescriptionSize]; 
     131    std::vector<uint8_t> m_data; 
    106132}; 
    107133 
    108134/// Equality operator. 
    109 /// Implemented in terms of LASRecordHeader::equal member function. 
     135/// Implemented in terms of LASVLR::equal member function. 
    110136/// \exception No throw 
    111 inline bool operator==(LASRecordHeader const& lhs, LASRecordHeader const& rhs) 
     137inline bool operator==(LASVLR const& lhs, LASVLR const& rhs) 
    112138{ 
    113139    return lhs.equal(rhs); 
    … …  
    117143/// Implemented in terms of LASRecordHeader::equal member function. 
    118144/// \exception No throw 
    119 inline bool operator!=(LASRecordHeader const& lhs, LASRecordHeader const& rhs) 
     145inline bool operator!=(LASVLR const& lhs, LASVLR const& rhs) 
    120146{ 
    121147    return (!(lhs == rhs)); 

  • src/detail/reader10.cpp

    r640 r641  
    4242#include <liblas/detail/reader10.hpp> 
    4343#include <liblas/detail/utility.hpp> 
     44#include <liblas/lasrecordheader.hpp> 
    4445#include <liblas/liblas.hpp> 
    4546#include <liblas/lasheader.hpp> 
    … …  
    210211    m_recordlength = header.GetDataRecordLength(); 
    211212 
     213 
     214    return true; 
     215} 
     216 
     217bool ReaderImpl::ReadVLR(LASHeader& header) { 
     218     
     219    VLRHeader vlrh = { 0 }; 
     220 
     221    m_ifs.seekg(header.GetHeaderSize(), std::ios::beg); 
     222  
     223    for (uint32_t i = 0; i < header.GetRecordsCount(); ++i) 
     224    { 
     225        read_n(vlrh, m_ifs, sizeof(VLRHeader)); 
     226 
     227        int16_t count = vlrh.recordLengthAfterHeader / sizeof(uint8_t); 
     228        uint8_t *rawdata = new uint8_t[count]; 
     229          
     230        read_n(rawdata, m_ifs, vlrh.recordLengthAfterHeader); 
     231          
     232        std::vector<uint8_t> data; 
     233        for (int j=0; j< count; ++j) { 
     234            data.push_back(rawdata[j]); 
     235        } 
     236          
     237        LASVLR vlr; 
     238        vlr.SetReserved(vlrh.reserved); 
     239        vlr.SetUserId(std::string(vlrh.userId)); 
     240        vlr.SetDescription(std::string(vlrh.description)); 
     241        vlr.SetRecordLength(vlrh.recordLengthAfterHeader); 
     242        vlr.SetRecordId(vlrh.recordId); 
     243        vlr.SetData(data); 
     244        delete[] rawdata; 
     245        header.AddVLR(vlr); 
     246    } 
    212247    // TODO: Under construction 
    213248    //       Testing reading of VLRecords with GeoKeys 
    … …  
    216251    return true; 
    217252} 
    218  
    219253bool ReaderImpl::ReadGeoreference(LASHeader const& header) 
    220254{ 
    … …  
    227261    ST_TIFF *st = ST_Create(); 
    228262 
    229     m_ifs.seekg(header.GetHeaderSize(), std::ios::beg); 
    230  
    231     for (uint32_t i = 0; i < header.GetRecordsCount(); ++i) 
    232     { 
    233         read_n(vlrh, m_ifs, sizeof(VLRHeader)); 
    234  
    235         if (uid == vlrh.userId && 34735 == vlrh.recordId) 
     263//    m_ifs.seekg(header.GetHeaderSize(), std::ios::beg); 
     264 
     265    printf("Records count: %d\n", (int)header.GetRecordsCount()); 
     266 
     267    for (uint16_t i = 0; i < header.GetRecordsCount(); ++i) 
     268    { 
     269        LASVLR record = header.GetVLR(i); 
     270        std::vector<uint8_t> data = record.GetData(); 
     271 
     272        printf("record.GetUserId(): '%s' record.GetRecordId: %d\n", record.GetUserId(true).c_str(), record.GetRecordId()); 
     273        if (uid == record.GetUserId(true).c_str() && 34735 == record.GetRecordId()) 
    236274        { 
    237             int16_t count = vlrh.recordLengthAfterHeader / sizeof(int16_t); 
     275            printf("uid == record.GetUserId(true).c_str() && 34735 == record.GetRecordId()\n"); 
     276 
     277            int16_t count = data.size()/sizeof(int16_t); 
     278 
     279            printf("count for int16_t: %d\n", count); 
    238280            uint16_t *geokeys = new uint16_t[count]; 
    239             read_n(geokeys, m_ifs, vlrh.recordLengthAfterHeader); 
    240             ST_SetKey( st, vlrh.recordId, count, STT_SHORT, geokeys ); 
     281            for (int j = 0; j< count; ++j) { 
     282                geokeys[j] = (uint16_t)data[j]; 
     283            } 
     284            ST_SetKey( st, record.GetRecordId(), count, STT_SHORT, geokeys ); 
    241285            delete[] geokeys; 
     286             
    242287        } 
    243         else if (uid == vlrh.userId && 34736 == vlrh.recordId) 
     288 
     289        if (uid == record.GetUserId(true).c_str() && 34736 == record.GetRecordId()) 
    244290        { 
    245             int count = vlrh.recordLengthAfterHeader / sizeof(double); 
    246             double *values = new double[count]; 
    247             read_n(values, m_ifs, vlrh.recordLengthAfterHeader); 
    248             ST_SetKey( st, vlrh.recordId, count, STT_DOUBLE, values ); 
    249             delete[] values; 
    250         } 
    251         else if (uid == vlrh.userId && 34737 == vlrh.recordId) 
     291            printf("uid == record.GetUserId(true).c_str() && 34736 == record.GetRecordId()\n"); 
     292 
     293            int count = data.size() / sizeof(double); 
     294            printf("count for int: %d\n", count); 
     295 
     296            double *geokeys = new double[count]; 
     297            for (int j = 0; j< count; ++j) { 
     298                geokeys[j] = (double)data[j]; 
     299            } 
     300            ST_SetKey( st, record.GetRecordId(), count, STT_DOUBLE, geokeys ); 
     301            delete[] geokeys; 
     302 
     303        }         
     304 
     305        if (uid == record.GetUserId(true).c_str() && 34737 == record.GetRecordId()) 
    252306        { 
    253             uint8_t count = vlrh.recordLengthAfterHeader / sizeof(uint8_t); 
    254             char *values = new char[count]; 
    255             read_n(values, m_ifs, vlrh.recordLengthAfterHeader); 
    256             ST_SetKey( st, vlrh.recordId, count, STT_ASCII, values ); 
    257             delete[] values; 
    258         } 
    259         else 
    260         { 
    261             std::istream::pos_type const pos = m_ifs.tellg(); 
    262             m_ifs.seekg(pos + std::istream::pos_type(vlrh.recordLengthAfterHeader)); 
    263         } 
     307            printf("uid == record.GetUserId(true).c_str() && 34737 == record.GetRecordId()\n"); 
     308 
     309            uint8_t count = data.size()/sizeof(uint8_t); 
     310             
     311            printf("count for string: %d data.size(): %d", count, (int)data.size()); 
     312 
     313            char *geokeys = new char[count]; 
     314            for (int j = 0; j< count; ++j) { 
     315                geokeys[j] = (uint8_t)data[j]; 
     316            } 
     317//            geokeys[count] = '\0'; 
     318            printf("Geokeys: '%s'", geokeys); 
     319            ST_SetKey( st, record.GetRecordId(), count, STT_ASCII, geokeys ); 
     320            delete[] geokeys; 
     321 
     322 
     323        }         
     324        // else if (uid == record.GetUserId() && record.GetRecordId()) 
     325        // { 
     326        //     int count = vlrh.recordLengthAfterHeader / sizeof(double); 
     327        //     double *values = new double[count]; 
     328        //     read_n(values, m_ifs, vlrh.recordLengthAfterHeader); 
     329        //     ST_SetKey( st, vlrh.recordId, count, STT_DOUBLE, values ); 
     330        //     delete[] values; 
     331        // } 
     332        // else if (uid == record.GetUserId() && record.GetRecordId()) 
     333        // { 
     334        //     uint8_t count = vlrh.recordLengthAfterHeader / sizeof(uint8_t); 
     335        //     char *values = new char[count]; 
     336        //     read_n(values, m_ifs, vlrh.recordLengthAfterHeader); 
     337        //     ST_SetKey( st, vlrh.recordId, count, STT_ASCII, values ); 
     338        //     delete[] values; 
     339        // } 
     340     //   else 
     341        // { 
     342        //     std::istream::pos_type const pos = m_ifs.tellg(); 
     343        //     m_ifs.seekg(pos + std::istream::pos_type(vlrh.recordLengthAfterHeader)); 
     344        // } 
    264345    } 
    265346 
    266347    GTIF *gtif = GTIFNewSimpleTags( st ); 
    267     GTIFDefn    defn; 
     348    GTIFDefn defn; 
    268349    if (GTIFGetDefn(gtif, &defn))  
    269350    { 
    270          printf( "PROJ.4 Definition: %s\n", GTIFGetProj4Defn(&defn)); 
    271     } 
    272     GTIFPrint(gtif,0,0); 
     351         printf( "char PROJ.4 Definition: %s\n", GTIFGetProj4Defn(&defn)); 
     352    } 
    273353    GTIFFree( gtif ); 
    274354    ST_Destroy( st ); 

  • src/detail/reader11.cpp

    r588 r641  
    4545#include <liblas/lasheader.hpp> 
    4646#include <liblas/laspoint.hpp> 
     47#include <liblas/lasrecordheader.hpp> 
     48 
    4749// std 
    4850#include <fstream> 
    … …  
    294296} 
    295297 
     298bool ReaderImpl::ReadVLR(LASHeader& header) { 
     299     
     300    VLRHeader vlrh = { 0 }; 
     301    LASVLR vlr; 
     302 
     303    return true; 
     304} 
     305 
    296306}}} // namespace liblas::detail::v11 

  • src/lasheader.cpp

    r588 r641  
    9999    std::vector<uint32_t>(other.m_pointRecordsByReturn).swap(m_pointRecordsByReturn); 
    100100    assert(ePointsByReturnSize >= m_pointRecordsByReturn.size()); 
     101     
     102    std::vector<LASVLR>(other.m_vlrs).swap(m_vlrs); 
    101103 
    102104} 
    … …  
    134136        assert(ePointsByReturnSize >= m_pointRecordsByReturn.size()); 
    135137 
     138        std::vector<LASVLR>(rhs.m_vlrs).swap(m_vlrs); 
    136139        m_scales = rhs.m_scales; 
    137140        m_offsets = rhs.m_offsets; 
    … …  
    183186        throw std::invalid_argument("invalid file signature"); 
    184187 
    185 //    m_signature = v; 
    186  
    187188    std::strncpy(m_signature, v.c_str(), eFileSignatureSize); 
    188189} 
    … …  
    261262    if (v.size() > eSystemIdSize) 
    262263        throw std::invalid_argument("system id too long"); 
    263      
    264 //    m_systemId = v; 
    265264 
    266265    std::fill(m_systemId, m_systemId + eSystemIdSize, 0); 
    … …  
    496495} 
    497496 
     497void LASHeader::AddVLR(LASVLR const& v)  
     498{ 
     499    m_vlrs.push_back(v); 
     500} 
     501LASVLR const& LASHeader::GetVLR(int index) const { 
     502    return m_vlrs[index]; 
     503} 
    498504void LASHeader::Init() 
    499505{ 

  • src/lasreader.cpp

    r588 r641  
    148148    if (!ret) 
    149149        throw std::runtime_error("public header block reading failure"); 
     150         
     151    ret = m_pimpl->ReadVLR(m_header); 
     152    if (!ret) 
     153        throw std::runtime_error("public vlr header block reading failure"); 
     154     
    150155} 
    151156 

  • src/lasrecordheader.cpp

    r588 r641  
    99 * Copyright (c) 2008, Phil Vachon 
    1010 * Copyright (c) 2008, Mateusz Loskot, mateusz@loskot.net 
     11 * Copyright (c) 2008, Howard Butler, hobu.inc@gmail.com 
    1112 * 
    1213 * All rights reserved. 
    … …  
    4344#include <liblas/lasrecordheader.hpp> 
    4445#include <liblas/cstdint.hpp> 
     46 
    4547// std 
     48#include <algorithm> 
     49#include <stdexcept> 
    4650#include <string> 
     51#include <vector> 
     52#include <cstring> // std::memset, std::memcpy, std::strncpy 
     53#include <cassert> 
    4754 
    4855namespace liblas { 
    4956 
    50 LASRecordHeader::LASRecordHeader() : 
     57LASVLR::LASVLR() : 
    5158    m_reserved(0), m_recordId(0), m_recordLength(0) 
    5259{     
    53 } 
    54  
    55 LASRecordHeader::LASRecordHeader(LASRecordHeader const& other) : 
     60    std::memset(m_userId, 0, eUIDSize); 
     61    std::memset(m_desc, 0, eDescriptionSize); 
     62     
     63    m_data.resize(40); 
     64 
     65} 
     66 
     67LASVLR::LASVLR(LASVLR const& other) : 
    5668    m_reserved(other.m_reserved), 
    5769    m_recordId(other.m_recordId), 
    58     m_recordLength(other.m_recordLength), 
    59     m_userId(other.m_userId), 
    60     m_desc(other.m_desc) 
    61 { 
    62 } 
    63  
    64 LASRecordHeader& LASRecordHeader::operator=(LASRecordHeader const& rhs) 
    65 { 
     70    m_recordLength(other.m_recordLength) 
     71{ 
     72    void* p = 0; 
     73 
     74    p = std::memcpy(m_userId, other.m_userId, eUIDSize); 
     75    assert(p == m_userId); 
     76 
     77    p = std::memcpy(m_desc, other.m_desc, eDescriptionSize); 
     78    assert(p == m_desc); 
     79     
     80    std::vector<uint8_t>(other.m_data).swap(m_data); 
     81} 
     82 
     83LASVLR::~LASVLR() 
     84{ 
     85 
     86} 
     87 
     88LASVLR& LASVLR::operator=(LASVLR const& rhs) 
     89{ 
     90    void* p = 0; 
    6691    if (this != &rhs) 
    6792    { 
    … …  
    6994        m_recordId = rhs.m_recordId; 
    7095        m_recordLength = rhs.m_recordLength; 
    71         m_userId = rhs.m_userId; 
    72         m_desc = rhs.m_desc; 
     96 
     97        p = std::memcpy(m_userId, rhs.m_userId, eUIDSize); 
     98        assert(p == m_userId); 
     99 
     100        p = std::memcpy(m_desc, rhs.m_desc, eDescriptionSize); 
     101        assert(p == m_desc); 
     102 
     103        std::vector<uint8_t>(rhs.m_data).swap(m_data); 
    73104    } 
    74105    return (*this); 
    75106} 
    76107 
    77 uint16_t LASRecordHeader::GetReserved() const 
     108uint16_t LASVLR::GetReserved() const 
    78109{ 
    79110    return m_reserved; 
    80111} 
    81112 
    82 std::string const& LASRecordHeader::GetUserId() const 
    83 { 
    84     return m_userId; 
    85 } 
    86  
    87 uint16_t LASRecordHeader::GetRecordId() const 
     113void LASVLR::SetReserved(uint16_t id) 
     114{ 
     115    m_reserved = id; 
     116} 
     117 
     118std::string LASVLR::GetUserId(bool pad /*= false*/) 
     119{ 
     120    // copy array of chars and trim zeros if smaller than 32 bytes 
     121    std::string tmp(std::string(m_userId, eUIDSize).c_str()); 
     122 
     123    // pad right side with spaces 
     124    if (pad && tmp.size() < eUIDSize) 
     125    { 
     126        tmp.resize(eUIDSize, 0); 
     127        assert(tmp.size() == eUIDSize); 
     128    } 
     129 
     130    assert(tmp.size() <= eUIDSize); 
     131    return tmp; 
     132} 
     133 
     134void LASVLR::SetUserId(std::string const& v) 
     135{ 
     136    if (v.size() > eUIDSize) 
     137        throw std::invalid_argument("user id too long"); 
     138     
     139 
     140    std::fill(m_userId, m_userId + eUIDSize, 0); 
     141    std::strncpy(m_userId, v.c_str(), eUIDSize); 
     142} 
     143 
     144 
     145uint16_t LASVLR::GetRecordId() const 
    88146{ 
    89147    return m_recordId; 
    90148} 
    91149 
    92 uint16_t LASRecordHeader::GeRecordLength() const 
     150void LASVLR::SetRecordId(uint16_t v) { 
     151    m_recordId = v; 
     152} 
     153 
     154uint16_t LASVLR::GetRecordLength() const 
    93155{ 
    94156    return m_recordLength; 
    95157} 
    96158 
    97 std::string const& LASRecordHeader::GetDescription() const 
    98 { 
    99     return m_desc; 
    100 } 
    101  
    102 bool LASRecordHeader::equal(LASRecordHeader const& other) const 
     159void LASVLR::SetRecordLength(uint16_t v) { 
     160    m_recordLength = v; 
     161} 
     162 
     163std::string LASVLR::GetDescription(bool pad /*= false*/) 
     164{ 
     165    // copy array of chars and trim zeros if smaller than 32 bytes 
     166    std::string tmp(std::string(m_desc, eDescriptionSize).c_str()); 
     167 
     168    // pad right side with spaces 
     169    if (pad && tmp.size() < eDescriptionSize) 
     170    { 
     171        tmp.resize(eDescriptionSize, 0); 
     172        assert(tmp.size() == eDescriptionSize); 
     173    } 
     174 
     175    assert(tmp.size() <= eDescriptionSize); 
     176    return tmp; 
     177} 
     178 
     179void LASVLR::SetDescription(std::string const& v) 
     180{ 
     181    if (v.size() > eDescriptionSize) 
     182        throw std::invalid_argument("description is too long"); 
     183     
     184 
     185    std::fill(m_desc, m_desc + eDescriptionSize, 0); 
     186    std::strncpy(m_desc, v.c_str(), eDescriptionSize); 
     187} 
     188 
     189 
     190std::vector<uint8_t> LASVLR::GetData() const 
     191{ 
     192    return m_data; 
     193} 
     194 
     195void LASVLR::SetData(const std::vector<uint8_t>& v)  
     196{ 
     197    std::vector<uint8_t> m_data(v); 
     198} 
     199 
     200bool LASVLR::equal(LASVLR const& other) const 
    103201{ 
    104202    return (m_recordId == other.m_recordId 
Note: See TracChangeset for help on using the changeset viewer.