TEST(NitfReaderTest, optionSrs) { StageFactory f; Options nitfOpts; nitfOpts.add("filename", Support::datapath("nitf/autzen-utm10.ntf")); std::string sr = "PROJCS[\"NAD83 / UTM zone 11N\",GEOGCS[\"NAD83\",DATUM[\"North_American_Datum_1983\",SPHEROID[\"GRS 1980\",6378137,298.257222101,AUTHORITY[\"EPSG\",\"7019\"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY[\"EPSG\",\"6269\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4269\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",-123],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"26910\"]]"; nitfOpts.add("spatialreference", sr); PointContext ctx; ReaderPtr nitfReader(f.createReader("readers.nitf")); EXPECT_TRUE(nitfReader.get()); nitfReader->setOptions(nitfOpts); Options lasOpts; lasOpts.add("filename", "/dev/null"); WriterPtr lasWriter(f.createWriter("writers.las")); EXPECT_TRUE(lasWriter.get()); lasWriter->setInput(nitfReader.get()); lasWriter->setOptions(lasOpts);; lasWriter->prepare(ctx); PointBufferSet pbSet = lasWriter->execute(ctx); EXPECT_EQ(sr, nitfReader->getSpatialReference().getWKT()); EXPECT_EQ("", lasWriter->getSpatialReference().getWKT()); EXPECT_EQ(sr, ctx.spatialRef().getWKT()); }
TEST(IcebridgeReaderTest, testRead) { StageFactory f; ReaderPtr reader(f.createReader("readers.icebridge")); EXPECT_TRUE(reader.get()); Option filename("filename", getFilePath(), ""); Options options(filename); reader->setOptions(options); PointContext ctx; reader->prepare(ctx); PointBufferSet pbSet = reader->execute(ctx); EXPECT_EQ(pbSet.size(), 1u); PointBufferPtr buf = *pbSet.begin(); EXPECT_EQ(buf->size(), 2u); checkPoint( *buf, 0, 141437548, // time 82.605319, // latitude 301.406196, // longitude 18.678, // elevation 2408, // xmtSig 181, // rcvSig 49.91, // azimuth -4.376, // pitch 0.608, // roll 2.9, // gpsPdop 20.0, // pulseWidth 0.0); // relTime checkPoint( *buf, 1, 141437548, // time 82.605287, // latitude 301.404862, // longitude 18.688, // elevation 2642, // xmtSig 173, // rcvSig 52.006, // azimuth -4.376, // pitch 0.609, // roll 2.9, // gpsPdop 17.0, // pulseWidth 0.0); // relTime }
Stage* Random::makeReader(Options readerOptions) { if (isDebug()) { readerOptions.add<bool>("debug", true); boost::uint32_t verbosity(getVerboseLevel()); if (!verbosity) verbosity = 1; readerOptions.add<boost::uint32_t>("verbose", verbosity); readerOptions.add<std::string>("log", "STDERR"); } StageFactory factory; Stage* reader_stage = factory.createReader("readers.faux"); reader_stage->setOptions(readerOptions); return reader_stage; }
TEST(NitfReaderTest, test_one) { StageFactory f; Options nitf_opts; nitf_opts.add("filename", Support::datapath("nitf/autzen-utm10.ntf")); nitf_opts.add("count", 750); PointContext ctx; ReaderPtr nitf_reader(f.createReader("readers.nitf")); EXPECT_TRUE(nitf_reader.get()); nitf_reader->setOptions(nitf_opts); nitf_reader->prepare(ctx); PointBufferSet pbSet = nitf_reader->execute(ctx); EXPECT_EQ(nitf_reader->getDescription(), "NITF Reader"); EXPECT_EQ(pbSet.size(), 1u); PointBufferPtr buf = *pbSet.begin(); // check metadata //ABELL /** { Metadata metadata = nitf_reader.getMetadata(); /////////////////////////////////////////////////EXPECT_EQ(metadatums.size(), 80u); EXPECT_EQ(metadata.toPTree().get<std::string>("metadata.FH_FDT.value"), "20120323002946"); } **/ // // read LAS // Options las_opts; las_opts.add("count", 750); las_opts.add("filename", Support::datapath("nitf/autzen-utm10.las")); PointContext ctx2; ReaderPtr las_reader(f.createReader("readers.las")); EXPECT_TRUE(las_reader.get()); las_reader->setOptions(las_opts); las_reader->prepare(ctx2); PointBufferSet pbSet2 = las_reader->execute(ctx2); EXPECT_EQ(pbSet2.size(), 1u); PointBufferPtr buf2 = *pbSet.begin(); // // // compare the two buffers // EXPECT_EQ(buf->size(), buf2->size()); for (PointId i = 0; i < buf2->size(); i++) { int32_t nitf_x = buf->getFieldAs<int32_t>(Dimension::Id::X, i); int32_t nitf_y = buf->getFieldAs<int32_t>(Dimension::Id::Y, i); int32_t nitf_z = buf->getFieldAs<int32_t>(Dimension::Id::Z, i); int32_t las_x = buf2->getFieldAs<int32_t>(Dimension::Id::X, i); int32_t las_y = buf2->getFieldAs<int32_t>(Dimension::Id::Y, i); int32_t las_z = buf2->getFieldAs<int32_t>(Dimension::Id::Z, i); EXPECT_EQ(nitf_x, las_x); EXPECT_EQ(nitf_y, las_y); EXPECT_EQ(nitf_z, las_z); } }
int HeightAboveGroundKernel::execute() { // we require separate contexts for the input and ground files PointContextRef input_ctx; PointContextRef ground_ctx; // because we are appending HeightAboveGround to the input buffer, we must // register it's Dimension input_ctx.registerDim(Dimension::Id::HeightAboveGround); // StageFactory will be used to create required stages StageFactory f; // setup the reader, inferring driver type from the filename std::string reader_driver = f.inferReaderDriver(m_input_file); std::unique_ptr<Reader> input(f.createReader(reader_driver)); Options readerOptions; readerOptions.add("filename", m_input_file); input->setOptions(readerOptions); // go ahead and execute to get the PointBuffer input->prepare(input_ctx); PointBufferSet pbSetInput = input->execute(input_ctx); PointBufferPtr input_buf = *pbSetInput.begin(); PointBufferSet pbSetGround; PointBufferPtr ground_buf; if (m_use_classification) { // the user has indicated that the classification dimension exists, so // we will find all ground returns Option source("source", "import numpy as np\n" "def yow1(ins,outs):\n" " cls = ins['Classification']\n" " keep_classes = [2]\n" " keep = np.equal(cls, keep_classes[0])\n" " outs['Mask'] = keep\n" " return True\n" ); Option module("module", "MyModule"); Option function("function", "yow1"); Options opts; opts.add(source); opts.add(module); opts.add(function); // and create a PointBuffer of only ground returns std::unique_ptr<Filter> pred(f.createFilter("filters.predicate")); pred->setOptions(opts); pred->setInput(input.get()); pred->prepare(ground_ctx); pbSetGround = pred->execute(ground_ctx); ground_buf = *pbSetGround.begin(); } else { // the user has provided a file containing only ground returns, setup // the reader, inferring driver type from the filename std::string ground_driver = f.inferReaderDriver(m_ground_file); std::unique_ptr<Reader> ground(f.createReader(ground_driver)); Options ro; ro.add("filename", m_ground_file); ground->setOptions(ro); // go ahead and execute to get the PointBuffer ground->prepare(ground_ctx); pbSetGround = ground->execute(ground_ctx); ground_buf = *pbSetGround.begin(); } typedef pcl::PointXYZ PointT; typedef pcl::PointCloud<PointT> Cloud; typedef Cloud::Ptr CloudPtr; // convert the input PointBuffer to a PointCloud CloudPtr cloud(new Cloud); BOX3D const& bounds = input_buf->calculateBounds(); pclsupport::PDALtoPCD(*input_buf, *cloud, bounds); // convert the ground PointBuffer to a PointCloud CloudPtr cloud_g(new Cloud); // here, we offset the ground cloud by the input bounds so that the two are aligned pclsupport::PDALtoPCD(*ground_buf, *cloud_g, bounds); // create a set of planar coefficients with X=Y=0,Z=1 pcl::ModelCoefficients::Ptr coefficients(new pcl::ModelCoefficients()); coefficients->values.resize(4); coefficients->values[0] = coefficients->values[1] = 0; coefficients->values[2] = 1.0; coefficients->values[3] = 0; // create the filtering object and project ground returns into xy plane pcl::ProjectInliers<PointT> proj; proj.setModelType(pcl::SACMODEL_PLANE); proj.setInputCloud(cloud_g); proj.setModelCoefficients(coefficients); CloudPtr cloud_projected(new Cloud); proj.filter(*cloud_projected); // setup the KdTree pcl::KdTreeFLANN<PointT> tree; tree.setInputCloud(cloud_projected); // loop over all points in the input cloud, finding the nearest neighbor in // the ground returns (XY plane only), and calculating the difference in z int32_t k = 1; for (size_t idx = 0; idx < cloud->points.size(); ++idx) { // Search for nearesrt neighbor of the query point std::vector<int32_t> neighbors(k); std::vector<float> distances(k); PointT temp_pt = cloud->points[idx]; temp_pt.z = 0.0f; int num_neighbors = tree.nearestKSearch(temp_pt, k, neighbors, distances); double hag = cloud->points[idx].z - cloud_g->points[neighbors[0]].z; input_buf->setField(Dimension::Id::HeightAboveGround, idx, hag); } // populate BufferReader with the input PointBuffer, which now has the // HeightAboveGround dimension BufferReader bufferReader; bufferReader.addBuffer(input_buf); // we require that the output be BPF for now, to house our non-standard // dimension Options wo; wo.add("filename", m_output_file); std::unique_ptr<Writer> writer(f.createWriter("writers.bpf")); writer->setOptions(wo); writer->setInput(&bufferReader); writer->prepare(input_ctx); writer->execute(input_ctx); return 0; }