C++ Stage::getSchema方法代码示例

void PcInfo::dumpOnePoint(const Stage& stage) const
{
    const Schema& schema = stage.getSchema();

    PointBuffer data(schema, 1);
    
    boost::scoped_ptr<StageSequentialIterator> iter(stage.createSequentialIterator(data));
    iter->skip(m_pointNumber);

    const boost::uint32_t numRead = iter->read(data);
    if (numRead != 1)
    {
        std::ostringstream oss;
        oss << "problem reading point number " << m_pointNumber;
        throw app_runtime_error(oss.str());
    }

    boost::property_tree::ptree tree = data.toPTree();
   
    std::ostream& ostr = m_outputStream ? *m_outputStream : std::cout;

    boost::property_tree::ptree output;
    output.add_child("point", tree.get_child("0"));
    if (m_useXML)
        write_xml(ostr, output);
    else
        write_json(ostr, tree.get_child("0"));
        
    return;
}

void PcInfo::dumpSDO_PCMetadata(const Stage& stage) const
{
    boost::property_tree::ptree metadata = stage.serializePipeline();

    const Schema& schema = stage.getSchema();
    
    std::string xml = pdal::Schema::to_xml(schema, &metadata);  
    
    std::ostream& ostr = m_outputStream ? *m_outputStream : std::cout;
    
    ostr << xml;
    
}

void PcInfo::dumpSchema(const Stage& stage) const
{
    const Schema& schema = stage.getSchema();

    boost::property_tree::ptree tree = schema.toPTree();
    
    std::ostream& ostr = m_outputStream ? *m_outputStream : std::cout;

    if (m_useXML)
        write_xml(ostr, tree);
    else
        write_json(ostr, tree);
    
    return;
}

int PcInfo::execute()
{


    Options readerOptions;
    {
        if (m_usestdin)
            m_inputFile = "STDIN";
        readerOptions.add<std::string>("filename", m_inputFile);
        readerOptions.add<bool>("debug", isDebug());
        readerOptions.add<boost::uint32_t>("verbose", getVerboseLevel());
    }

    Stage* reader = AppSupport::makeReader(readerOptions);

    if (m_seed != 0)
    {
        Option seed_option("seed", m_seed, "seed value");
        m_options.add(seed_option);
    }
    
    Option sample_size("sample_size", m_sample_size, "sample size for random sample");
    m_options.add(sample_size);
    
    Option cls("exact_count", "Classification", "use exact counts for classification stats");
    Option rn("exact_count", "ReturnNumber", "use exact counts for ReturnNumber stats");
    Option nr("exact_count", "NumberOfReturns", "use exact counts for ReturnNumber stats");
    m_options.add(cls);
    m_options.add(rn);
    m_options.add(nr);
    if (m_Dimensions.size())
    {
        Option dimensions("dimensions", m_Dimensions, "Use explicit list of dimensions");
        m_options.add(dimensions);
        Option do_sample("do_sample", false, "Dont do sampling");
        m_options.add(do_sample);
    }
    
    pdal::Options options = m_options + readerOptions;
    
    pdal::filters::Stats* filter = new pdal::filters::Stats(*reader, options);
    

    filter->initialize();

    if (m_pointNumber != (std::numeric_limits<boost::uint64_t>::max)())
    {
        dumpOnePoint(*filter);
    }

    if (m_showStats)
    {
        dumpStats(*filter);
    }

    if (m_showSchema)
    {
        dumpSchema(*reader);
    }
    
    if (m_showMetadata)
    {
        dumpMetadata(*reader);
    }
    if (m_showStage)
    {
        dumpStage(*reader);
    }
    
    if (m_showSDOPCMetadata)
    {
        dumpSDO_PCMetadata(*reader);
    }
    
    if (m_QueryPoint.size())
    {
        IndexedPointBuffer buffer(reader->getSchema(), reader->getNumPoints());
        dumpQuery(*reader, buffer);
    }
    
    std::ostream& ostr = m_outputStream ? *m_outputStream : std::cout;
    ostr << std::endl;
    
    delete filter;
    delete reader;

    if (m_outputStream)
    {
        FileUtils::closeFile(m_outputStream);
    }
    
    return 0;
}

