int clock_getres(clockid_t clock, struct timespec* ts)
{
ENSURE(clock == CLOCK_REALTIME || clock == CLOCK_MONOTONIC);
const double resolution = whrt_Resolution();
const i64 ns = i64(resolution * 1e9);
*ts = TimespecFromNs(ns);
return 0;
}
i64 File::Length(const char *name) {
#ifdef _win_
WIN32_FIND_DATA fData;
HANDLE h = FindFirstFileA(name, &fData);
if (h == INVALID_HANDLE_VALUE)
return -1;
FindClose(h);
return (((i64)fData.nFileSizeHigh) * (i64(MAXDWORD)+1)) + (i64)fData.nFileSizeLow;
#elif defined(_unix_)
struct stat buf;
int r = stat(name, &buf);
if (r == -1)
return -1;
return (i64)buf.st_size;
#endif
}
void Colorization::setScaledValue(PointBuffer& data,
double value,
Dimension const& d,
std::size_t pointIndex) const
{
float flt(0.0);
boost::int8_t i8(0);
boost::uint8_t u8(0);
boost::int16_t i16(0);
boost::uint16_t u16(0);
boost::int32_t i32(0);
boost::uint32_t u32(0);
boost::int64_t i64(0);
boost::uint64_t u64(0);
boost::uint32_t size = d.getByteSize();
switch (d.getInterpretation())
{
case dimension::Float:
if (size == 4)
{
flt = static_cast<float>(value);
data.setField<float>(d, pointIndex, flt);
}
if (size == 8)
{
data.setField<double>(d, pointIndex, value);
}
break;
case dimension::SignedInteger:
case dimension::SignedByte:
if (size == 1)
{
i8 = d.removeScaling<boost::int8_t>(value);
data.setField<boost::int8_t>(d, pointIndex, i8);
}
if (size == 2)
{
i16 = d.removeScaling<boost::int16_t>(value);
data.setField<boost::int16_t>(d, pointIndex, i16);
}
if (size == 4)
{
i32 = d.removeScaling<boost::int32_t>(value);
data.setField<boost::int32_t>(d, pointIndex, i32);
}
if (size == 8)
{
i64 = d.removeScaling<boost::int64_t>(value);
data.setField<boost::int64_t>(d, pointIndex, i64);
}
break;
case dimension::UnsignedInteger:
case dimension::UnsignedByte:
if (size == 1)
{
u8 = d.removeScaling<boost::uint8_t>(value);
data.setField<boost::uint8_t>(d, pointIndex, u8);
}
if (size == 2)
{
u16 = d.removeScaling<boost::uint16_t>(value);
data.setField<boost::uint16_t>(d, pointIndex, u16);
}
if (size == 4)
{
u32 = d.removeScaling<boost::uint32_t>(value);
data.setField<boost::uint32_t>(d, pointIndex, u32);
}
if (size == 8)
{
u64 = d.removeScaling<boost::uint64_t>(value);
data.setField<boost::uint64_t>(d, pointIndex, u64);
}
break;
case dimension::Pointer: // stored as 64 bits, even on a 32-bit box
case dimension::Undefined:
throw pdal_error("Dimension data type unable to be reprojected");
}
}
double Colorization::getScaledValue(PointBuffer& data,
Dimension const& d,
std::size_t pointIndex) const
{
double output(0.0);
float flt(0.0);
boost::int8_t i8(0);
boost::uint8_t u8(0);
boost::int16_t i16(0);
boost::uint16_t u16(0);
boost::int32_t i32(0);
boost::uint32_t u32(0);
boost::int64_t i64(0);
boost::uint64_t u64(0);
boost::uint32_t size = d.getByteSize();
switch (d.getInterpretation())
{
case dimension::Float:
if (size == 4)
{
flt = data.getField<float>(d, pointIndex);
output = static_cast<double>(flt);
}
if (size == 8)
{
output = data.getField<double>(d, pointIndex);
}
break;
case dimension::SignedInteger:
case dimension::SignedByte:
if (size == 1)
{
i8 = data.getField<boost::int8_t>(d, pointIndex);
output = d.applyScaling<boost::int8_t>(i8);
}
if (size == 2)
{
i16 = data.getField<boost::int16_t>(d, pointIndex);
output = d.applyScaling<boost::int16_t>(i16);
}
if (size == 4)
{
i32 = data.getField<boost::int32_t>(d, pointIndex);
output = d.applyScaling<boost::int32_t>(i32);
}
if (size == 8)
{
i64 = data.getField<boost::int64_t>(d, pointIndex);
output = d.applyScaling<boost::int64_t>(i64);
}
break;
case dimension::UnsignedInteger:
case dimension::UnsignedByte:
if (size == 1)
{
u8 = data.getField<boost::uint8_t>(d, pointIndex);
output = d.applyScaling<boost::uint8_t>(u8);
}
if (size == 2)
{
u16 = data.getField<boost::uint16_t>(d, pointIndex);
output = d.applyScaling<boost::uint16_t>(u16);
}
if (size == 4)
{
u32 = data.getField<boost::uint32_t>(d, pointIndex);
output = d.applyScaling<boost::uint32_t>(u32);
}
if (size == 8)
{
u64 = data.getField<boost::uint64_t>(d, pointIndex);
output = d.applyScaling<boost::uint64_t>(u64);
}
break;
case dimension::Pointer: // stored as 64 bits, even on a 32-bit box
case dimension::Undefined:
throw pdal_error("Dimension data type unable to be reprojected");
}
return output;
}
// return nanoseconds since POSIX epoch.
// algorithm: add current HRT value to the startup system time
static i64 CurrentSystemTime_ns()
{
const i64 ns = stInitial_ns + i64(whrt_Time() * _1e9);
return ns;
}
void print_header( std::string const& model, std::string const& name, color::rgb<double> const& r )
{
color_name<uint8_t> i8 ( r );
color_name<uint16_t> i16 ( r );
color_name<uint32_t> i32 ( r );
color_name<uint64_t> i64 ( r );
color_name<float> f ( r );
color_name<double> d ( r );
color_name<long double> ld ( r );
color::rgb<uint8_t> r32( r );
std::stringstream ss;
ss << "#ifndef color_"<< model <<"_make_" << name << std::endl;
ss << "#define color_"<< model <<"_make_" << name << std::endl;
ss << std::endl;
ss << "// ::color::make::" << name << "( c )" << std::endl;
ss << std::endl;
ss << " namespace color" << std::endl;
ss << " {" << std::endl;
ss << " namespace make" << std::endl;
ss << " { //RGB equivalents: ";
ss << "std::array<double,3>( { "<< d[0]<<", "<< d[1]<<", "<< d[2]<<" } )";
ss << " - ";
ss << "rgb(" << std::setbase(10) <<(unsigned)r32[0] << "," << (unsigned)r32[1] << "," << (unsigned)r32[2] << ")" ;
ss << " - ";
ss << "#" << std::setbase(16) << std::setw(2) << std::setfill('0') << (unsigned)r32[0]
<< std::setbase(16) << std::setw(2) << std::setfill('0') << (unsigned)r32[1]
<< std::setbase(16) << std::setw(2) << std::setfill('0') << (unsigned)r32[2] ;
ss << std::endl;
ss << std::endl;
ss << " inline" << std::endl;
ss << " void " << name << "( ::color::_internal::model< ::color::category::"<< model <<"_uint8 > & color_parameter )" << std::endl;
ss << " {" << std::endl;
ss << " color_parameter.container() = std::array< std::uint8_t, " << i8.size() << " >( { "
<< "0x" << std::setbase(16) << std::setw(2) << std::setfill('0') << (unsigned)i8[0] << ", "
<< "0x" << std::setbase(16) << std::setw(2) << std::setfill('0') << (unsigned)i8[1] << ", "
<< "0x" << std::setbase(16) << std::setw(2) << std::setfill('0') << (unsigned)i8[2];
if( 4 == i8.size() ){ ss << ", 0x" << std::setbase(16) << std::setw(2) << std::setfill('0') << (unsigned)i8[3]; }
ss << " } );" << std::endl;
ss << " }" << std::endl;
ss << std::endl;
ss << " inline" << std::endl;
ss << " void " << name << "( ::color::_internal::model< ::color::category::"<< model <<"_uint16 > & color_parameter )" << std::endl;
ss << " {" << std::endl;
ss << " color_parameter.container() = std::array< std::uint16_t, " << i16.size() << " >( { "
<< "0x" << std::setbase(16) << std::setw(4) << std::setfill('0') << i16[0] << ", "
<< "0x" << std::setbase(16) << std::setw(4) << std::setfill('0') << i16[1] << ", "
<< "0x" << std::setbase(16) << std::setw(4) << std::setfill('0') << i16[2];
if( 4 == i16.size() ){ ss << ", 0x" << std::setbase(16) << std::setw(4) << std::setfill('0') << i16[3]; }
ss << " } );" << std::endl;
ss << " }" << std::endl;
ss << std::endl;
ss << " inline" << std::endl;
ss << " void " << name << "( ::color::_internal::model< ::color::category::"<< model <<"_uint32 > & color_parameter )" << std::endl;
ss << " {" << std::endl;
ss << " color_parameter.container() = std::array< std::uint32_t, " << f.size() << " >( { "
<< "0x" << std::setbase(16) << std::setw(8) << std::setfill('0') << i32[0] << ", "
<< "0x" << std::setbase(16) << std::setw(8) << std::setfill('0') << i32[1] << ", "
<< "0x" << std::setbase(16) << std::setw(8) << std::setfill('0') << i32[2];
if( 4 == i32.size() ){ ss << ", 0x" << std::setbase(16) << std::setw(8) << std::setfill('0') << i32[3]; }
ss << " } );" << std::endl;
ss << " }" << std::endl;
ss << std::endl;
ss << " inline" << std::endl;
ss << " void " << name << "( ::color::_internal::model< ::color::category::"<< model <<"_uint64 > & color_parameter )" << std::endl;
ss << " {" << std::endl;
ss << " color_parameter.container() = std::array< std::uint64_t, " << i64.size() << " >( { "
<< "0x" << std::setbase(16) << std::setw(16) << std::setfill('0') << i64[0] << "ull, "
<< "0x" << std::setbase(16) << std::setw(16) << std::setfill('0') << i64[1] << "ull, "
<< "0x" << std::setbase(16) << std::setw(16) << std::setfill('0') << i64[2] << "ull" ;
if( 4 == i64.size() ){ ss << ", 0x" << std::setbase(16) << std::setw(16) << std::setfill('0') << i64[3] << "ull"; }
ss << " } );" << std::endl;
ss << " }" << std::endl;
ss << std::endl;
ss << " inline" << std::endl;
ss << " void " << name << "( ::color::_internal::model< ::color::category::"<< model <<"_float > & color_parameter )" << std::endl;
ss << " {" << std::endl;
ss << " color_parameter.container() = std::array<float," << f.size() << ">( { " << f[0] << ", " << f[1] << ", " << f[2];
if( 4 == f.size() ){ ss << ", " << f[3]; }
ss << " } );" << std::endl;
ss << " }" << std::endl;
ss << std::endl;
ss << " inline" << std::endl;
ss << " void " << name << "( ::color::_internal::model< ::color::category::"<< model <<"_double> & color_parameter )" << std::endl;
ss << " {" << std::endl;
ss << " color_parameter.container() = std::array<double," << d.size() << ">( { " << d[0] << ", " << d[1] << ", " << d[2];
if( 4 == d.size() ){ ss << ", " << d[3]; }
ss << " } );" << std::endl;
ss << " }" << std::endl;
ss << std::endl;
ss << " inline" << std::endl;
ss << " void " << name << "( ::color::_internal::model< ::color::category::"<< model <<"_ldouble> & color_parameter )" << std::endl;
ss << " {" << std::endl;
ss << " color_parameter.container() = std::array<long double," << ld.size() << ">( { " << ld[0] << ", " << ld[1] << ", " << ld[2];
if( 4 == ld.size() ){ ss << ", " << ld[3];}
ss << " } );" << std::endl;
ss << " }" << std::endl;
ss << std::endl;
ss << " }" << std::endl;
ss << " }" << std::endl;
ss << std::endl;
ss << "#endif" << std::endl;
//std::cout << ss.str();
//std::cout << "-------" << std:: endl;
{
std::ofstream ofs( ( "./gen-"+ model +"/"+name + ".hpp" ). c_str() );
//std::ofstream ofs( ( "../../../src/color/"+ model +"/make/"+name + ".hpp" ). c_str() );
ofs << ss.str();
}
}
/// not threadsafe
i64 DataFile::readScans(std::vector<int16> & scans_out, u64 pos, u64 num2read, const QBitArray & channelSubset, unsigned downSampleFactor)
{
if (pos > scanCt) return -1;
if (num2read + pos > scanCt) num2read = scanCt - pos;
QBitArray chset = channelSubset;
if (chset.size() != (i64)nChans) chset.fill(true, nChans);
if (downSampleFactor <= 0) downSampleFactor = 1;
unsigned nChansOn = chset.count(true);
int sizeofscans;
if ( (num2read / downSampleFactor) * downSampleFactor < num2read )
sizeofscans = ((num2read / downSampleFactor)+1) * nChansOn;
else
sizeofscans = ((num2read / downSampleFactor)) * nChansOn;
scans_out.resize(sizeofscans);
u64 cur = pos;
i64 nout = 0;
std::vector<int> onChans;
onChans.reserve(chset.size());
for (int i = 0, n = chset.size(); i < n; ++i)
if (chset.testBit(i)) onChans.push_back(i);
qint64 maxBufSize = nChans*sRate*1; // read about max 1sec worth of data at a time as an optimization
qint64 desiredBufSize = num2read*nChans; // but first try and do the entire requested read at once in our buffer if it fits within our limits..
if (desiredBufSize > maxBufSize) desiredBufSize = maxBufSize;
std::vector<int16> buf(desiredBufSize);
if (int(buf.size()) < nChans) buf.resize(nChans); // minimum read is 1 scan
while (cur < pos + num2read) {
if (!dataFile.seek(cur * sizeof(int16) * nChans)) {
Error() << "Error seeking in dataFile::readScans()!";
scans_out.clear();
return -1;
}
qint64 nr = dataFile.read(reinterpret_cast<char *>(&buf[0]), sizeof(int16) * buf.size());
if (nr < int(sizeof(int16) * nChans)) {
Error() << "Short read in dataFile::readScans()!";
scans_out.clear();
return -1;
}
int nscans = int(nr/sizeof(int16))/nChans;
if (nscans <= 0) {
Error() << "Short read in dataFile::readScans()... nscans <= 0!";
scans_out.clear();
return -1;
}
const int16 *bufptr = &buf[0];
const int onChansSize = int(onChans.size());
const int skip = nChans*downSampleFactor;
for (int sc = 0; sc < nscans && cur < pos + num2read; /* .. */) {
if (int(nChansOn) == nChans) {
i64 i_out = nout * nChans;
for (int i = 0; i < nChans; ++i)
scans_out[i_out + i] = int16(bufptr[i]);
} else {
// not all chans on, put subset 1 by 1 in the output vector
i64 i_out = nout*i64(nChansOn);
for (int i = 0; i < onChansSize; ++i)
scans_out[i_out++] = int16(bufptr[onChans[i]]);
}
++nout;
bufptr += skip;
sc += downSampleFactor;
cur += downSampleFactor;
}
}
return nout;
}
