void GlyphCustom::initWidget() {
PipelineManager* pm = m_mainWnd->getPipelineManager();
Pipeline* pl = pm->getPipeline(m_pipelineID);
// Get the instance of OkcVisualMap
VisualMap* visMap = pl->getVisualMap();
assert( typeid(*visMap)==typeid(OkcVisualMap) );
OkcVisualMap* okcVisMap = dynamic_cast<OkcVisualMap*>(visMap);
// Get the instance of GlyphPlace
GlyphPlace* place = okcVisMap->getGlyphPlace();
XmdvTool::GLYPHPLACE_MODE mode = place->getGlyphPlaceMode();
// Check one radio button about sorting mode in terms of
// the OkcVisualMap configuration
switch (mode) {
case XmdvTool::GLYPHPLACE_ORIGINAL :
ui.radioButton_orig->setChecked(true);
changeToOriginal();
break;
case XmdvTool::GLYPHPLACE_ORDERED :
ui.radioButton_order->setChecked(true);
changeToOrdered();
break;
case XmdvTool::GLYPHPLACE_DATA_DRIVEN :
ui.radioButton_datadriven->setChecked(true);
changeToDatadriven();
break;
case XmdvTool::GLYPHPLACE_DERIVED :
ui.radioButton_derived->setChecked(true);
changeToDerived();
break;
}
}
void OkcViewDisplay::refreshBrush() {
OkcVisualMapResult* okvVMR = getOkcVisualMapResult();
Operator* brushQ = (Operator*)(okvVMR->getBrushOperator());
PipelineManager* pm = getPipelineManager();
Brush *brush = okvVMR->getBrush();
//If the maximum and minimum values for one dimension has the exact same value,
//they should be adjusted to a little different values,
//otherwise, some records having the same value as this max/min value
//cannot be highlighted.
int i;
for (i=0; i<brush->getDimSize(); i++) {
brush->max[i] += XMDV_DBL_EPSILON;
brush->min[i] -= XMDV_DBL_EPSILON;
}
OkcData* brushStorage = brush->toOkcDataStorage();
std::vector<double> buf;
brushStorage->getData(buf, 3);
int pID = getPipelineID();
// update the assistant input by the reverse pipeline
pm->updateAssisInput(pID, brushStorage, XmdvTool::ASSISDATA_BRUSH);
delete brushStorage;
pm->assemble(pID, brushQ);
getViewManager()->refreshDisplayByPID(pID);
}
TEST(FerryFilterTest, test_ferry_copy_xml)
{
PipelineManager mgr;
mgr.readPipeline(Support::configuredpath("filters/ferry.xml"));
mgr.execute();
ConstPointTableRef table(mgr.pointTable());
PointViewSet viewSet = mgr.views();
EXPECT_EQ(viewSet.size(), 1u);
PointViewPtr view = *viewSet.begin();
EXPECT_EQ(view->size(), 1065u);
Dimension::Id::Enum state_plane_x = table.layout()->findDim("StatePlaneX");
Dimension::Id::Enum state_plane_y = table.layout()->findDim("StatePlaneY");
double lon = view->getFieldAs<double>(Dimension::Id::X, 0);
double lat = view->getFieldAs<double>(Dimension::Id::Y, 0);
double x = view->getFieldAs<double>(state_plane_x, 0);
double y = view->getFieldAs<double>(state_plane_y, 0);
EXPECT_DOUBLE_EQ(-117.2501328350574, lon);
EXPECT_DOUBLE_EQ(49.341077824192915, lat);
EXPECT_DOUBLE_EQ(637012.24, x);
EXPECT_DOUBLE_EQ(849028.31, y);
}
TEST_F(PredicateFilterTest, PredicateFilterTest_EmbedJSON)
{
PipelineManager mgr;
mgr.readPipeline(Support::configuredpath("plang/predicate-embed.json"));
point_count_t cnt = mgr.execute();
EXPECT_EQ(cnt, 1u);
}
TEST(PredicateFilterTest, PredicateFilterTest_Embed)
{
PipelineManager mgr;
PipelineReader reader(mgr);
reader.readPipeline(Support::configuredpath("plang/predicate-embed.xml"));
point_count_t cnt = mgr.execute();
EXPECT_EQ(cnt, 1u);
}
TEST(SbetReaderTest, testPipeline)
{
PipelineManager manager;
PipelineReader reader(manager);
reader.readPipeline(Support::configuredpath("sbet/pipeline.xml"));
point_count_t numPoints = manager.execute();
EXPECT_EQ(numPoints, 2u);
FileUtils::deleteFile(Support::datapath("sbet/outfile.txt"));
}
TEST(IcebridgeReaderTest, testPipeline)
{
PipelineManager manager;
manager.readPipeline(Support::configuredpath("icebridge/pipeline.xml"));
point_count_t numPoints = manager.execute();
EXPECT_EQ(numPoints, 2u);
FileUtils::deleteFile(Support::datapath("icebridge/outfile.txt"));
}
int SmoothKernel::execute()
{
PointTable table;
Stage& readerStage(makeReader(m_inputFile, ""));
// go ahead and prepare/execute on reader stage only to grab input
// PointViewSet, this makes the input PointView available to both the
// processing pipeline and the visualizer
readerStage.prepare(table);
PointViewSet viewSetIn = readerStage.execute(table);
// the input PointViewSet will be used to populate a BufferReader that is
// consumed by the processing pipeline
PointViewPtr input_view = *viewSetIn.begin();
PipelineManager manager;
manager.commonOptions() = m_manager.commonOptions();
manager.stageOptions() = m_manager.stageOptions();
BufferReader& bufferReader =
static_cast<BufferReader&>(manager.makeReader("", "readers.buffer"));
bufferReader.addView(input_view);
std::ostringstream ss;
ss << "{";
ss << " \"pipeline\": {";
ss << " \"filters\": [{";
ss << " \"name\": \"MovingLeastSquares\"";
ss << " }]";
ss << " }";
ss << "}";
Options smoothOptions;
smoothOptions.add("json", ss.str());
Stage& smoothStage = manager.makeFilter("filters.pclblock", bufferReader);
smoothStage.addOptions(smoothOptions);
Stage& writer(Kernel::makeWriter(m_outputFile, smoothStage, ""));
writer.prepare(table);
// process the data, grabbing the PointViewSet for visualization of the
// resulting PointView
PointViewSet viewSetOut = writer.execute(table);
if (isVisualize())
visualize(*viewSetOut.begin());
//visualize(*viewSetIn.begin(), *viewSetOut.begin());
return 0;
}
TIndexKernel::FileInfo TIndexKernel::getFileInfo(KernelFactory& factory,
const std::string& filename)
{
FileInfo fileInfo;
PipelineManager manager;
manager.commonOptions() = m_manager.commonOptions();
manager.stageOptions() = m_manager.stageOptions();
// Need to make sure options get set.
Stage& reader = manager.makeReader(filename, "");
if (m_fastBoundary)
{
QuickInfo qi = reader.preview();
std::stringstream polygon;
polygon << "POLYGON ((";
polygon << qi.m_bounds.minx << " " << qi.m_bounds.miny;
polygon << ", " << qi.m_bounds.maxx << " " << qi.m_bounds.miny;
polygon << ", " << qi.m_bounds.maxx << " " << qi.m_bounds.maxy;
polygon << ", " << qi.m_bounds.minx << " " << qi.m_bounds.maxy;
polygon << ", " << qi.m_bounds.minx << " " << qi.m_bounds.miny;
polygon << "))";
fileInfo.m_boundary = polygon.str();
if (!qi.m_srs.empty())
fileInfo.m_srs = qi.m_srs.getWKT();
}
else
{
Stage& hexer = manager.makeFilter("filters.hexbin", reader);
PointTable table;
hexer.prepare(table);
PointViewSet set = hexer.execute(table);
MetadataNode m = table.metadata();
m = m.findChild("filters.hexbin:boundary");
fileInfo.m_boundary = m.value();
PointViewPtr v = *set.begin();
if (!v->spatialReference().empty())
fileInfo.m_srs = v->spatialReference().getWKT();
}
FileUtils::fileTimes(filename, &fileInfo.m_ctime, &fileInfo.m_mtime);
fileInfo.m_filename = filename;
return fileInfo;
}
TEST(MergeTest, test4)
{
using namespace pdal;
PipelineManager mgr;
mgr.readPipeline(Support::configuredpath("filters/merge.json"));
mgr.execute();
PointViewSet viewSet = mgr.views();
EXPECT_EQ(1u, viewSet.size());
PointViewPtr view = *viewSet.begin();
EXPECT_EQ(2130u, view->size());
}
TEST(MergeTest, test2)
{
using namespace pdal;
PipelineManager mgr;
PipelineReader specReader(mgr);
specReader.readPipeline(Support::configuredpath("filters/merge2.xml"));
mgr.execute();
PointViewSet viewSet = mgr.views();
EXPECT_EQ(viewSet.size(), 1u);
PointViewPtr view = *viewSet.begin();
EXPECT_EQ(view->size(), 2130u);
}
void Kernel::visualize(PointViewPtr view)
{
PipelineManager manager;
manager.commonOptions() = m_manager.commonOptions();
manager.stageOptions() = m_manager.stageOptions();
BufferReader& reader =
static_cast<BufferReader&>(manager.makeReader("", "readers.buffer"));
reader.addView(view);
Stage& writer = manager.makeWriter("", "writers.pclvisualizer", reader);
PointTable table;
writer.prepare(table);
writer.execute(table);
}
TEST_F(PythonFilterTest, pipelineJSON)
{
PipelineManager manager;
manager.readPipeline(
Support::configuredpath("plang/programmable-update-y-dims.json"));
manager.execute();
PointViewSet viewSet = manager.views();
EXPECT_EQ(viewSet.size(), 1u);
PointViewPtr view = *viewSet.begin();
for (PointId idx = 0; idx < 10; ++idx)
{
int32_t y = view->getFieldAs<int32_t>(Dimension::Id::Y, idx);
EXPECT_EQ(y, 314);
}
}
TEST(SortFilterTest, pipeline)
{
PipelineManager mgr;
PipelineReader reader(mgr);
reader.readPipeline(Support::configuredpath("filters/sort.xml"));
mgr.execute();
PointBufferSet pbSet = mgr.buffers();
EXPECT_EQ(pbSet.size(), 1u);
PointBufferPtr buf = *pbSet.begin();
for (PointId i = 1; i < buf->size(); ++i)
{
double d1 = buf->getFieldAs<double>(Dimension::Id::X, i - 1);
double d2 = buf->getFieldAs<double>(Dimension::Id::X, i);
EXPECT_TRUE(d1 <= d2);
}
}
TEST(json, tags)
{
PipelineManager manager;
manager.readPipeline(Support::configuredpath("pipeline/tags.json"));
std::vector<Stage *> stages = manager.m_stages;
EXPECT_EQ(stages.size(), 4u);
size_t totalInputs(0);
for (Stage *s : stages)
{
std::vector<Stage *> inputs = s->getInputs();
if (inputs.empty())
EXPECT_EQ(s->getName(), "readers.las");
if (inputs.size() == 1 || inputs.size() == 2)
EXPECT_EQ(s->getName(), "writers.las");
totalInputs += inputs.size();
}
EXPECT_EQ(totalInputs, 3U);
}
TEST(MergeTest, test3)
{
using namespace pdal;
PipelineManager mgr;
mgr.readPipeline(Support::configuredpath("filters/merge3.xml"));
std::ostringstream oss;
std::ostream& o = std::clog;
auto ctx = Utils::redirect(o, oss);
mgr.execute();
std::string s = oss.str();
EXPECT_TRUE(s.find("inconsistent spatial references") != s.npos);
Utils::restore(o, ctx);
PointViewSet viewSet = mgr.views();
EXPECT_EQ(1u, viewSet.size());
PointViewPtr view = *viewSet.begin();
EXPECT_EQ(2130u, view->size());
}
// Make sure we handle repeated options properly
TEST(json, issue_1941)
{
PipelineManager manager;
std::string file;
file = Support::configuredpath("pipeline/range_multi_limits.json");
manager.readPipeline(file);
EXPECT_EQ(manager.execute(), (point_count_t)5);
const PointViewSet& s = manager.views();
EXPECT_EQ(s.size(), 1U);
PointViewPtr view = *s.begin();
EXPECT_EQ(view->getFieldAs<int>(Dimension::Id::X, 0), 3);
EXPECT_EQ(view->getFieldAs<int>(Dimension::Id::X, 1), 4);
EXPECT_EQ(view->getFieldAs<int>(Dimension::Id::X, 2), 5);
EXPECT_EQ(view->getFieldAs<int>(Dimension::Id::X, 3), 8);
EXPECT_EQ(view->getFieldAs<int>(Dimension::Id::X, 4), 9);
PipelineManager manager2;
file = Support::configuredpath("pipeline/range_bad_limits.json");
EXPECT_THROW(manager2.readPipeline(file), pdal_error);
}
bool Pipeline::willOuputToVis(XmdvTool::VISTYPE visType) {
PipelineManager* pm = getPipelineManager();
ViewManager* vm = pm->getViewManager();
return vm->willOuputToVis(getPipelineID(), visType);
}
void GlyphCustom::on_pushButton_apply_clicked() {
getOkcPipelineSettings()->m_glyphPlaceMode = m_placeMode;
PipelineManager* pm = m_mainWnd->getPipelineManager();
ViewManager * vm = m_mainWnd->getViewManager();
OkcPipeline* pl = getOkcPipeline();
Transformation* mainT = pl->getMainTransformation();
XmdvTool::PLTYPE plType = pl->getPipelineType();
assert (plType==XmdvTool::PLTYPE_FLATNORMAL ||
plType==XmdvTool::PLTYPE_SBB);
SortRowsOperator* sortO = pl->getSortRowsOperator();
PCADeriveOperator* pcaO = pl->getPCADeriveOperator();
// Setup the pipeline in terms of the current glyph place mode
switch (m_placeMode) {
case XmdvTool::GLYPHPLACE_ORIGINAL :
{
// Disable the sort operator
// Disable the PCA operator
switch (plType) {
case XmdvTool::PLTYPE_FLATNORMAL :
mainT->enableOperator(PL_FN_OP_SORT, false);
mainT->enableOperator(PL_FN_OP_PCADERIVE, false);
break;
case XmdvTool::PLTYPE_SBB :
mainT->enableOperator(PL_SBB_OP_SORT, false);
mainT->enableOperator(PL_SBB_OP_PCADERIVE, false);
break;
default:
// The code should not go to here;
return;
}
// Reassemble the pipeline
pm->assemble(m_pipelineID, sortO);
// If the current views include the glyphs, refresh the output
if (vm->willOuputToVis(m_pipelineID, XmdvTool::VISTYPE_GL)) {
vm->refreshDisplayByPID(m_pipelineID);
}
}
break;
case XmdvTool::GLYPHPLACE_ORDERED :
{
if (m_selectedDimNo<0 || m_selectedDimNo>=ui.listWidget_dims->count()) {
// If users did not select anything, return immediately
return;
}
// Enable the sort operator
// Disable the PCA operator
switch (plType) {
case XmdvTool::PLTYPE_FLATNORMAL :
mainT->enableOperator(PL_FN_OP_SORT, true);
mainT->enableOperator(PL_FN_OP_PCADERIVE, false);
break;
case XmdvTool::PLTYPE_SBB :
mainT->enableOperator(PL_SBB_OP_SORT, true);
mainT->enableOperator(PL_SBB_OP_PCADERIVE, false);
break;
default:
// The code should not go to here;
return;
}
// Get the sort operator
// Setup the sort Operator
sortO->setSortWay (XmdvTool::OKCDIM_ORIGINAL);
sortO->setSortDimNo (m_selectedDimNo);
sortO->setSortOrder (m_sortOrder);
// Reassemble the pipeline
pm->assemble(m_pipelineID, sortO);
// If the current views include the glyphs, refresh the output
if (vm->willOuputToVis(m_pipelineID, XmdvTool::VISTYPE_GL)) {
vm->refreshDisplayByPID(m_pipelineID);
}
}
break;
case XmdvTool::GLYPHPLACE_DATA_DRIVEN :
{
if (m_XDimNumber<0
|| m_XDimNumber>=ui.listWidget_dims->count()
|| m_YDimNumber<0
|| m_YDimNumber>=ui.listWidget_dims->count()) {
// If users did not select anything for X dim or Y dim, return immediately
return;
}
// Disable the sort operator
// Disable the PCA operator
switch (plType) {
case XmdvTool::PLTYPE_FLATNORMAL :
mainT->enableOperator(PL_FN_OP_SORT, false);
mainT->enableOperator(PL_FN_OP_PCADERIVE, false);
break;
case XmdvTool::PLTYPE_SBB :
mainT->enableOperator(PL_SBB_OP_SORT, false);
mainT->enableOperator(PL_SBB_OP_PCADERIVE, false);
break;
default:
// The code should not go to here;
return;
}
OkcPipeline* okcpl = getOkcPipeline();
OkcVisualMap* okcvm = okcpl->getOkcVisualMap();
GlyphPlace* gp = okcvm->getGlyphPlace();
gp->setDimX(XmdvTool::OKCDIM_ORIGINAL);
gp->setDimXNo(m_XDimNumber);
gp->setDimY(XmdvTool::OKCDIM_ORIGINAL);
gp->setDimYNo(m_YDimNumber);
// Reassemble the pipeline
pm->assemble(m_pipelineID, sortO);
// If the current views include the glyphs, refresh the output
if (vm->willOuputToVis(m_pipelineID, XmdvTool::VISTYPE_GL)) {
vm->refreshDisplayByPID(m_pipelineID);
}
}
break;
case XmdvTool::GLYPHPLACE_DERIVED :
{
if (m_XDimNumber<0 || m_YDimNumber<0 ) {
// If users did not select anything for X dim or Y dim, return immediately
return;
}
// Disable the sort operator
// Enable the PCA operator
switch (plType) {
case XmdvTool::PLTYPE_FLATNORMAL :
mainT->enableOperator(PL_FN_OP_SORT, false);
mainT->enableOperator(PL_FN_OP_PCADERIVE, true);
break;
case XmdvTool::PLTYPE_SBB :
mainT->enableOperator(PL_SBB_OP_SORT, false);
mainT->enableOperator(PL_SBB_OP_PCADERIVE, true);
break;
default:
// The code should not go to here;
return;
}
OkcPipeline* okcpl = getOkcPipeline();
OkcVisualMap* okcvm = okcpl->getOkcVisualMap();
GlyphPlace* gp = okcvm->getGlyphPlace();
gp->setDimX(m_XDim);
gp->setDimXNo(m_XDimNumber);
gp->setDimY(m_YDim);
gp->setDimYNo(m_YDimNumber);
// Reassemble the pipeline
if (okcpl->needRunPCA()) {
// If the PCA algorithm has been run once,
// assemble the pipeline from the pca operator
pm->assemble(m_pipelineID, pcaO);
okcpl->setNeedRunPCA(false);
} else {
// If the PCA algorithm has been run once,
// we only need to do visual mapping
pm->assemble(m_pipelineID, -1);
}
// If the current views include the glyphs, refresh the output
if (vm->willOuputToVis(m_pipelineID, XmdvTool::VISTYPE_GL)) {
vm->refreshDisplayByPID(m_pipelineID);
}
}
break;
}
}
OkcPipeline* GlyphCustom::getOkcPipeline() {
PipelineManager* pm = m_mainWnd->getPipelineManager();
Pipeline* pl = pm->getPipeline(m_pipelineID);
return dynamic_cast<OkcPipeline*>(pl);
}
