bounds.hpp | bounds.hpp | |||
---|---|---|---|---|
skipping to change at line 70 | skipping to change at line 70 | |||
namespace liblas { | namespace liblas { | |||
template <typename T> | template <typename T> | |||
class LAS_DLL Range | class LAS_DLL Range | |||
{ | { | |||
public: | public: | |||
T minimum; | T minimum; | |||
T maximum; | T maximum; | |||
typedef T value_type; | typedef T value_type; | |||
Range(T mmin=(std::numeric_limits<T>::max)(), T mmax=(std::numeric_limi ts<T>::min)()) | Range(T mmin=(std::numeric_limits<T>::max)(), T mmax=(std::numeric_limi ts<T>::min)()) | |||
: minimum(mmin), maximum(mmax) {} | : minimum(mmin), maximum(mmax) {} | |||
Range(Range const& other) | Range(Range const& other) | |||
: minimum(other.minimum) | : minimum(other.minimum) | |||
, maximum(other.maximum) | , maximum(other.maximum) | |||
{ | { | |||
} | } | |||
skipping to change at line 115 | skipping to change at line 115 | |||
|| !(detail::compare_distance(maximum, other.maximum))) | || !(detail::compare_distance(maximum, other.maximum))) | |||
{ | { | |||
return false; | return false; | |||
} | } | |||
return true; | return true; | |||
} | } | |||
bool overlaps(Range const& r) const | bool overlaps(Range const& r) const | |||
{ | { | |||
return minimum <= r.maximum && maximum >= r.minimum; | return minimum < r.maximum && maximum > r.minimum; | |||
} | } | |||
bool contains(Range const& r) const | bool contains(Range const& r) const | |||
{ | { | |||
return minimum <= r.minimum && r.maximum <= maximum; | return minimum <= r.minimum && r.maximum <= maximum; | |||
} | } | |||
bool contains(T v) const | bool contains(T v) const | |||
{ | { | |||
return minimum <= v && v <= maximum; | return minimum <= v && v <= maximum; | |||
End of changes. 2 change blocks. | ||||
2 lines changed or deleted | 2 lines changed or added | |||
chipper.hpp | chipper.hpp | |||
---|---|---|---|---|
#ifndef LIBLAS_CHIPPER_H | #ifndef LIBLAS_CHIPPER_H | |||
#define LIBLAS_CHIPPER_H | #define LIBLAS_CHIPPER_H | |||
#include <liblas/liblas.hpp> | #include <liblas/liblas.hpp> | |||
#include <liblas/export.hpp> | #include <liblas/export.hpp> | |||
#include <liblas/detail/opt_allocator.hpp> | ||||
#include <vector> | #include <vector> | |||
namespace liblas | namespace liblas | |||
{ | { | |||
namespace chipper | namespace chipper | |||
{ | { | |||
enum Direction | enum Direction | |||
skipping to change at line 32 | skipping to change at line 33 | |||
class LAS_DLL PtRef | class LAS_DLL PtRef | |||
{ | { | |||
public: | public: | |||
double m_pos; | double m_pos; | |||
boost::uint32_t m_ptindex; | boost::uint32_t m_ptindex; | |||
boost::uint32_t m_oindex; | boost::uint32_t m_oindex; | |||
bool operator < (const PtRef& pt) const | bool operator < (const PtRef& pt) const | |||
{ return m_pos < pt.m_pos; } | { return m_pos < pt.m_pos; } | |||
}; | }; | |||
typedef std::vector<PtRef, detail::opt_allocator<PtRef> > PtRefVec; | ||||
struct LAS_DLL RefList | struct LAS_DLL RefList | |||
{ | { | |||
public: | public: | |||
std::vector<PtRef> m_vec; | PtRefVec *m_vec_p; | |||
Direction m_dir; | Direction m_dir; | |||
RefList(Direction dir = DIR_NONE) : m_dir(dir) | RefList(Direction dir = DIR_NONE) : m_vec_p(NULL), m_dir(dir) | |||
{} | {} | |||
std::vector<PtRef>::size_type size() const | ~RefList() | |||
{ return m_vec.size(); } | { | |||
void reserve(std::vector<PtRef>::size_type n) | delete m_vec_p; | |||
{ m_vec.reserve(n); } | } | |||
void resize(std::vector<PtRef>::size_type n) | ||||
{ m_vec.resize(n); } | PtRefVec::size_type size() const | |||
{ return m_vec_p->size(); } | ||||
void reserve(PtRefVec::size_type n) | ||||
{ m_vec_p->reserve(n); } | ||||
void resize(PtRefVec::size_type n) | ||||
{ m_vec_p->resize(n); } | ||||
void push_back(const PtRef& ref) | void push_back(const PtRef& ref) | |||
{ m_vec.push_back(ref); } | { m_vec_p->push_back(ref); } | |||
std::vector<PtRef>::iterator begin() | PtRefVec::iterator begin() | |||
{ return m_vec.begin(); } | { return m_vec_p->begin(); } | |||
std::vector<PtRef>::iterator end() | PtRefVec::iterator end() | |||
{ return m_vec.end(); } | { return m_vec_p->end(); } | |||
PtRef& operator[](boost::uint32_t pos) | PtRef& operator[](boost::uint32_t pos) | |||
{ return m_vec[pos]; } | { return (*m_vec_p)[pos]; } | |||
std::string Dir() | std::string Dir() | |||
{ | { | |||
if (m_dir == DIR_X) | if (m_dir == DIR_X) | |||
return "X"; | return "X"; | |||
else if (m_dir == DIR_Y) | else if (m_dir == DIR_Y) | |||
return "Y"; | return "Y"; | |||
else | else | |||
return "NONE"; | return "NONE"; | |||
} | } | |||
void SortByOIndex(boost::uint32_t left, boost::uint32_t center, | ||||
boost::uint32_t right); | ||||
void SetAllocator(detail::opt_allocator<PtRef> *alloc_p ) | ||||
{ | ||||
m_vec_p = new PtRefVec( *alloc_p ); | ||||
} | ||||
}; | }; | |||
class LAS_DLL Chipper; | class LAS_DLL Chipper; | |||
class LAS_DLL Block | class LAS_DLL Block | |||
{ | { | |||
friend class Chipper; | friend class Chipper; | |||
private: | private: | |||
RefList *m_list_p; | RefList *m_list_p; | |||
boost::uint32_t m_left; | boost::uint32_t m_left; | |||
boost::uint32_t m_right; | boost::uint32_t m_right; | |||
liblas::Bounds<double> m_bounds; | liblas::Bounds<double> m_bounds; | |||
// double m_xmin; | ||||
// double m_ymin; | ||||
// double m_xmax; | ||||
// double m_ymax; | ||||
public: | public: | |||
std::vector<boost::uint32_t> GetIDs() const; | std::vector<boost::uint32_t> GetIDs() const; | |||
liblas::Bounds<double> const& GetBounds() const {return m_bounds;} | Bounds<double> const& GetBounds() const | |||
void SetBounds(liblas::Bounds<double> const& bounds) {m_bounds = bounds | {return m_bounds;} | |||
;} | void SetBounds(liblas::Bounds<double> const& bounds) | |||
// double GetXmin() const | {m_bounds = bounds;} | |||
// { return m_xmin; } | }; | |||
// double GetYmin() const | ||||
// { return m_ymin; } | // Options that can be used to modify the behavior of the chipper. | |||
// double GetXmax() const | class LAS_DLL Options | |||
// { return m_xmax; } | { | |||
// double GetYmax() const | public: | |||
// { return m_ymax; } | Options() : m_threshold( 1000 ), m_use_sort( false ), | |||
m_use_maps( false ) | ||||
{} | ||||
// Maximum number of pointer per output block. | ||||
boost::uint32_t m_threshold; | ||||
// If true, use sorting instead of copying to reduce memory. | ||||
bool m_use_sort; | ||||
// If true, use memory mapped files instead of main memory | ||||
bool m_use_maps; | ||||
// Map file to use if m_use_maps is true. | ||||
std::string m_map_file; | ||||
}; | }; | |||
class LAS_DLL Chipper | class LAS_DLL Chipper | |||
{ | { | |||
public: | public: | |||
Chipper(Reader *reader, Options *options ); | ||||
Chipper(Reader *reader, boost::uint32_t max_partition_size) : | Chipper(Reader *reader, boost::uint32_t max_partition_size) : | |||
m_reader(reader), m_threshold(max_partition_size), | m_reader(reader), m_xvec(DIR_X), m_yvec(DIR_Y), m_spare(DIR_NONE) | |||
m_xvec(DIR_X), m_yvec(DIR_Y), m_spare(DIR_NONE) | { | |||
{} | m_options.m_threshold = max_partition_size; | |||
} | ||||
void Chip(); | void Chip(); | |||
std::vector<Block>::size_type GetBlockCount() | std::vector<Block>::size_type GetBlockCount() | |||
{ return m_blocks.size(); } | { return m_blocks.size(); } | |||
const Block& GetBlock(std::vector<Block>::size_type i) | const Block& GetBlock(std::vector<Block>::size_type i) | |||
{ return m_blocks[i]; } | { return m_blocks[i]; } | |||
private: | private: | |||
void Load(RefList& xvec, RefList& yvec, RefList& spare); | int Allocate(); | |||
int Load(); | ||||
void Partition(boost::uint32_t size); | void Partition(boost::uint32_t size); | |||
void Split(RefList& xvec, RefList& yvec, RefList& spare); | void Split(RefList& xvec, RefList& yvec, RefList& spare); | |||
void DecideSplit(RefList& v1, RefList& v2, RefList& spare, | void DecideSplit(RefList& v1, RefList& v2, RefList& spare, | |||
boost::uint32_t left, boost::uint32_t right); | boost::uint32_t left, boost::uint32_t right); | |||
void RearrangeNarrow(RefList& wide, RefList& narrow, RefList& spare, | ||||
boost::uint32_t left, boost::uint32_t center, boost::uint32_t right | ||||
); | ||||
void Split(RefList& wide, RefList& narrow, RefList& spare, | void Split(RefList& wide, RefList& narrow, RefList& spare, | |||
boost::uint32_t left, boost::uint32_t right); | boost::uint32_t left, boost::uint32_t right); | |||
void FinalSplit(RefList& wide, RefList& narrow, | void FinalSplit(RefList& wide, RefList& narrow, | |||
boost::uint32_t pleft, boost::uint32_t pcenter); | boost::uint32_t pleft, boost::uint32_t pcenter); | |||
void Emit(RefList& wide, boost::uint32_t widemin, boost::uint32_t widem ax, | void Emit(RefList& wide, boost::uint32_t widemin, boost::uint32_t widem ax, | |||
RefList& narrow, boost::uint32_t narrowmin, boost::uint32_t narrowm ax ); | RefList& narrow, boost::uint32_t narrowmin, boost::uint32_t narrowm ax); | |||
Reader *m_reader; | Reader *m_reader; | |||
boost::uint32_t m_threshold; | ||||
std::vector<Block> m_blocks; | std::vector<Block> m_blocks; | |||
std::vector<boost::uint32_t> m_partitions; | std::vector<boost::uint32_t> m_partitions; | |||
// Note, order is important here, as the allocator must be destroyed | ||||
// after the RefLists. | ||||
boost::shared_ptr<detail::opt_allocator<PtRef> > m_allocator; | ||||
RefList m_xvec; | RefList m_xvec; | |||
RefList m_yvec; | RefList m_yvec; | |||
RefList m_spare; | RefList m_spare; | |||
Options m_options; | ||||
}; | }; | |||
} // namespace chipper | } // namespace chipper | |||
} // namespace liblas | } // namespace liblas | |||
#endif | #endif | |||
End of changes. 18 change blocks. | ||||
35 lines changed or deleted | 64 lines changed or added | |||
classification.hpp | classification.hpp | |||
---|---|---|---|---|
skipping to change at line 142 | skipping to change at line 142 | |||
{ | { | |||
if (&rhs != this) | if (&rhs != this) | |||
{ | { | |||
m_flags = rhs.m_flags; | m_flags = rhs.m_flags; | |||
} | } | |||
return *this; | return *this; | |||
} | } | |||
/// Conversion operator. | /// Conversion operator. | |||
/// Returns classification object as in form of std::bitset<8>. | /// Returns classification object as in form of std::bitset<8>. | |||
/// bitset< object | ||||
operator bitset_type() const | operator bitset_type() const | |||
{ | { | |||
return bitset_type(m_flags); | return bitset_type(m_flags); | |||
} | } | |||
/// Named accessor converting Classification to std::bitset<8>. | ||||
bitset_type GetFlags() const | ||||
{ | ||||
return bitset_type(m_flags); | ||||
} | ||||
/// Raturns name of class as defined in LAS 1.1+ | /// Raturns name of class as defined in LAS 1.1+ | |||
/// Finds class name in lookup table based on class index | /// Finds class name in lookup table based on class index | |||
/// as defined in classification object. | /// as defined in classification object. | |||
std::string GetClassName() const; | std::string GetClassName() const; | |||
/// Returns index of ASPRS classification as defined in the lookup tabl e. | /// Returns index of ASPRS classification as defined in the lookup tabl e. | |||
boost::uint8_t GetClass() const; | boost::uint8_t GetClass() const; | |||
/// Updates index of ASPRS classification as defined in the lookup tabl e. | /// Updates index of ASPRS classification as defined in the lookup tabl e. | |||
/// Valid index is in range from 0 to class_table_size - 1. | /// Valid index is in range from 0 to class_table_size - 1. | |||
End of changes. 2 change blocks. | ||||
1 lines changed or deleted | 6 lines changed or added | |||
dimension.hpp | dimension.hpp | |||
---|---|---|---|---|
skipping to change at line 81 | skipping to change at line 81 | |||
namespace liblas { | namespace liblas { | |||
/// Dimension definition | /// Dimension definition | |||
class LAS_DLL Dimension | class LAS_DLL Dimension | |||
{ | { | |||
public: | public: | |||
Dimension(std::string const& name, std::size_t size_in_bits); | Dimension(std::string const& name, std::size_t size_in_bits); | |||
Dimension& operator=(Dimension const& rhs); | Dimension& operator=(Dimension const& rhs); | |||
Dimension(Dimension const& other); | Dimension(Dimension const& other); | |||
bool operator==(const Dimension& other) const; | ||||
bool operator!=(const Dimension& other) const { return !(*this == other | ||||
); } | ||||
virtual ~Dimension() {} | virtual ~Dimension() {} | |||
inline std::string const& GetName() const { return m_name; } | inline std::string const& GetName() const { return m_name; } | |||
/// bits, total logical size of point record, including any custom | /// bits, total logical size of point record, including any custom | |||
/// dimensions | /// dimensions | |||
inline std::size_t GetBitSize() const | inline std::size_t GetBitSize() const | |||
{ | { | |||
return m_bit_size; | return m_bit_size; | |||
} | } | |||
End of changes. 1 change blocks. | ||||
0 lines changed or deleted | 4 lines changed or added | |||
factory.hpp | factory.hpp | |||
---|---|---|---|---|
skipping to change at line 59 | skipping to change at line 59 | |||
// boost | // boost | |||
#include <boost/cstdint.hpp> | #include <boost/cstdint.hpp> | |||
// std | // std | |||
namespace liblas { | namespace liblas { | |||
class LAS_DLL ReaderFactory | class LAS_DLL ReaderFactory | |||
{ | { | |||
public: | public: | |||
ReaderFactory() {}; | ReaderFactory() {} | |||
ReaderFactory(ReaderFactory const& other); | ReaderFactory(ReaderFactory const& other); | |||
ReaderFactory& operator=(ReaderFactory const& rhs); | ReaderFactory& operator=(ReaderFactory const& rhs); | |||
Reader CreateWithImpl(ReaderIPtr r); | Reader CreateWithImpl(ReaderIPtr r); | |||
Reader CreateCached(std::istream& stream, boost::uint32_t cache_size); | Reader CreateCached(std::istream& stream, boost::uint32_t cache_size); | |||
Reader CreateWithStream(std::istream& stream); | Reader CreateWithStream(std::istream& stream); | |||
// help function to create an input stream | // help function to create an input stream | |||
// returns NULL if failed to open | // returns NULL if failed to open | |||
// static std::istream* FileOpen(std::string const& filename, std::ios: :openmode mode); | // static std::istream* FileOpen(std::string const& filename, std::ios: :openmode mode); | |||
// static void FileClose(std::istream*); | // static void FileClose(std::istream*); | |||
/// Destructor. | /// Destructor. | |||
/// @exception nothrow | /// @exception nothrow | |||
~ReaderFactory() {}; | ~ReaderFactory() {} | |||
private: | private: | |||
}; | }; | |||
class LAS_DLL WriterFactory | class LAS_DLL WriterFactory | |||
{ | { | |||
public: | public: | |||
enum FileType | enum FileType | |||
{ | { | |||
FileType_Unknown, | FileType_Unknown, | |||
FileType_LAS, | FileType_LAS, | |||
FileType_LAZ | FileType_LAZ | |||
}; | }; | |||
WriterFactory() {}; | WriterFactory() {} | |||
WriterFactory(WriterFactory const& other); | WriterFactory(WriterFactory const& other); | |||
WriterFactory& operator=(WriterFactory const& rhs); | WriterFactory& operator=(WriterFactory const& rhs); | |||
Writer CreateWithImpl(WriterIPtr w); | Writer CreateWithImpl(WriterIPtr w); | |||
// makes a WriterImpl or a ZipWriterImpl, depending on header type | // makes a WriterImpl or a ZipWriterImpl, depending on header type | |||
static WriterIPtr CreateWithStream(std::ostream& stream, Header const& header); | static WriterIPtr CreateWithStream(std::ostream& stream, Header const& header); | |||
/// Destructor. | /// Destructor. | |||
/// @exception nothrow | /// @exception nothrow | |||
~WriterFactory() {}; | ~WriterFactory() {} | |||
// returns Unknown, unless we find a .laz or .las extension | // returns Unknown, unless we find a .laz or .las extension | |||
static FileType InferFileTypeFromExtension(const std::string&); | static FileType InferFileTypeFromExtension(const std::string&); | |||
// | // | |||
private: | private: | |||
}; | }; | |||
} // namespace liblas | } // namespace liblas | |||
End of changes. 4 change blocks. | ||||
4 lines changed or deleted | 4 lines changed or added | |||
index.hpp | index.hpp | |||
---|---|---|---|---|
skipping to change at line 491 | skipping to change at line 491 | |||
double LowFilterZ, double HighFilterZ, boost::uint32_t Chunk Size); | double LowFilterZ, double HighFilterZ, boost::uint32_t Chunk Size); | |||
IndexIterator(Index *IndexSrc, IndexData const& IndexDataSrc, boost: :uint32_t ChunkSize); | IndexIterator(Index *IndexSrc, IndexData const& IndexDataSrc, boost: :uint32_t ChunkSize); | |||
IndexIterator(Index *IndexSrc, Bounds<double> const& BoundsSrc, boos t::uint32_t ChunkSize); | IndexIterator(Index *IndexSrc, Bounds<double> const& BoundsSrc, boos t::uint32_t ChunkSize); | |||
/// Copy constructor. | /// Copy constructor. | |||
IndexIterator(IndexIterator const& other); | IndexIterator(IndexIterator const& other); | |||
/// Assignment operator. | /// Assignment operator. | |||
IndexIterator& operator=(IndexIterator const& rhs); | IndexIterator& operator=(IndexIterator const& rhs); | |||
private: | private: | |||
void Copy(IndexIterator const& other); | void Copy(IndexIterator const& other); | |||
void ResetPosition(void); | void ResetPosition(void); | |||
boost::uint8_t MinMajorVersion(void) {return(1);}; | boost::uint8_t MinMajorVersion(void) {return(1);} | |||
boost::uint8_t MinMinorVersion(void) {return(2);}; | boost::uint8_t MinMinorVersion(void) {return(2);} | |||
public: | public: | |||
/// n=0 or n=1 gives next sequence with no gap, n>1 skips n-1 filter -compliant points, n<0 jumps backwards n compliant points | /// n=0 or n=1 gives next sequence with no gap, n>1 skips n-1 filter -compliant points, n<0 jumps backwards n compliant points | |||
const std::vector<boost::uint32_t>& advance(boost::int32_t n); | const std::vector<boost::uint32_t>& advance(boost::int32_t n); | |||
/// returns filter-compliant points as though the first point returned is element n in a zero-based array | /// returns filter-compliant points as though the first point returned is element n in a zero-based array | |||
const std::vector<boost::uint32_t>& operator()(boost::int32_t n); | const std::vector<boost::uint32_t>& operator()(boost::int32_t n); | |||
/// returns next set of filter-compliant points with no skipped poin ts | /// returns next set of filter-compliant points with no skipped poin ts | |||
inline const std::vector<boost::uint32_t>& operator++() {return (adv ance(1));} | inline const std::vector<boost::uint32_t>& operator++() {return (adv ance(1));} | |||
/// returns next set of filter-compliant points with no skipped poin ts | /// returns next set of filter-compliant points with no skipped poin ts | |||
inline const std::vector<boost::uint32_t>& operator++(int) {ret urn (advance(1));} | inline const std::vector<boost::uint32_t>& operator++(int) {ret urn (advance(1));} | |||
skipping to change at line 518 | skipping to change at line 518 | |||
inline const std::vector<boost::uint32_t>& operator+=(boost::int32_t n) {return (advance(n));} | inline const std::vector<boost::uint32_t>& operator+=(boost::int32_t n) {return (advance(n));} | |||
/// returns next set of filter-compliant points with n-1 skipped poi nts, for n<0 acts like -() | /// returns next set of filter-compliant points with n-1 skipped poi nts, for n<0 acts like -() | |||
inline const std::vector<boost::uint32_t>& operator+(boost::int32_t n) {return (advance(n));} | inline const std::vector<boost::uint32_t>& operator+(boost::int32_t n) {return (advance(n));} | |||
/// returns set of filter-compliant points beginning n points backwa rds from the end of the last set, for n<0 acts like +=() | /// returns set of filter-compliant points beginning n points backwa rds from the end of the last set, for n<0 acts like +=() | |||
inline const std::vector<boost::uint32_t>& operator-=(boost::int32_t n) {return (advance(-n));} | inline const std::vector<boost::uint32_t>& operator-=(boost::int32_t n) {return (advance(-n));} | |||
/// returns set of filter-compliant points beginning n points backwa rds from the end of the last set, for n<0 acts like +() | /// returns set of filter-compliant points beginning n points backwa rds from the end of the last set, for n<0 acts like +() | |||
inline const std::vector<boost::uint32_t>& operator-(boost::int32_t n) {return (advance(-n));} | inline const std::vector<boost::uint32_t>& operator-(boost::int32_t n) {return (advance(-n));} | |||
/// returns filter-compliant points as though the first point returned is element n in a zero-based array | /// returns filter-compliant points as though the first point returned is element n in a zero-based array | |||
inline const std::vector<boost::uint32_t>& operator[](boost::int32_t n) {return ((*this)(n));} | inline const std::vector<boost::uint32_t>& operator[](boost::int32_t n) {return ((*this)(n));} | |||
/// tests viability of index for filtering with iterator | /// tests viability of index for filtering with iterator | |||
bool ValidateIndexVersion(boost::uint8_t VersionMajor, boost::uint8_ t VersionMinor) {return (VersionMajor > MinMajorVersion() || (VersionMa jor == MinMajorVersion() && VersionMinor >= MinMinorVersion()));}; | bool ValidateIndexVersion(boost::uint8_t VersionMajor, boost::uint8_ t VersionMinor) {return (VersionMajor > MinMajorVersion() || (VersionMa jor == MinMajorVersion() && VersionMinor >= MinMinorVersion()));} | |||
}; | }; | |||
template <typename T, typename Q> | template <typename T, typename Q> | |||
inline void ReadVLRData_n(T& dest, IndexVLRData const& src, Q& pos) | inline void ReadVLRData_n(T& dest, IndexVLRData const& src, Q& pos) | |||
{ | { | |||
// error if reading past array end | // error if reading past array end | |||
if (static_cast<size_t>(pos) + sizeof(T) > src.size()) | if (static_cast<size_t>(pos) + sizeof(T) > src.size()) | |||
throw std::out_of_range("liblas::detail::ReadVLRData_n: arra y index out of range"); | throw std::out_of_range("liblas::detail::ReadVLRData_n: arra y index out of range"); | |||
// copy sizeof(T) bytes to destination | // copy sizeof(T) bytes to destination | |||
memcpy(&dest, &src[pos], sizeof(T)); | memcpy(&dest, &src[pos], sizeof(T)); | |||
End of changes. 2 change blocks. | ||||
3 lines changed or deleted | 3 lines changed or added | |||
indexoutput.hpp | indexoutput.hpp | |||
---|---|---|---|---|
skipping to change at line 80 | skipping to change at line 80 | |||
}; | }; | |||
template <typename T, typename Q> | template <typename T, typename Q> | |||
inline void WriteVLRData_n(IndexVLRData& dest, T& src, Q& pos) | inline void WriteVLRData_n(IndexVLRData& dest, T& src, Q& pos) | |||
{ | { | |||
// Fix little-endian | // Fix little-endian | |||
LIBLAS_SWAP_BYTES_N(src, sizeof(T)); | LIBLAS_SWAP_BYTES_N(src, sizeof(T)); | |||
// error if writing past array end | // error if writing past array end | |||
if (static_cast<size_t>(pos) + sizeof(T) > dest.size()) | if (static_cast<size_t>(pos) + sizeof(T) > dest.size()) | |||
throw std::out_of_range("liblas::detail::WriteVLRData_n: array inde x out of range"); | dest.resize(dest.size() + (std::numeric_limits<unsigned short>::max )()); | |||
// copy sizeof(T) bytes to destination | // copy sizeof(T) bytes to destination | |||
memcpy(&dest[pos], &src, sizeof(T)); | memcpy(&dest[pos], &src, sizeof(T)); | |||
// increment the write position to end of written data | // increment the write position to end of written data | |||
pos += sizeof(T); | pos += sizeof(T); | |||
} | } | |||
template <typename T, typename Q> | template <typename T, typename Q> | |||
inline void WriteVLRDataNoInc_n(IndexVLRData& dest, T& src, Q const& pos) | inline void WriteVLRDataNoInc_n(IndexVLRData& dest, T& src, Q const& pos) | |||
{ | { | |||
// Fix little-endian | // Fix little-endian | |||
LIBLAS_SWAP_BYTES_N(src, sizeof(T)); | LIBLAS_SWAP_BYTES_N(src, sizeof(T)); | |||
// error if writing past array end | // error if writing past array end | |||
if (static_cast<size_t>(pos) + sizeof(T) > dest.size()) | if (static_cast<size_t>(pos) + sizeof(T) > dest.size()) | |||
throw std::out_of_range("liblas::detail::WriteVLRDataNoInc_n: array index out of range"); | dest.resize(dest.size() + (std::numeric_limits<unsigned short>::max )()); | |||
// copy sizeof(T) bytes to destination | // copy sizeof(T) bytes to destination | |||
memcpy(&dest[pos], &src, sizeof(T)); | memcpy(&dest[pos], &src, sizeof(T)); | |||
} | } | |||
template <typename T, typename Q> | template <typename T, typename Q> | |||
inline void WriteVLRData_str(IndexVLRData& dest, char * const src, T const srclen, Q& pos) | inline void WriteVLRData_str(IndexVLRData& dest, char * const src, T const srclen, Q& pos) | |||
{ | { | |||
// copy srclen bytes to destination | // copy srclen bytes to destination | |||
std::memcpy(&dest[pos], src, srclen); | std::memcpy(&dest[pos], src, srclen); | |||
// error if writing past array end | // error if writing past array end | |||
if (static_cast<size_t>(pos) + static_cast<size_t>(srclen) > dest.size( )) | if (static_cast<size_t>(pos) + static_cast<size_t>(srclen) > dest.size( )) | |||
throw std::out_of_range("liblas::detail::WriteVLRData_str: array in dex out of range"); | dest.resize(dest.size() + (std::numeric_limits<unsigned short>::max )()); | |||
// increment the write position to end of written data | // increment the write position to end of written data | |||
pos += srclen; | pos += srclen; | |||
} | } | |||
template <typename T, typename Q> | template <typename T, typename Q> | |||
inline void WriteVLRDataNoInc_str(IndexVLRData& dest, char * const src, T c onst srclen, Q pos) | inline void WriteVLRDataNoInc_str(IndexVLRData& dest, char * const src, T c onst srclen, Q pos) | |||
{ | { | |||
// error if writing past array end | // error if writing past array end | |||
if (static_cast<size_t>(pos) + static_cast<size_t>(srclen) > dest.size( )) | if (static_cast<size_t>(pos) + static_cast<size_t>(srclen) > dest.size( )) | |||
throw std::out_of_range("liblas::detail::WriteVLRDataNoInc_str: arr ay index out of range"); | dest.resize(dest.size() + (std::numeric_limits<unsigned short>::max )()); | |||
// copy srclen bytes to destination | // copy srclen bytes to destination | |||
memcpy(&dest[pos], src, srclen); | memcpy(&dest[pos], src, srclen); | |||
} | } | |||
}} // namespace liblas::detail | }} // namespace liblas::detail | |||
#endif // LIBLAS_DETAIL_INDEXOUTPUT_HPP_INCLUDED | #endif // LIBLAS_DETAIL_INDEXOUTPUT_HPP_INCLUDED | |||
End of changes. 4 change blocks. | ||||
4 lines changed or deleted | 4 lines changed or added | |||
las_version.h | las_version.h | |||
---|---|---|---|---|
skipping to change at line 47 | skipping to change at line 47 | |||
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT | * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT | |||
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY | * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY | |||
* OF SUCH DAMAGE. | * OF SUCH DAMAGE. | |||
************************************************************************** **/ | ************************************************************************** **/ | |||
#ifndef LAS_VERSION_H_INCLUDED | #ifndef LAS_VERSION_H_INCLUDED | |||
#define LAS_VERSION_H_INCLUDED | #define LAS_VERSION_H_INCLUDED | |||
#ifndef LIBLAS_VERSION_MAJOR | #ifndef LIBLAS_VERSION_MAJOR | |||
#define LIBLAS_VERSION_MAJOR 1 | #define LIBLAS_VERSION_MAJOR 1 | |||
#define LIBLAS_VERSION_MINOR 6 | #define LIBLAS_VERSION_MINOR 7 | |||
#define LIBLAS_VERSION_REV 1 | #define LIBLAS_VERSION_REV 0 | |||
#define LIBLAS_VERSION_BUILD 0 | #define LIBLAS_VERSION_BUILD 0 | |||
#endif | #endif | |||
#ifndef LIBLAS_VERSION_NUM | #ifndef LIBLAS_VERSION_NUM | |||
#define LIBLAS_VERSION_NUM (LIBLAS_VERSION_MAJOR*1000+LIBLAS_VERSION_M INOR*100+LIBLAS_VERSION_REV*10+LIBLAS_VERSION_BUILD) | #define LIBLAS_VERSION_NUM (LIBLAS_VERSION_MAJOR*1000+LIBLAS_VERSION_M INOR*100+LIBLAS_VERSION_REV*10+LIBLAS_VERSION_BUILD) | |||
#endif | #endif | |||
#ifndef LIBLAS_RELEASE_DATE | #ifndef LIBLAS_RELEASE_DATE | |||
#define LIBLAS_RELEASE_DATE 20100405 | #define LIBLAS_RELEASE_DATE 20120105 | |||
#endif | #endif | |||
#ifndef LIBLAS_RELEASE_NAME | #ifndef LIBLAS_RELEASE_NAME | |||
#define LIBLAS_RELEASE_NAME "1.6.1" | #define LIBLAS_RELEASE_NAME "1.7.0" | |||
#endif | #endif | |||
#endif /* LAS_VERSION_H_INCLUDED */ | #endif /* LAS_VERSION_H_INCLUDED */ | |||
End of changes. 3 change blocks. | ||||
4 lines changed or deleted | 4 lines changed or added | |||
liblas.h | liblas.h | |||
---|---|---|---|---|
skipping to change at line 207 | skipping to change at line 207 | |||
LAS_DLL LASError LASReader_SetOutputSRS(LASReaderH hReader, const LASSRSH h SRS); | LAS_DLL LASError LASReader_SetOutputSRS(LASReaderH hReader, const LASSRSH h SRS); | |||
/** Seeks to the specified point for the next LASReader_GetNextPoint | /** Seeks to the specified point for the next LASReader_GetNextPoint | |||
* operation to start from. If an error is returned, the seek failed | * operation to start from. If an error is returned, the seek failed | |||
* for some reason. | * for some reason. | |||
* @param hReader the LASReaderH instance | * @param hReader the LASReaderH instance | |||
* @return a LASError defaulting to LE_None upon success. | * @return a LASError defaulting to LE_None upon success. | |||
*/ | */ | |||
LAS_DLL LASError LASReader_Seek(LASReaderH hReader, unsigned int position); | LAS_DLL LASError LASReader_Seek(LASReaderH hReader, unsigned int position); | |||
LAS_DLL char* LASReader_GetSummaryXML(const LASReaderH hReader); | ||||
/************************************************************************** **/ | /************************************************************************** **/ | |||
/* Point operations */ | /* Point operations */ | |||
/************************************************************************** **/ | /************************************************************************** **/ | |||
/** Returns the X value for the point. This value is scaled by any header | /** Returns the X value for the point. This value is scaled by any header | |||
* information that is present for the point. Use GetRawX if you want uns caled | * information that is present for the point. Use GetRawX if you want uns caled | |||
* data. | * data. | |||
* header values after the value is read. | * header values after the value is read. | |||
* @param hPoint the opaque pointer to the LASPointH instance | * @param hPoint the opaque pointer to the LASPointH instance | |||
* @return the X value for the LASPointH | * @return the X value for the LASPointH | |||
skipping to change at line 523 | skipping to change at line 525 | |||
/** Sets the data stream for the Point as an array of bytes. The length of this | /** Sets the data stream for the Point as an array of bytes. The length of this | |||
* array should be the same as LASPoint_GetHeader(LASHeader_GetDataRecordL ength()). The data are copied into | * array should be the same as LASPoint_GetHeader(LASHeader_GetDataRecordL ength()). The data are copied into | |||
* the Point . | * the Point . | |||
* @param hPoint the LASPointH instance | * @param hPoint the LASPointH instance | |||
* @param data a pointer to your array. It must be LASPoint_GetHeader(LAS Header_GetDataRecordLength()) in size | * @param data a pointer to your array. It must be LASPoint_GetHeader(LAS Header_GetDataRecordLength()) in size | |||
* @return LASErrorEnum | * @return LASErrorEnum | |||
*/ | */ | |||
LAS_DLL LASError LASPoint_SetData(LASPointH hPoint, unsigned char* data); | LAS_DLL LASError LASPoint_SetData(LASPointH hPoint, unsigned char* data); | |||
/** Returns an XMLized representation of the point | ||||
* @param hPoint the LASPointH instance | ||||
*/ | ||||
LAS_DLL char* LASPoint_GetXML(const LASPointH hPoint); | ||||
/************************************************************************** **/ | /************************************************************************** **/ | |||
/* Header operations */ | /* Header operations */ | |||
/************************************************************************** **/ | /************************************************************************** **/ | |||
/** Copies a LASHeaderH instance | /** Copies a LASHeaderH instance | |||
* @param hHeader the LASHeaderH to copy | * @param hHeader the LASHeaderH to copy | |||
* @return a LASHeaderH instance or NULL on error | * @return a LASHeaderH instance or NULL on error | |||
*/ | */ | |||
LAS_DLL LASHeaderH LASHeader_Copy(const LASHeaderH hHeader); | LAS_DLL LASHeaderH LASHeader_Copy(const LASHeaderH hHeader); | |||
skipping to change at line 702 | skipping to change at line 709 | |||
LAS_DLL unsigned int LASHeader_GetDataOffset(const LASHeaderH hHeader); | LAS_DLL unsigned int LASHeader_GetDataOffset(const LASHeaderH hHeader); | |||
/** Sets the location in number of bytes to start writing point data. Any | /** Sets the location in number of bytes to start writing point data. Any | |||
* space between the end of the LASVLRHs and this value will be written wi th 0's. | * space between the end of the LASVLRHs and this value will be written wi th 0's. | |||
* @param hHeader LASHeaderH instance | * @param hHeader LASHeaderH instance | |||
* @param value the long integer to set for byte location determining the end of the header | * @param value the long integer to set for byte location determining the end of the header | |||
* @return LASError enum | * @return LASError enum | |||
*/ | */ | |||
LAS_DLL LASError LASHeader_SetDataOffset(const LASHeaderH hHeader, unsigne d int value); | LAS_DLL LASError LASHeader_SetDataOffset(const LASHeaderH hHeader, unsigne d int value); | |||
/** Returns the number of bytes between the end of the VLRs on the header t | ||||
o the data offset | ||||
* @param hHeader LASHeaderH instance | ||||
* @return the number of bytes between the end of the VLRs on the header t | ||||
o the data offset | ||||
*/ | ||||
LAS_DLL unsigned int LASHeader_GetHeaderPadding(const LASHeaderH hHeader); | ||||
/** Sets the number of bytes between the end of the VLRs on the header to t | ||||
he data offset | ||||
* @param hHeader LASHeaderH instance | ||||
* @param value the long integer to set for the number of bytes between th | ||||
e end of the VLRs and the data offset | ||||
* @return LASError enum | ||||
*/ | ||||
LAS_DLL LASError LASHeader_SetHeaderPadding(const LASHeaderH hHeader, unsi | ||||
gned int value); | ||||
/** Returns the number of variable length records in the header | /** Returns the number of variable length records in the header | |||
* @param hHeader LASHeaderH instance | * @param hHeader LASHeaderH instance | |||
* @return the number of variable length records in the header | * @return the number of variable length records in the header | |||
*/ | */ | |||
LAS_DLL unsigned int LASHeader_GetRecordsCount(const LASHeaderH hHeader); | LAS_DLL unsigned int LASHeader_GetRecordsCount(const LASHeaderH hHeader); | |||
/** Returns the record length for the points based on their data format id in bytes | /** Returns the record length for the points based on their data format id in bytes | |||
* @param hHeader LASHeaderH instance | * @param hHeader LASHeaderH instance | |||
* @return the record length for the points based on their data format id in bytes | * @return the record length for the points based on their data format id in bytes | |||
*/ | */ | |||
skipping to change at line 896 | skipping to change at line 916 | |||
*/ | */ | |||
LAS_DLL LASError LASHeader_DeleteVLR(LASHeaderH hHeader, unsigned int index ); | LAS_DLL LASError LASHeader_DeleteVLR(LASHeaderH hHeader, unsigned int index ); | |||
/** Adds a VLR record to the header. | /** Adds a VLR record to the header. | |||
* @param hHeader the LASHeaderH instance | * @param hHeader the LASHeaderH instance | |||
* @param hVLR the VLR to add to the header | * @param hVLR the VLR to add to the header | |||
* @return LASErrorEnum | * @return LASErrorEnum | |||
*/ | */ | |||
LAS_DLL LASError LASHeader_AddVLR(LASHeaderH hHeader, const LASVLRH hVLR); | LAS_DLL LASError LASHeader_AddVLR(LASHeaderH hHeader, const LASVLRH hVLR); | |||
/** Returns an XMLized representation of the header | ||||
* @param hHeader the LASHeader instance | ||||
*/ | ||||
LAS_DLL char* LASHeader_GetXML(const LASHeaderH hHeader); | ||||
/************************************************************************** **/ | /************************************************************************** **/ | |||
/* Writer Operations */ | /* Writer Operations */ | |||
/************************************************************************** **/ | /************************************************************************** **/ | |||
/** Creates a new LASWriterH for write operations on LAS files. The file m ay | /** Creates a new LASWriterH for write operations on LAS files. The file m ay | |||
* be opened in either LAS_MODE_APPEND or LAS_MODE_WRITE, but the file can not | * be opened in either LAS_MODE_APPEND or LAS_MODE_WRITE, but the file can not | |||
* be open by another other operations (another LASReaderH or LASWriterH). | * be open by another other operations (another LASReaderH or LASWriterH). | |||
* @param filename The filename to open to write | * @param filename The filename to open to write | |||
* @param hHeader an opaque pointer to a LASHeaderH that will be written t o | * @param hHeader an opaque pointer to a LASHeaderH that will be written t o | |||
* the file as part of the opening for write operation. | * the file as part of the opening for write operation. | |||
End of changes. 4 change blocks. | ||||
0 lines changed or deleted | 30 lines changed or added | |||
private_utility.hpp | private_utility.hpp | |||
---|---|---|---|---|
skipping to change at line 440 | skipping to change at line 440 | |||
inline void write_n<std::string>(std::ostream& dest, std::string const& src , std::streamsize const& num) | inline void write_n<std::string>(std::ostream& dest, std::string const& src , std::streamsize const& num) | |||
{ | { | |||
if (!dest) | if (!dest) | |||
throw std::runtime_error("detail::liblas::write_n<std::string>: out put stream is not writable"); | throw std::runtime_error("detail::liblas::write_n<std::string>: out put stream is not writable"); | |||
dest.write(src.c_str(), num); | dest.write(src.c_str(), num); | |||
check_stream_state(dest); | check_stream_state(dest); | |||
} | } | |||
#ifdef _MSC_VER | #ifdef _MSC_VER | |||
# pragma warning(push) | # pragma warning(pop) | |||
#endif | #endif | |||
// Utility functor with accompanying to print GeoTIFF directory. | // Utility functor with accompanying to print GeoTIFF directory. | |||
struct geotiff_dir_printer | struct geotiff_dir_printer | |||
{ | { | |||
geotiff_dir_printer() {} | geotiff_dir_printer() {} | |||
std::string output() const { return m_oss.str(); } | std::string output() const { return m_oss.str(); } | |||
std::string::size_type size() const { return m_oss.str().size(); } | std::string::size_type size() const { return m_oss.str().size(); } | |||
End of changes. 1 change blocks. | ||||
1 lines changed or deleted | 1 lines changed or added | |||
schema.hpp | schema.hpp | |||
---|---|---|---|---|
skipping to change at line 109 | skipping to change at line 109 | |||
/// Schema definition | /// Schema definition | |||
class LAS_DLL Schema | class LAS_DLL Schema | |||
{ | { | |||
public: | public: | |||
// Schema(); | // Schema(); | |||
Schema(PointFormatName data_format_id); | Schema(PointFormatName data_format_id); | |||
Schema(std::vector<VariableRecord> const& vlrs); | Schema(std::vector<VariableRecord> const& vlrs); | |||
Schema& operator=(Schema const& rhs); | Schema& operator=(Schema const& rhs); | |||
bool operator==(const Schema& other) const; | ||||
bool operator!=(const Schema& other) const { return !(*this == other); | ||||
} | ||||
Schema(Schema const& other); | Schema(Schema const& other); | |||
~Schema() {} | ~Schema() {} | |||
/// Fetch byte size | /// Fetch byte size | |||
std::size_t GetByteSize() const; | std::size_t GetByteSize() const; | |||
std::size_t GetBitSize() const; | std::size_t GetBitSize() const; | |||
void CalculateSizes(); | void CalculateSizes(); | |||
End of changes. 1 change blocks. | ||||
0 lines changed or deleted | 5 lines changed or added | |||
spatialreference.hpp | spatialreference.hpp | |||
---|---|---|---|---|
skipping to change at line 100 | skipping to change at line 100 | |||
/// Constructor creating SpatialReference instance from given Variable- Length Record. | /// Constructor creating SpatialReference instance from given Variable- Length Record. | |||
SpatialReference(std::vector<VariableRecord> const& vlrs); | SpatialReference(std::vector<VariableRecord> const& vlrs); | |||
/// Copy constryctor. | /// Copy constryctor. | |||
SpatialReference(SpatialReference const& other); | SpatialReference(SpatialReference const& other); | |||
/// Assignment operator. | /// Assignment operator. | |||
SpatialReference& operator=(SpatialReference const& rhs); | SpatialReference& operator=(SpatialReference const& rhs); | |||
bool operator==(const SpatialReference& other) const; | ||||
bool operator!=(const SpatialReference& other) const { return !(*this = | ||||
= other); } | ||||
/// Returns a pointer to the internal GTIF*. Only available if | /// Returns a pointer to the internal GTIF*. Only available if | |||
/// you have libgeotiff linked in. | /// you have libgeotiff linked in. | |||
const GTIF* GetGTIF(); | const GTIF* GetGTIF(); | |||
void SetGTIF(GTIF* pgtiff, ST_TIFF* ptiff); | void SetGTIF(GTIF* pgtiff, ST_TIFF* ptiff); | |||
/// Returns the OGC WKT describing Spatial Reference System. | /// Returns the OGC WKT describing Spatial Reference System. | |||
/// If GDAL is linked, it uses GDAL's operations and methods to determi ne | /// If GDAL is linked, it uses GDAL's operations and methods to determi ne | |||
/// the WKT. If GDAL is not linked, no WKT is returned. | /// the WKT. If GDAL is not linked, no WKT is returned. | |||
/// \param mode_flag May be eHorizontalOnly indicating the WKT will not | /// \param mode_flag May be eHorizontalOnly indicating the WKT will not | |||
skipping to change at line 196 | skipping to change at line 199 | |||
/// Reset the VLRs of the SpatialReference using the existing GTIF* and ST_TIF* | /// Reset the VLRs of the SpatialReference using the existing GTIF* and ST_TIF* | |||
/// Until this method is called, | /// Until this method is called, | |||
/// the SpatialReference will only contain a SRS description using the VLRs | /// the SpatialReference will only contain a SRS description using the VLRs | |||
/// that it was first instantiated with. SetWKT and SetProj4 can | /// that it was first instantiated with. SetWKT and SetProj4 can | |||
/// be used to change the GTIF* | /// be used to change the GTIF* | |||
void ResetVLRs(); | void ResetVLRs(); | |||
}; | }; | |||
} // namespace liblas | } // namespace liblas | |||
LAS_DLL std::ostream& operator<<(std::ostream& ostr, const liblas::SpatialR | ||||
eference& srs); | ||||
LAS_C_START | LAS_C_START | |||
#if defined(__geotiff_h_) | #if defined(__geotiff_h_) | |||
#if defined(GEO_NORMALIZE_H_INCLUDED) | #if defined(GEO_NORMALIZE_H_INCLUDED) | |||
char LAS_DLL * GTIFGetOGISDefn(GTIF*, GTIFDefn*); | char LAS_DLL * GTIFGetOGISDefn(GTIF*, GTIFDefn*); | |||
#endif | #endif | |||
int LAS_DLL GTIFSetFromOGISDefn(GTIF*, const char*); | int LAS_DLL GTIFSetFromOGISDefn(GTIF*, const char*); | |||
void SetLinearUnitCitation(GTIF* psGTIF, char* pszLinearUOMName); | void SetLinearUnitCitation(GTIF* psGTIF, char* pszLinearUOMName); | |||
#if defined(_OGR_SRS_API_H_INCLUDED) | #if defined(_OGR_SRS_API_H_INCLUDED) | |||
End of changes. 2 change blocks. | ||||
0 lines changed or deleted | 7 lines changed or added | |||
transform.hpp | transform.hpp | |||
---|---|---|---|---|
skipping to change at line 75 | skipping to change at line 75 | |||
virtual ~TransformI() {} | virtual ~TransformI() {} | |||
}; | }; | |||
typedef boost::shared_ptr<liblas::TransformI> TransformPtr; | typedef boost::shared_ptr<liblas::TransformI> TransformPtr; | |||
class LAS_DLL ReprojectionTransform: public TransformI | class LAS_DLL ReprojectionTransform: public TransformI | |||
{ | { | |||
public: | public: | |||
ReprojectionTransform(const SpatialReference& inSRS, const SpatialRefer ence& outSRS); | ReprojectionTransform(const SpatialReference& inSRS, const SpatialRefer ence& outSRS); | |||
ReprojectionTransform(const SpatialReference& inSRS, const SpatialRefer ence& outSRS, liblas::HeaderPtr new_header); | ReprojectionTransform(const SpatialReference& inSRS, const SpatialRefer ence& outSRS, Header const* new_header); | |||
~ReprojectionTransform(); | ~ReprojectionTransform(); | |||
bool transform(Point& point); | bool transform(Point& point); | |||
void SetHeaderPtr(liblas::HeaderPtr header) {m_new_header = header;} | void SetHeader(Header* header) {m_new_header = header;} | |||
bool ModifiesHeader() { return true; } | bool ModifiesHeader() { return true; } | |||
private: | private: | |||
liblas::HeaderPtr m_new_header; | Header const* m_new_header; | |||
typedef boost::shared_ptr<void> ReferencePtr; | typedef boost::shared_ptr<void> ReferencePtr; | |||
typedef boost::shared_ptr<void> TransformPtr; | typedef boost::shared_ptr<void> TransformPtr; | |||
ReferencePtr m_in_ref_ptr; | ReferencePtr m_in_ref_ptr; | |||
ReferencePtr m_out_ref_ptr; | ReferencePtr m_out_ref_ptr; | |||
TransformPtr m_transform_ptr; | TransformPtr m_transform_ptr; | |||
ReprojectionTransform(ReprojectionTransform const& other); | ReprojectionTransform(ReprojectionTransform const& other); | |||
ReprojectionTransform& operator=(ReprojectionTransform const& rhs); | ReprojectionTransform& operator=(ReprojectionTransform const& rhs); | |||
skipping to change at line 150 | skipping to change at line 150 | |||
class LAS_DLL ColorFetchingTransform: public TransformI | class LAS_DLL ColorFetchingTransform: public TransformI | |||
{ | { | |||
public: | public: | |||
ColorFetchingTransform( std::string const& datasource, | ColorFetchingTransform( std::string const& datasource, | |||
std::vector<boost::uint32_t> bands | std::vector<boost::uint32_t> bands | |||
); | ); | |||
ColorFetchingTransform( std::string const& datasource, | ColorFetchingTransform( std::string const& datasource, | |||
std::vector<boost::uint32_t> bands, | std::vector<boost::uint32_t> bands, | |||
HeaderPtr header); | Header const* header); | |||
void SetScaleFactor(boost::uint32_t v) {m_scale = v; } | void SetScaleFactor(boost::uint32_t v) {m_scale = v; } | |||
~ColorFetchingTransform(); | ~ColorFetchingTransform(); | |||
bool transform(Point& point); | bool transform(Point& point); | |||
bool ModifiesHeader() { return true; } | bool ModifiesHeader() { return true; } | |||
private: | private: | |||
liblas::HeaderPtr m_new_header; | Header const* m_new_header; | |||
typedef boost::shared_ptr<void> DataSourcePtr; | typedef boost::shared_ptr<void> DataSourcePtr; | |||
DataSourcePtr m_ds; | DataSourcePtr m_ds; | |||
std::string m_datasource; | std::string m_datasource; | |||
std::vector<boost::uint32_t> m_bands; | std::vector<boost::uint32_t> m_bands; | |||
boost::array<double, 6> m_forward_transform; | boost::array<double, 6> m_forward_transform; | |||
boost::array<double, 6> m_inverse_transform; | boost::array<double, 6> m_inverse_transform; | |||
boost::uint32_t m_scale; | boost::uint32_t m_scale; | |||
End of changes. 5 change blocks. | ||||
5 lines changed or deleted | 5 lines changed or added | |||
utility.hpp | utility.hpp | |||
---|---|---|---|---|
skipping to change at line 78 | skipping to change at line 78 | |||
Summary(); | Summary(); | |||
Summary(Summary const& other); | Summary(Summary const& other); | |||
Summary& operator=(Summary const& rhs); | Summary& operator=(Summary const& rhs); | |||
bool filter(const Point& point); | bool filter(const Point& point); | |||
void AddPoint(liblas::Point const& p); | void AddPoint(liblas::Point const& p); | |||
ptree GetPTree() const; | ptree GetPTree() const; | |||
void SetHeader(liblas::Header const& h); | void SetHeader(liblas::Header const& h); | |||
~Summary() {}; | ~Summary() {} | |||
private: | private: | |||
classes_type classes; | classes_type classes; | |||
boost::uint32_t synthetic; | boost::uint32_t synthetic; | |||
boost::uint32_t withheld; | boost::uint32_t withheld; | |||
boost::uint32_t keypoint; | boost::uint32_t keypoint; | |||
boost::uint32_t count; | boost::uint32_t count; | |||
boost::array<boost::uint32_t, 8> points_by_return; | boost::array<boost::uint32_t, 8> points_by_return; | |||
boost::array<boost::uint32_t, 8> returns_of_given_pulse; | boost::array<boost::uint32_t, 8> returns_of_given_pulse; | |||
bool first; | bool first; | |||
skipping to change at line 110 | skipping to change at line 110 | |||
CoordinateSummary(); | CoordinateSummary(); | |||
CoordinateSummary(CoordinateSummary const& other); | CoordinateSummary(CoordinateSummary const& other); | |||
CoordinateSummary& operator=(CoordinateSummary const& rhs); | CoordinateSummary& operator=(CoordinateSummary const& rhs); | |||
bool filter(const Point& point); | bool filter(const Point& point); | |||
void AddPoint(liblas::Point const& p); | void AddPoint(liblas::Point const& p); | |||
ptree GetPTree() const; | ptree GetPTree() const; | |||
void SetHeader(liblas::Header const& h); | void SetHeader(liblas::Header const& h); | |||
~CoordinateSummary() {}; | ~CoordinateSummary() {} | |||
private: | private: | |||
boost::uint32_t count; | boost::uint32_t count; | |||
boost::array<boost::uint32_t, 8> points_by_return; | boost::array<boost::uint32_t, 8> points_by_return; | |||
boost::array<boost::uint32_t, 8> returns_of_given_pulse; | boost::array<boost::uint32_t, 8> returns_of_given_pulse; | |||
bool first; | bool first; | |||
liblas::Point minimum; | liblas::Point minimum; | |||
liblas::Point maximum; | liblas::Point maximum; | |||
liblas::Header m_header; | liblas::Header m_header; | |||
End of changes. 2 change blocks. | ||||
2 lines changed or deleted | 2 lines changed or added | |||
variablerecord.hpp | variablerecord.hpp | |||
---|---|---|---|---|
skipping to change at line 129 | skipping to change at line 129 | |||
/// Compare actual header object against the other. | /// Compare actual header object against the other. | |||
/// \exception No throw | /// \exception No throw | |||
bool equal(VariableRecord const& other) const; | bool equal(VariableRecord const& other) const; | |||
/// Get the total size of the VLR in bytes | /// Get the total size of the VLR in bytes | |||
std::size_t GetTotalSize() const; | std::size_t GetTotalSize() const; | |||
liblas::property_tree::ptree GetPTree() const; | liblas::property_tree::ptree GetPTree() const; | |||
enum | ||||
{ | ||||
eUserIdSize = 16, | ||||
eDescriptionSize = 32 | ||||
}; | ||||
private: | private: | |||
std::vector<boost::uint8_t> m_data; | std::vector<boost::uint8_t> m_data; | |||
boost::array<char, 32> m_description; | boost::array<char, 32> m_description; | |||
boost::array<char, 16> m_user_id; | boost::array<char, 16> m_user_id; | |||
boost::uint16_t m_reserved; | boost::uint16_t m_reserved; | |||
boost::uint16_t m_record_id; | boost::uint16_t m_record_id; | |||
boost::uint16_t m_record_size; // length after header | boost::uint16_t m_record_size; // length after header | |||
}; | }; | |||
End of changes. 1 change blocks. | ||||
0 lines changed or deleted | 6 lines changed or added | |||
zippoint.hpp | zippoint.hpp | |||
---|---|---|---|---|
skipping to change at line 51 | skipping to change at line 51 | |||
#ifndef LIBLAS_DETAIL_ZIPPOINT_HPP_INCLUDED | #ifndef LIBLAS_DETAIL_ZIPPOINT_HPP_INCLUDED | |||
#define LIBLAS_DETAIL_ZIPPOINT_HPP_INCLUDED | #define LIBLAS_DETAIL_ZIPPOINT_HPP_INCLUDED | |||
#include <liblas/detail/fwd.hpp> | #include <liblas/detail/fwd.hpp> | |||
#include <liblas/liblas.hpp> | #include <liblas/liblas.hpp> | |||
// boost | // boost | |||
#include <boost/cstdint.hpp> | #include <boost/cstdint.hpp> | |||
#include <boost/shared_ptr.hpp> | #include <boost/shared_ptr.hpp> | |||
#include <boost/scoped_ptr.hpp> | ||||
#include <boost/scoped_array.hpp> | ||||
// liblaszip | // liblaszip | |||
class LASzipper; | class LASzipper; | |||
class LASitem; | class LASzip; | |||
namespace liblas { namespace detail { | namespace liblas { namespace detail { | |||
class ZipPoint | class ZipPoint | |||
{ | { | |||
public: | public: | |||
ZipPoint(PointFormatName); | ZipPoint(PointFormatName, const std::vector<VariableRecord>& vlrs); | |||
~ZipPoint(); | ~ZipPoint(); | |||
void ConstructVLR(VariableRecord&) const; | void ConstructVLR(VariableRecord&) const; | |||
// these will return false iff we find a laszip VLR and it doesn't matc h | // these will return false iff we find a laszip VLR and it doesn't matc h | |||
// the point format this object wasd constructed with | // the point format this object wasd constructed with | |||
bool ValidateVLR(std::vector<VariableRecord> const& vlrs) const; | bool ValidateVLR(std::vector<VariableRecord> const& vlrs) const; | |||
bool ValidateVLR(const VariableRecord& vlr) const; | bool ValidateVLR(const VariableRecord& vlr) const; | |||
bool IsZipVLR(const VariableRecord& vlr) const; | bool IsZipVLR(const VariableRecord& vlr) const; | |||
LASzip* GetZipper() const { return m_zip.get(); } | ||||
private: | private: | |||
void ConstructItems(PointFormatName); | void ConstructItems(); | |||
public: // for now | public: // for now | |||
unsigned int m_num_items; | // LASzip::pack() allocates/sets vlr_data and vlr_num for us, and delet | |||
LASitem* m_items; | es it for us ["his"] | |||
// LASzip::unpack() just reads from the vlr_data we give it (we allocat | ||||
e and delete) ["our"] | ||||
int his_vlr_num; | ||||
unsigned char* his_vlr_data; | ||||
boost::scoped_ptr<LASzip> m_zip; | ||||
unsigned char** m_lz_point; | unsigned char** m_lz_point; | |||
unsigned char* m_lz_point_data; | boost::scoped_array<boost::uint8_t> m_lz_point_data; | |||
unsigned int m_lz_point_size; | unsigned int m_lz_point_size; | |||
}; | }; | |||
}} // namespace liblas::detail | }} // namespace liblas::detail | |||
#endif // LIBLAS_DETAIL_ZIPPOINT_HPP_INCLUDED | #endif // LIBLAS_DETAIL_ZIPPOINT_HPP_INCLUDED | |||
End of changes. 7 change blocks. | ||||
6 lines changed or deleted | 17 lines changed or added | |||
zipreader.hpp | zipreader.hpp | |||
---|---|---|---|---|
skipping to change at line 54 | skipping to change at line 54 | |||
#include <liblas/detail/fwd.hpp> | #include <liblas/detail/fwd.hpp> | |||
#include <liblas/detail/reader/header.hpp> | #include <liblas/detail/reader/header.hpp> | |||
// boost | // boost | |||
#include <boost/cstdint.hpp> | #include <boost/cstdint.hpp> | |||
// std | // std | |||
#include <iosfwd> | #include <iosfwd> | |||
#include <boost/shared_ptr.hpp> | #include <boost/shared_ptr.hpp> | |||
// liblaszip | // liblaszip | |||
class LASitem; | ||||
class LASunzipper; | class LASunzipper; | |||
class LASzip; | ||||
namespace liblas { namespace detail { | namespace liblas { namespace detail { | |||
class ZipPoint; | class ZipPoint; | |||
typedef boost::shared_ptr< reader::Header > HeaderReaderPtr; | typedef boost::shared_ptr< reader::Header > HeaderReaderPtr; | |||
class ZipReaderImpl : public ReaderI | class ZipReaderImpl : public ReaderI | |||
{ | { | |||
public: | public: | |||
ZipReaderImpl(std::istream& ifs); | ZipReaderImpl(std::istream& ifs); | |||
skipping to change at line 110 | skipping to change at line 110 | |||
HeaderReaderPtr m_header_reader; | HeaderReaderPtr m_header_reader; | |||
HeaderPtr m_header; | HeaderPtr m_header; | |||
PointPtr m_point; | PointPtr m_point; | |||
std::vector<liblas::FilterPtr> m_filters; | std::vector<liblas::FilterPtr> m_filters; | |||
std::vector<liblas::TransformPtr> m_transforms; | std::vector<liblas::TransformPtr> m_transforms; | |||
private: | private: | |||
void ReadIdiom(bool recordPoint); | void ReadIdiom(); | |||
void ResetUnzipper(); | ||||
// boost::scoped_ptr<LASzip> m_zip; | ||||
boost::scoped_ptr<ZipPoint> m_zipPoint; | ||||
boost::scoped_ptr<LASunzipper> m_unzipper; | ||||
LASunzipper* m_unzipper; | ||||
ZipPoint* m_zipPoint; | ||||
bool bNeedHeaderCheck; | bool bNeedHeaderCheck; | |||
std::streampos m_zipReadStartPosition; | ||||
// Blocked copying operations, declared but not defined. | // Blocked copying operations, declared but not defined. | |||
ZipReaderImpl(ZipReaderImpl const& other); | ZipReaderImpl(ZipReaderImpl const& other); | |||
ZipReaderImpl& operator=(ZipReaderImpl const& rhs); | ZipReaderImpl& operator=(ZipReaderImpl const& rhs); | |||
}; | }; | |||
}} // namespace liblas::detail | }} // namespace liblas::detail | |||
#endif // LIBLAS_DETAIL_ZIPREADERIMPL_HPP_INCLUDED | #endif // LIBLAS_DETAIL_ZIPREADERIMPL_HPP_INCLUDED | |||
End of changes. 5 change blocks. | ||||
5 lines changed or deleted | 7 lines changed or added | |||
zipwriter.hpp | zipwriter.hpp | |||
---|---|---|---|---|
skipping to change at line 52 | skipping to change at line 52 | |||
#ifndef LIBLAS_DETAIL_ZIPWRITER_HPP_INCLUDED | #ifndef LIBLAS_DETAIL_ZIPWRITER_HPP_INCLUDED | |||
#define LIBLAS_DETAIL_ZIPWRITER_HPP_INCLUDED | #define LIBLAS_DETAIL_ZIPWRITER_HPP_INCLUDED | |||
#include <liblas/detail/fwd.hpp> | #include <liblas/detail/fwd.hpp> | |||
#include <liblas/liblas.hpp> | #include <liblas/liblas.hpp> | |||
#include <liblas/detail/writer/point.hpp> | #include <liblas/detail/writer/point.hpp> | |||
#include <liblas/detail/writer/header.hpp> | #include <liblas/detail/writer/header.hpp> | |||
// boost | // boost | |||
#include <boost/cstdint.hpp> | #include <boost/cstdint.hpp> | |||
#include <boost/shared_ptr.hpp> | #include <boost/shared_ptr.hpp> | |||
#include <boost/scoped_ptr.hpp> | ||||
// liblaszip | // liblaszip | |||
class LASzip; | ||||
class LASzipper; | class LASzipper; | |||
class LASitem; | ||||
namespace liblas { namespace detail { | namespace liblas { namespace detail { | |||
class ZipPoint; | class ZipPoint; | |||
typedef boost::shared_ptr< writer::Point > PointWriterPtr; | typedef boost::shared_ptr< writer::Point > PointWriterPtr; | |||
typedef boost::shared_ptr< writer::Header > HeaderWriterPtr; | typedef boost::shared_ptr< writer::Header > HeaderWriterPtr; | |||
class ZipWriterImpl : public WriterI | class ZipWriterImpl : public WriterI | |||
{ | { | |||
public: | public: | |||
skipping to change at line 99 | skipping to change at line 100 | |||
HeaderWriterPtr m_header_writer; | HeaderWriterPtr m_header_writer; | |||
std::vector<liblas::FilterPtr> m_filters; | std::vector<liblas::FilterPtr> m_filters; | |||
std::vector<liblas::TransformPtr> m_transforms; | std::vector<liblas::TransformPtr> m_transforms; | |||
HeaderPtr m_header; | HeaderPtr m_header; | |||
private: | private: | |||
boost::uint32_t m_pointCount; | boost::uint32_t m_pointCount; | |||
LASzipper* m_zipper; | boost::scoped_ptr<LASzipper> m_zipper; | |||
ZipPoint* m_zipPoint; | boost::scoped_ptr<ZipPoint> m_zipPoint; | |||
// block copying operations | // block copying operations | |||
ZipWriterImpl(ZipWriterImpl const& other); | ZipWriterImpl(ZipWriterImpl const& other); | |||
ZipWriterImpl& operator=(ZipWriterImpl const& other); | ZipWriterImpl& operator=(ZipWriterImpl const& other); | |||
}; | }; | |||
}} // namespace liblas::detail | }} // namespace liblas::detail | |||
#endif // LIBLAS_DETAIL_ZIPWRITER_HPP_INCLUDED | #endif // LIBLAS_DETAIL_ZIPWRITER_HPP_INCLUDED | |||
End of changes. 4 change blocks. | ||||
3 lines changed or deleted | 4 lines changed or added | |||