void object::test<7>()
{
GeomPtr geom;
try
{
// use FLOATING model
namespace ggm = geos::geom;
namespace gio = geos::io;
ggm::PrecisionModel pm(ggm::PrecisionModel::FLOATING);
ggm::GeometryFactory gf(&pm);
gio::WKTReader wktReader(&gf);
const std::string str = " POINT (0 0) ";
geom.reset(wktReader.read(str)); //HERE IT FAILS
geos::geom::CoordinateSequence *coords = geom->getCoordinates();
ensure_equals(coords->getDimension(), 2U);
ensure_distance(coords->getX(0), 0.0, 1e-12);
ensure_distance( coords->getY(0), 0.0, 1e-12);
delete coords;
}
catch (const geos::util::IllegalArgumentException& ex)
{
ensure( "Did get expected exception" );
ex.what();
}
catch (...)
{
ensure( !"Got unexpected exception" );
}
}
void to::test<14>()
{
ensure_distance("invalid default time",
m_default.GetTime(), 0.0, 0.01);
double const time = 3.14; // dummy value
m_default.SetTime(time);
ensure_distance("invalid time",
m_default.GetTime(), time, 0.01);
}
void to::test<8>()
{
lasreader_iterator it(reader_);
// test 1st point data record
ensure_distance(it->GetX(), double(630262.30), 0.0001);
ensure_distance(it->GetY(), double(4834500), 0.0001);
ensure_distance(it->GetZ(), double(51.53), 0.0001);
ensure_equals(it->GetIntensity(), 670);
ensure_equals(it->GetClassification(), liblas::uint8_t(1));
ensure_equals(it->GetScanAngleRank(), 0);
ensure_equals(it->GetUserData(), 3);
ensure_equals(it->GetScanFlags(), 9);
ensure_distance(it->GetTime(), double(413665.23360000004), 0.0001);
}
void object::test<1>()
{
geom1_ = GEOSGeomFromWKT("POINT(10 10)");
geom2_ = GEOSGeomFromWKT("POINT(3 6)");
double dist;
int ret = GEOSDistance(geom1_, geom2_, &dist);
ensure_equals(ret, 1);
ensure_distance(dist, 8.06225774829855, 1e-12);
}
void frametimer_object_t::test<2>()
{
F64 seconds_since_epoch = LLFrameTimer::getTotalSeconds();
seconds_since_epoch += 10.0;
LLFrameTimer timer;
timer.setExpiryAt(seconds_since_epoch);
F64 expires_at = timer.expiresAt();
ensure_distance(
"set expiry matches get expiry 1",
expires_at,
seconds_since_epoch,
0.001);
seconds_since_epoch += 10.0;
timer.setExpiryAt(seconds_since_epoch);
expires_at = timer.expiresAt();
ensure_distance(
"set expiry matches get expiry 2",
expires_at,
seconds_since_epoch,
0.001);
}
void object::test<4>()
{
// Index of test file being tested
const std::size_t fileIdx = 1;
std::string file(data_ + SEP);
file += grids_.at(fileIdx).file_;
GDALDatasetH ds = GDALOpen(file.c_str(), GA_ReadOnly);
ensure("Can't open dataset: " + file, nullptr != ds);
double geoTransform[6] = { 0 };
CPLErr err = GDALGetGeoTransform(ds, geoTransform);
ensure_equals("Can't fetch affine transformation coefficients", err, CE_None);
// Test affine transformation coefficients
const double maxError = 0.000001;
const double expect[6] = { 100000.0, 50, 0, 650600.0, 0, -50 };
const std::string msg("Geotransform is incorrect");
ensure_distance(msg.c_str(), expect[0], geoTransform[0], maxError);
ensure_distance(msg.c_str(), expect[1], geoTransform[1], maxError);
ensure_distance(msg.c_str(), expect[2], geoTransform[2], maxError);
ensure_distance(msg.c_str(), expect[3], geoTransform[3], maxError);
ensure_distance(msg.c_str(), expect[4], geoTransform[4], maxError);
ensure_distance(msg.c_str(), expect[5], geoTransform[5], maxError);
GDALClose(ds);
}
void to::test<5>()
{
std::ifstream ifs;
ifs.open(utm15_filename.c_str(), std::ios::in | std::ios::binary);
liblas::Reader reader(ifs);
liblas::Header const& header = reader.GetHeader();
liblas::SpatialReference const& in_ref = header.GetSRS();
const char* utm15_wkt = "PROJCS[\"NAD83 / UTM zone 15N\",GEOGCS[\"NAD83\",DATUM[\"North_American_Datum_1983\",SPHEROID[\"GRS 1980\",6378137,298.2572221010002,AUTHORITY[\"EPSG\",\"7019\"]],AUTHORITY[\"EPSG\",\"6269\"]],PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.0174532925199433],AUTHORITY[\"EPSG\",\"4269\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",-93],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AUTHORITY[\"EPSG\",\"26915\"]]";
ensure_equals("Input WKT comparison", in_ref.GetWKT(), utm15_wkt);
const char* epsg4326_wkt = "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.0174532925199433],AUTHORITY[\"EPSG\",\"4326\"]]";
liblas::SpatialReference out_ref;
out_ref.SetWKT(epsg4326_wkt);
liblas::SpatialReference test_ref;
test_ref.SetWKT(out_ref.GetWKT());
ensure_equals("Output WKT comparison", out_ref, test_ref);
liblas::Header out_hdr(header);
out_hdr.SetScale(0.00000001, 0.00000001, 0.01);
out_hdr.SetOffset(0,0,0);
liblas::TransformPtr srs_transform = liblas::TransformPtr(new liblas::ReprojectionTransform(in_ref, out_ref, &out_hdr));
std::vector<liblas::TransformPtr> transforms;
transforms.push_back(srs_transform);
reader.ReadPointAt(0);
liblas::Point unprojected_point = reader.GetPoint();
ensure_distance("unprojected_point.GetX()",
unprojected_point.GetX(),
double(470692.44),
0.01);
ensure_distance("unprojected_point.GetY()",
unprojected_point.GetY(),
double(4602888.90),
0.01);
reader.SetTransforms(transforms);
// This should throw an out of range exception because the given scale/offset
// combination is not sufficient to store the data.
try
{
reader.ReadPointAt(0);
ensure("std::domain_error was not thrown", false);
}
catch (std::domain_error const& e)
{
ensure(e.what(), true);
}
liblas::Header out_hdr2(header);
out_hdr2.SetScale(0.0000001, 0.0000001, 0.01);
out_hdr2.SetOffset(0,0,0);
srs_transform = liblas::TransformPtr(new liblas::ReprojectionTransform(in_ref, out_ref, &out_hdr2));
transforms.clear();
transforms.push_back(srs_transform);
reader.SetTransforms(transforms);
reader.Reset();
reader.ReadPointAt(0);
liblas::Point const& projected_point = reader.GetPoint();
ensure_distance("projected_point.GetX()",
projected_point.GetX(),
double(-93.35156259),
0.0000001);
ensure_distance("projected_point.GetY()",
projected_point.GetY(),
double(41.57714839),
0.000001);
}