int Delta::execute()
{

    Options sourceOptions;
    {
        sourceOptions.add<std::string>("filename", m_sourceFile);
        sourceOptions.add<bool>("debug", isDebug());
        sourceOptions.add<boost::uint32_t>("verbose", getVerboseLevel());
    }
    Stage* source = AppSupport::makeReader(sourceOptions);
    source->initialize();
    
    boost::uint32_t totalPointCount(source->getNumPoints());
    
    PointBuffer source_data(source->getSchema(), totalPointCount);
    StageSequentialIterator* source_iter = source->createSequentialIterator(source_data);

    boost::uint32_t  numRead = source_iter->read(source_data);
    assert(numRead == source_data.getNumPoints());

    delete source_iter;
    delete source;



    Options candidateOptions;
    {
        candidateOptions.add<std::string>("filename", m_candidateFile);
        candidateOptions.add<bool>("debug", isDebug());
        candidateOptions.add<boost::uint32_t>("verbose", getVerboseLevel());
    }

    Stage* candidate = AppSupport::makeReader(candidateOptions);

    candidate->initialize();    


    IndexedPointBuffer candidate_data(candidate->getSchema(), totalPointCount);
    StageSequentialIterator* candidate_iter = candidate->createSequentialIterator(candidate_data);

    numRead = candidate_iter->read(candidate_data);
    assert(numRead == candidate_data.getNumPoints());
        
    delete candidate_iter;    


    if (source_data.getNumPoints() != candidate_data.getNumPoints())
    {
        std::cerr << "Source and candidate files do not have the same point count, testing each source point only!" << std::endl;
    }
    

    // m_summary_x(xd);
    // m_summary_y(yd);
    // m_summary_z(zd);

    if (m_outputFileName.size())
    {
        m_outputStream = FileUtils::createFile(m_outputFileName);
    }

    candidate_data.build(m_3d);
    boost::uint32_t count(std::min(source_data.getNumPoints(), candidate_data.getNumPoints()));
    


    boost::scoped_ptr<std::map<Point, Point> > points(cumulatePoints(source_data, candidate_data));
    if (m_OutputDetail)
    {
        outputDetail(source_data, candidate_data, points.get());
        return 0;
    }
    
    std::map<Point, Point>::const_iterator i;
    for(i = points->begin(); i != points->end(); ++i)
    {
        Point const& s = i->first;
        Point const& c = i->second;

        double xd = s.x - c.x;
        double yd = s.y - c.y;
        double zd = s.z - c.z;        
        m_summary_x(xd);
        m_summary_y(yd);
        m_summary_z(zd);        
    }
    
    std::string headline("------------------------------------------------------------------------------------------");
    std::cout << headline << std::endl;
    std::cout << " Delta summary for source '" << m_sourceFile << "' and candidate '" << m_candidateFile <<"'" << std::endl;
    std::cout << headline << std::endl;
    std::cout << std::endl;
    
    std::string thead("----------- --------------- --------------- --------------");
    std::cout << thead << std::endl;
    std::cout << " Dimension       X             Y                  Z    " << std::endl;
    std::cout << thead << std::endl;
    
    boost::format fmt("%.4f");
    double sminx  = (boost::accumulators::min)(m_summary_x);
//.........这里部分代码省略.........

int PcQuery::execute()
{


    Options readerOptions;
    {
        readerOptions.add<std::string>("filename", m_inputFile);
        readerOptions.add<bool>("debug", isDebug());
        readerOptions.add<boost::uint32_t>("verbose", getVerboseLevel());
    }

    Stage* reader = AppSupport::makeReader(readerOptions);

    

    pdal::Options options = m_options + readerOptions;
    options.add<boost::uint32_t>("dimensions", 2);
    
    pdal::filters::Index* filter = new pdal::filters::Index(*reader, options);

    filter->initialize();

    boost::uint32_t chunkSize(pdal::Writer::s_defaultChunkSize);
    if (filter->getNumPoints() > 0 && m_chunkSize == 0)
    {
        chunkSize = filter->getNumPoints();
    } 
    else if (m_chunkSize > 0)
    {
        chunkSize = m_chunkSize;
    }    
    PointBuffer data(filter->getSchema(), chunkSize);
    StageSequentialIterator* iter = filter->createSequentialIterator(data);

    readPoints(iter, data);

    pdal::filters::iterators::sequential::Index* idx = dynamic_cast<pdal::filters::iterators::sequential::Index*>(iter);
    if (!idx)
    {
        throw app_runtime_error("unable to cast iterator to Index iterator!");
    }
    
    idx->build();
    
    if (m_point.size())
    {
        boost::char_separator<char> sep(SEPARATORS);
        tokenizer tokens(m_point, sep);
        std::vector<double> values;
        for (tokenizer::iterator t = tokens.begin(); t != tokens.end(); ++t) {
            values.push_back(boost::lexical_cast<double>(*t));
        }
        
        if (values.size() < 2)
            throw app_runtime_error("--points must be two or three values");
        double x = values[0];
        double y = values[1];
        
        double z(0.0);
        if (values.size() > 2)
            z = values[2];
        std::vector<boost::uint32_t> ids = idx->query(x, y, z, 0.0, 1);
        
        if (ids.size())
        {
            PointBuffer data(reader->getSchema(), 1);
            StageRandomIterator* iterator = reader->createRandomIterator(data);
            iterator->seek(ids[0]);

            Schema const& schema = data.getSchema();
            Dimension const& dimX = schema.getDimension("X");
            Dimension const& dimY = schema.getDimension("Y");
            Dimension const& dimZ = schema.getDimension("Z");
            iterator->read(data);
            boost::int32_t xi = data.getField<boost::int32_t>(dimX, 0);
            boost::int32_t yi = data.getField<boost::int32_t>(dimY, 0);
            boost::int32_t zi = data.getField<boost::int32_t>(dimZ, 0);            
            double x = dimX.applyScaling<boost::int32_t>(xi);
            double y = dimY.applyScaling<boost::int32_t>(yi);
            double z = dimZ.applyScaling<boost::int32_t>(zi);
            std::cout.precision(8);
            std::cout << x << "," << y << "," << z << std::endl;
        }
        else
        {
            throw app_runtime_error("Candidate point not found!");
            
        }

    }

    std::cout << std::endl;
    
    delete filter;
    delete reader;


    
    return 0;
}