557 lines
20 KiB
C++
Executable File
557 lines
20 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* Declaration/Definition
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
*/
|
|
|
|
#include "Viewshed.h"
|
|
|
|
|
|
// Qt
|
|
#include <QDebug>
|
|
#include <QDialog>
|
|
#include <QPushButton>
|
|
#include <QGridLayout>
|
|
#include <QLabel>
|
|
#include <QMessageBox>
|
|
|
|
|
|
// Esri
|
|
#include <arcgis/ArcGISRuntime.h>
|
|
#include <arcgis/MapGraphicsView.h>
|
|
#include <arcgis/SimpleMarkerSymbol.h>
|
|
#include <arcgis/SimpleFillSymbol.h>
|
|
#include <arcgis/UserCredentials.h>
|
|
#include <arcgis/ProxySetup.h>
|
|
|
|
|
|
|
|
// Uncomment if needed
|
|
//#include <Graphic.h>
|
|
//#include <SimpleMarkerSymbol.h>
|
|
//#include <PictureMarkerSymbol.h>
|
|
//#include <Point.h>
|
|
//#include <Polyline.h>
|
|
//#include <MultiPath.h>
|
|
|
|
|
|
//#define USE_SAMPLE_SERVER
|
|
|
|
|
|
EsriRuntimeQt::SpatialReference sr(102100);
|
|
|
|
mainwindow::mainwindow(QWidget *parent)
|
|
: QMainWindow(parent)
|
|
{
|
|
m_map = new EsriRuntimeQt::Map(this);
|
|
|
|
connect(m_map, SIGNAL(mapReady()), this, SLOT(onMapReady()));
|
|
|
|
m_mapGraphicsView = EsriRuntimeQt::MapGraphicsView::create(m_map, this);
|
|
setCentralWidget(m_mapGraphicsView);
|
|
m_map->setWrapAroundEnabled(false);
|
|
|
|
// create and add the tiled layer
|
|
EsriRuntimeQt::ArcGISTiledMapServiceLayer* mapServiceLayer =
|
|
new EsriRuntimeQt::ArcGISTiledMapServiceLayer(QLatin1String("http://services.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer"), this);
|
|
m_map->addLayer(mapServiceLayer);
|
|
|
|
QString path = EsriRuntimeQt::ArcGISRuntime::installDirectory();
|
|
path.append(QLatin1String("/sdk/samples/data"));
|
|
QDir dataDir(path); // using QDir to convert to correct file separator
|
|
QString pathSampleData = dataDir.path() + QDir::separator();
|
|
qDebug() << " installDirectory='" << path << "'";
|
|
|
|
QString tiledBaseMapLayer = pathSampleData + QLatin1String("tpks/Topographic.tpk");
|
|
qDebug() << " tiledBaseMapLayer='" << tiledBaseMapLayer << "'";
|
|
|
|
// m_tiledLayer = new EsriRuntimeQt::ArcGISLocalTiledLayer(tiledBaseMapLayer, this);
|
|
// m_tiledLayer->setName( QLatin1String("ArcGISLocalTiledLayer") );
|
|
// m_map->addLayer(m_tiledLayer);
|
|
|
|
|
|
// Create Graphics Layer
|
|
m_graphicsLayer = new EsriRuntimeQt::GraphicsLayer(this);
|
|
m_graphicsLayer -> setName(QLatin1String("GraphicsLayer"));
|
|
|
|
m_map->addLayer(m_graphicsLayer);
|
|
|
|
// {
|
|
// //
|
|
// // Create red circle at maps origin
|
|
// //
|
|
|
|
// EsriRuntimeQt::Point nullPoint(0, 0, m_map->spatialReference());
|
|
// EsriRuntimeQt::SimpleMarkerSymbol redCircle(Qt::red, 20, EsriRuntimeQt::SimpleMarkerSymbolStyle::Circle);
|
|
// EsriRuntimeQt::Graphic* graphic1 = new EsriRuntimeQt::Graphic( nullPoint, redCircle);
|
|
|
|
// qint64 gId = m_graphicsLayer->addGraphic(graphic1);
|
|
|
|
// //
|
|
// // Get access to graphic and hide: -> Works fine :-)
|
|
// //
|
|
// EsriRuntimeQt::Graphic* graphicRetrieved = m_graphicsLayer->graphic(gId);
|
|
|
|
// if (graphicRetrieved)
|
|
// {
|
|
// graphicRetrieved->setVisible(false);
|
|
// } else {
|
|
// qWarning() << LOGFUNCTION << "could NOT retrieve graphic" ;
|
|
// }
|
|
// }
|
|
|
|
|
|
QString url;
|
|
#ifdef USE_SAMPLE_SERVER
|
|
url = QLatin1String("http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Elevation/ESRI_Elevation_World/GPServer/Viewshed");
|
|
#else
|
|
url = QLatin1String("http://elevation.arcgis.com/arcgis/rest/services/Tools/Elevation/GPServer/Viewshed");
|
|
#endif
|
|
|
|
qDebug() << LOGFUNCTION << " url='" << url << "'";
|
|
|
|
|
|
// create a Geoprocessor that points to the remote geoprocessing service.
|
|
EsriRuntimeQt::UserCredentials *ucEsri = new EsriRuntimeQt::UserCredentials;
|
|
ucEsri->setUserAccount("norbert.thoden", "RDEESRI7");
|
|
m_geoprocessor = new EsriRuntimeQt::Geoprocessor(url,
|
|
ucEsri,
|
|
this);
|
|
|
|
connect(m_geoprocessor,
|
|
SIGNAL(gpError(const EsriRuntimeQt::ServiceError&)), this,
|
|
SLOT(onGpError(const EsriRuntimeQt::ServiceError&)));
|
|
|
|
#ifdef USE_SAMPLE_SERVER
|
|
connect(m_geoprocessor,
|
|
SIGNAL(gpExecuteComplete(const QList<EsriRuntimeQt::GPParameter*>&)), this,
|
|
SLOT(onGpExecuteComplete(const QList<EsriRuntimeQt::GPParameter*>&)));
|
|
|
|
#else
|
|
connect(m_geoprocessor,
|
|
SIGNAL(gpSubmitJobComplete(const EsriRuntimeQt::GPJobResource&)), this,
|
|
SLOT(onGpSubmitJobComplete(const EsriRuntimeQt::GPJobResource&)));
|
|
// used:
|
|
connect(m_geoprocessor,
|
|
SIGNAL(gpJobStatusComplete(const EsriRuntimeQt::GPJobResource&)), this,
|
|
SLOT(onGpJobStatusComplete(const EsriRuntimeQt::GPJobResource&)));
|
|
|
|
// used:
|
|
connect(m_geoprocessor,
|
|
SIGNAL(gpResultComplete(EsriRuntimeQt::GPParameter*)), this,
|
|
SLOT(onGpResultComplete(EsriRuntimeQt::GPParameter*)));
|
|
|
|
// unused!?
|
|
connect(m_geoprocessor,
|
|
SIGNAL(gpServiceInfoComplete(EsriRuntimeQt::GPServiceInfo)), this,
|
|
SLOT(onGpServiceInfoComplete(EsriRuntimeQt::GPServiceInfo)));
|
|
|
|
// unused!?
|
|
connect(m_geoprocessor,
|
|
SIGNAL(gpSubmitJobAndGetResultComplete(const EsriRuntimeQt::GPJobResource&, const QList<EsriRuntimeQt::GPParameter*>&)), this,
|
|
SLOT(onGpSubmitJobAndGetResultComplete(const EsriRuntimeQt::GPJobResource&, const QList<EsriRuntimeQt::GPParameter*>&)));
|
|
|
|
// unused!?
|
|
connect(m_geoprocessor,
|
|
SIGNAL(statusUpdated(const EsriRuntimeQt::GPJobResource&, const QList<EsriRuntimeQt::GPMessage>&)), this,
|
|
SLOT(onStatusUpdated(const EsriRuntimeQt::GPJobResource&, const QList<EsriRuntimeQt::GPMessage>&)));
|
|
|
|
// unused!?
|
|
connect(m_geoprocessor,
|
|
SIGNAL(gpTaskInfoComplete(EsriRuntimeQt::GPTaskInfo)), this,
|
|
SLOT(onGpTaskInfoComplete(const EsriRuntimeQt::GPTaskInfo&)));
|
|
#endif
|
|
|
|
// connect signals
|
|
connect(m_map, SIGNAL(mapReady()), this, SLOT(onMapReady()));
|
|
connect(m_map, SIGNAL(mousePressRelease(QMouseEvent&)), this, SLOT(onMousePressRelease(QMouseEvent&)));
|
|
|
|
|
|
// // set up progress bar
|
|
// m_progressDialog = new QProgressDialog();
|
|
// m_progressDialog->setBaseSize(280, 20);
|
|
// m_progressDialog->setRange(0, 0);
|
|
// m_progressDialog->setValue(0);
|
|
// m_progressDialog->setCancelButton(0);
|
|
// connect(m_mapGraphicsView->scene(), SIGNAL(sceneRectChanged(QRectF)), this, SLOT(onResizeProgressBar()));
|
|
// m_progressDialog->setLabelText("");
|
|
// m_progressDialog->setAttribute(Qt::WA_NoBackground);
|
|
// m_progressDialog->setAutoFillBackground(false);
|
|
// m_progressDialog->setVisible(false);
|
|
|
|
// WidgetPanel* widget = new WidgetPanel();
|
|
// QLabel* instructionsLabel = new QLabel(
|
|
// QString("Click on the map to set the viewshed point. The viewshed will be computed ") +
|
|
// QString("from the specified buffer area around the viewshed point. "));
|
|
// instructionsLabel->setWordWrap(true);
|
|
// QFont font;
|
|
// font.setPixelSize(11);
|
|
// instructionsLabel->setFont(font);
|
|
// instructionsLabel->setMargin(5);
|
|
// instructionsLabel->setObjectName("instructions");
|
|
// instructionsLabel->setStyleSheet("QLabel#instructions { background: rgba(0,0,0, 192); color: #ddd; }");
|
|
// instructionsLabel->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding));
|
|
//
|
|
// QVBoxLayout* layout = new QVBoxLayout();
|
|
// layout->setMargin(0);
|
|
//// layout->addWidget(instructionsLabel, Qt::AlignLeft);
|
|
|
|
// QHBoxLayout* horizontalBox = new QHBoxLayout();
|
|
// horizontalBox->setMargin(1);
|
|
|
|
// QFont font;
|
|
// font.setPixelSize(12);
|
|
// QLabel* distanceLabel = new QLabel("Viewshed Buffer (miles):");
|
|
// distanceLabel->setFixedSize(180, 25);
|
|
// distanceLabel->setFont(font);
|
|
// distanceLabel->setMargin(5);
|
|
// horizontalBox->addWidget(distanceLabel, Qt::AlignRight);
|
|
|
|
// m_textDistanceLineEdit = new QLineEdit("9");
|
|
// m_textDistanceLineEdit->setFixedSize(60, 25);
|
|
// m_textDistanceLineEdit->setFont(font);
|
|
|
|
// horizontalBox->addWidget(m_textDistanceLineEdit, Qt::AlignLeft);
|
|
// layout->addLayout(horizontalBox);
|
|
|
|
//// widget->setFixedSize(210, 105);
|
|
//// widget->setLayout(layout);
|
|
|
|
// QGraphicsProxyWidget *proxy = m_mapGraphicsView->scene()->addWidget(widget);
|
|
// proxy->setPos(10, 10);
|
|
// proxy->setAcceptedMouseButtons(Qt::LeftButton);
|
|
// proxy->setFlag(QGraphicsItem::ItemIsFocusable, true);
|
|
// proxy->setFlag(QGraphicsItem::ItemIsSelectable, true);
|
|
// proxy->setFlag(QGraphicsItem::ItemAcceptsInputMethod, true);
|
|
// proxy->setOpacity(0.85);
|
|
|
|
// m_proxyProgressBar = m_mapGraphicsView->scene()->addWidget(m_progressDialog);
|
|
// m_proxyProgressBar->setAcceptedMouseButtons(Qt::NoButton);
|
|
// m_proxyProgressBar->setFlag(QGraphicsItem::ItemIsSelectable, false);
|
|
|
|
|
|
|
|
|
|
// m_viewShed = new
|
|
// SituationMap::ViewshedBase(
|
|
// m_geoprocessor->url()
|
|
// , *m_graphicsLayer,
|
|
// this);
|
|
|
|
// bool init = m_viewShed->init();
|
|
// qDebug() << LOGFUNCTION << " init=" << init;
|
|
|
|
|
|
} /* mainwindow::mainwindow */
|
|
|
|
|
|
mainwindow::~mainwindow()
|
|
{
|
|
}
|
|
|
|
|
|
void mainwindow::onMapReady()
|
|
{
|
|
qDebug() << LOGFUNCTION << " ready";
|
|
// m_map->setExtent(EsriRuntimeQt::Envelope(-10000, -10000, 10000, 10000, sr));
|
|
|
|
m_map->setExtent(EsriRuntimeQt::Envelope(-13386516, 4516694, -13236394, 4616827, m_map->spatialReference()));
|
|
m_srMap = m_map->spatialReference();
|
|
}
|
|
|
|
|
|
void mainwindow::onMousePressRelease(QMouseEvent &event)
|
|
{
|
|
qDebug() << LOGFUNCTION;
|
|
|
|
if (event.button() != Qt::LeftButton)
|
|
return;
|
|
|
|
if (m_inProgress)
|
|
return;
|
|
|
|
QPoint scenePosition = event.pos();
|
|
|
|
// // make sure the mouse didn't move - if so it was a pan so do nothing
|
|
// QGraphicsItem * graphicsItem = nullptr;
|
|
// graphicsItem = itemFromQGraphicsScene(m_mapGraphicsView->scene(), scenePosition);
|
|
// if (graphicsItem)
|
|
// return; // Clicked item box
|
|
|
|
// remove viewshed from previous computation
|
|
m_graphicsLayer->removeAll();
|
|
|
|
int inputValue = 10;
|
|
// inputValue = m_textDistanceLineEdit->text().toInt();
|
|
if (inputValue > 12 || inputValue < 1)
|
|
{
|
|
if (m_progressDialog)
|
|
m_progressDialog->setVisible(false);
|
|
QMessageBox::warning(this, "Invalid Distance", "Please enter an integer from 1 to 12.");
|
|
return;
|
|
}
|
|
|
|
// the click point is the viewshed point
|
|
EsriRuntimeQt::Point viewshedPoint = m_map->toMapPoint(scenePosition.x(), scenePosition.y());
|
|
|
|
qDebug() << LOGFUNCTION<< " esriViewshedPoint.x=" << viewshedPoint.x()
|
|
<< " ;y=" << viewshedPoint.y()
|
|
<< " wkid=" << viewshedPoint.spatialReference().wkid()
|
|
<< " m_inProgress=" << m_inProgress
|
|
;
|
|
|
|
|
|
// make sure it is a point on the map
|
|
if (!EsriRuntimeQt::GeometryEngine::within(viewshedPoint, m_map->extent()))
|
|
return;
|
|
|
|
m_inProgress = true;
|
|
|
|
if (m_progressDialog)
|
|
{
|
|
m_progressDialog->setLabelText("Computing the viewshed...");
|
|
m_progressDialog->setVisible(true);
|
|
}
|
|
|
|
EsriRuntimeQt::Graphic* viewshedPointGraphic = new EsriRuntimeQt::Graphic(viewshedPoint, EsriRuntimeQt::SimpleMarkerSymbol(QColor("Black"), 14, EsriRuntimeQt::SimpleMarkerSymbolStyle::X));
|
|
m_graphicsLayer->addGraphic(viewshedPointGraphic);
|
|
|
|
// initialize the input parameters. refer to help link in the geoprocessing service URL.
|
|
m_geoprocessor->setProcessSR(m_srMap);
|
|
m_geoprocessor->setOutSR(m_srMap);
|
|
|
|
QList<EsriRuntimeQt::GPParameter*> gpInputParams;
|
|
|
|
#ifdef USE_SAMPLE_SERVER
|
|
EsriRuntimeQt::GPFeatureRecordSetLayer* gpInputViewshedPoint =
|
|
new EsriRuntimeQt::GPFeatureRecordSetLayer("Input_Observation_Point", this);
|
|
#else
|
|
EsriRuntimeQt::GPFeatureRecordSetLayer* gpInputViewshedPoint =
|
|
new EsriRuntimeQt::GPFeatureRecordSetLayer("InputPoints", this);
|
|
#endif
|
|
gpInputViewshedPoint->setSpatialReference(m_srMap);
|
|
gpInputViewshedPoint->addGraphic(qobject_cast<EsriRuntimeQt::Graphic*>(viewshedPointGraphic->clone(this)));
|
|
|
|
|
|
|
|
#ifdef USE_SAMPLE_SERVER
|
|
EsriRuntimeQt::GPLinearUnit* gpInputViewshedDistance =
|
|
new EsriRuntimeQt::GPLinearUnit("Viewshed_Distance", this);
|
|
gpInputViewshedDistance->setUnits("esriMiles");
|
|
gpInputViewshedDistance->setDistance(inputValue);
|
|
|
|
gpInputParams.append(gpInputViewshedPoint);
|
|
gpInputParams.append(gpInputViewshedDistance);
|
|
|
|
#else
|
|
EsriRuntimeQt::GPDouble* gpInputMaxDistance =
|
|
new EsriRuntimeQt::GPDouble("MaximumDistance", this);
|
|
gpInputMaxDistance->setValue(inputValue);
|
|
|
|
EsriRuntimeQt::GPString* gpInputMaxDistanceUnits =
|
|
new EsriRuntimeQt::GPString("MaximumDistanceUnits", this);
|
|
gpInputMaxDistanceUnits->setValue(QLatin1String("Miles"));
|
|
|
|
EsriRuntimeQt::GPDouble* gpInputObserverHeight =
|
|
new EsriRuntimeQt::GPDouble("ObserverHeight", this);
|
|
gpInputObserverHeight->setValue(3000); // [Meter]
|
|
|
|
EsriRuntimeQt::GPBoolean* gpInputGeneralize =
|
|
new EsriRuntimeQt::GPBoolean("GeneralizeViewshedPolygons", this);
|
|
gpInputGeneralize->setValue(false);
|
|
|
|
|
|
gpInputParams.append(gpInputViewshedPoint);
|
|
gpInputParams.append(gpInputMaxDistance);
|
|
gpInputParams.append(gpInputMaxDistanceUnits);
|
|
gpInputParams.append(gpInputObserverHeight);
|
|
// gpInputParams.append(gpInputGeneralize);
|
|
#endif
|
|
|
|
// execute the geoprocessing request
|
|
|
|
// -------------------------------------------------------------------------------------
|
|
// Option 1 - execute sync
|
|
// Client execution will happen in this thread. It will be blocked on server.
|
|
// Client side result collection will happen in this thread. It will be blocked on server.
|
|
//
|
|
// This is ideal for jobs that take less processing time and whose result size is small.
|
|
// This will freeze the UI.
|
|
// -------------------------------------------------------------------------------------
|
|
/*QList<EsriRuntimeQt::GPParameter*> result = m_geoprocessor->execute(gpInputParams);
|
|
processResult(result);*/
|
|
|
|
// -------------------------------------------------------------------------------------
|
|
// Option 2 - execute async
|
|
// Client execution will happen in a new thread. It will be blocked on server.
|
|
// Client side result collection will happen on that thread. It will be blocked on server.
|
|
//
|
|
// This is ideal for jobs that take relatively more processing time than option 1
|
|
// and whose result size is small.
|
|
// -------------------------------------------------------------------------------------
|
|
// m_geoprocessor->execute(gpInputParams);
|
|
|
|
m_geoprocessor->setStatusPollingInterval(10);
|
|
|
|
#ifdef USE_SAMPLE_SERVER
|
|
m_geoprocessor->execute( gpInputParams );
|
|
#else
|
|
m_geoprocessor->submitJob(gpInputParams);
|
|
#endif
|
|
|
|
|
|
|
|
}
|
|
|
|
void mainwindow::onGpExecuteComplete(const QList<EsriRuntimeQt::GPParameter *> &result)
|
|
{
|
|
qDebug() << LOGFUNCTION << " result.size()=" << result.size();
|
|
|
|
foreach (EsriRuntimeQt::GPParameter* outputParameter, result)
|
|
{
|
|
if (!outputParameter)
|
|
continue;
|
|
|
|
EsriRuntimeQt::GPFeatureRecordSetLayer* gpLayer = qobject_cast<EsriRuntimeQt::GPFeatureRecordSetLayer*>(outputParameter);
|
|
if (gpLayer)
|
|
{
|
|
qDebug() << LOGFUNCTION << " gpLayer->graphics().size=" << gpLayer->graphics().size();
|
|
// get all the graphics and add them to the graphics layer.
|
|
foreach (EsriRuntimeQt::Graphic* resultGraphic, gpLayer->graphics())
|
|
{
|
|
EsriRuntimeQt::Graphic* theGraphic = new EsriRuntimeQt::Graphic(resultGraphic->geometry(), EsriRuntimeQt::SimpleFillSymbol(QColor(255, 0, 0, 80), EsriRuntimeQt::SimpleFillSymbolStyle::Solid, EsriRuntimeQt::SimpleLineSymbol(QColor("Red"), 0.5)));
|
|
// add to the graphics layer
|
|
m_graphicsLayer->addGraphic(theGraphic);
|
|
}
|
|
}
|
|
|
|
outputParameter->deleteLater();
|
|
}
|
|
|
|
if (m_progressDialog)
|
|
m_progressDialog->setVisible(false);
|
|
|
|
m_inProgress = false;
|
|
|
|
}
|
|
|
|
void mainwindow::onGpError(const EsriRuntimeQt::ServiceError &error)
|
|
{
|
|
if (m_progressDialog)
|
|
m_progressDialog->setVisible(false);
|
|
qWarning() << LOGFUNCTION << QString("Service Error, code: %1, message: %2, details: %3").arg(QString::number(error.code()), error.message(), error.details());
|
|
|
|
m_inProgress = false;
|
|
}
|
|
|
|
void mainwindow::onGpSubmitJobComplete(const EsriRuntimeQt::GPJobResource &jobResource)
|
|
{
|
|
qWarning() << "\n";
|
|
qWarning() << LOGFUNCTION << " isEmpty=" << jobResource.isEmpty();
|
|
qWarning() << LOGFUNCTION << " jobId='" << jobResource.jobId() << "'";
|
|
qWarning() << LOGFUNCTION << " jobStatus='" << (int)jobResource.jobStatus() << "'";
|
|
qWarning() << LOGFUNCTION << " inputParameters().size()='" << (int)jobResource.inputParameters().size() << "'";
|
|
qWarning() << LOGFUNCTION << " outputParameters().size()='" << (int)jobResource.outputParameters().size() << "'";
|
|
qWarning() << LOGFUNCTION << " messages().size()='" << (int)jobResource.messages().size() << "'";
|
|
|
|
|
|
delete m_timer;
|
|
m_timer = new QTimer;
|
|
connect(m_timer, &QTimer::timeout, [=]() {
|
|
qWarning() << " jobStatus() ...";
|
|
m_geoprocessor->jobStatus();
|
|
|
|
} );
|
|
|
|
qWarning() << "\n starting timer...";
|
|
m_timer->start(1000);
|
|
}
|
|
|
|
void mainwindow::onGpJobStatusComplete(const EsriRuntimeQt::GPJobResource &jobResource)
|
|
{
|
|
qWarning() << "\n";
|
|
qWarning() << LOGFUNCTION << " isEmpty=" << jobResource.isEmpty();
|
|
qWarning() << LOGFUNCTION << " jobId='" << jobResource.jobId() << "'";
|
|
qWarning() << LOGFUNCTION << " jobStatus='" << (int)jobResource.jobStatus() << "'";
|
|
qWarning() << LOGFUNCTION << " inputParameters().size()='" << (int)jobResource.inputParameters().size() << "'";
|
|
qWarning() << LOGFUNCTION << " outputParameters().size()='" << (int)jobResource.outputParameters().size() << "'";
|
|
qWarning() << LOGFUNCTION << " messages().size()='" << (int)jobResource.messages().size() << "'";
|
|
|
|
if (jobResource.jobStatus() == EsriRuntimeQt::JobStatus::Succeeded)
|
|
{
|
|
qWarning() << " Succeeded :-)";
|
|
|
|
if (m_timer)
|
|
m_timer->stop();
|
|
|
|
m_geoprocessor->result(jobResource,
|
|
QLatin1String("OutputViewshed"),
|
|
true); // GetAsImageResult
|
|
}
|
|
}
|
|
|
|
void mainwindow::onGpResultComplete(EsriRuntimeQt::GPParameter *outputParameter)
|
|
{
|
|
qWarning() << "\n";
|
|
qWarning() << LOGFUNCTION << " outputParameter=" << outputParameter;
|
|
|
|
if (outputParameter)
|
|
{
|
|
EsriRuntimeQt::GPFeatureRecordSetLayer* gpLayer = qobject_cast<EsriRuntimeQt::GPFeatureRecordSetLayer*>(outputParameter);
|
|
if (gpLayer)
|
|
{
|
|
qDebug() << LOGFUNCTION << " gpLayer->graphics().size=" << gpLayer->graphics().size();
|
|
// get all the graphics and add them to the graphics layer.
|
|
foreach (EsriRuntimeQt::Graphic* resultGraphic, gpLayer->graphics())
|
|
{
|
|
EsriRuntimeQt::Graphic* theGraphic =
|
|
new EsriRuntimeQt::Graphic(resultGraphic->geometry(),
|
|
EsriRuntimeQt::SimpleFillSymbol(QColor(0, 255, 0, 80), EsriRuntimeQt::SimpleFillSymbolStyle::Solid,
|
|
EsriRuntimeQt::SimpleLineSymbol(QColor("Red"), 0.5)));
|
|
// add to the graphics layer
|
|
m_graphicsLayer->addGraphic(theGraphic);
|
|
}
|
|
}
|
|
outputParameter->deleteLater();
|
|
}
|
|
}
|
|
|
|
void mainwindow::onGpServiceInfoComplete(EsriRuntimeQt::GPServiceInfo serviceInfo)
|
|
{
|
|
qWarning() << "\n";
|
|
qWarning() << LOGFUNCTION ;
|
|
}
|
|
|
|
void mainwindow::onGpSubmitJobAndGetResultComplete(const EsriRuntimeQt::GPJobResource &, const QList<EsriRuntimeQt::GPParameter *> &results)
|
|
{
|
|
qWarning() << "\n";
|
|
qWarning() << LOGFUNCTION ;
|
|
}
|
|
|
|
void mainwindow::onStatusUpdated(const EsriRuntimeQt::GPJobResource &jobResource, const QList<EsriRuntimeQt::GPMessage> &msgList)
|
|
{
|
|
qWarning() << "\n";
|
|
qWarning() << LOGFUNCTION << " isEmpty=" << jobResource.isEmpty();
|
|
qWarning() << LOGFUNCTION << " jobId='" << jobResource.jobId() << "'";
|
|
qWarning() << LOGFUNCTION << " jobStatus='" << (int)jobResource.jobStatus() << "'";
|
|
qWarning() << LOGFUNCTION << " inputParameters().size()='" << (int)jobResource.inputParameters().size() << "'";
|
|
qWarning() << LOGFUNCTION << " outputParameters().size()='" << (int)jobResource.outputParameters().size() << "'";
|
|
qWarning() << LOGFUNCTION << " messages().size()='" << (int)jobResource.messages().size() << "'";
|
|
|
|
qWarning() << LOGFUNCTION << " 2 msgList().size()='" << msgList.size() << "'";
|
|
|
|
m_geoprocessor->jobStatus();
|
|
}
|
|
|
|
void mainwindow::onGpTaskInfoComplete(const EsriRuntimeQt::GPTaskInfo &)
|
|
{
|
|
qWarning() << "\n";
|
|
qWarning() << LOGFUNCTION ;
|
|
}
|
|
|
|
|
|
|
|
|