KJ135
/
RasterProcessTool
mirror of http://172.16.0.12:5000/LAMPSARToolSoftware/RasterProcessTool.git
4
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/RasterShow-dev' into RFPC-dev

pull/14/head
陈增辉 2025-04-29 11:46:33 +08:00
parent 947146320e 05ac1a8013
commit 9b91f722a9
20 changed files with 1413 additions and 1422 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

612
RasterMainWidgetGUI/RasterMainWidget/RasterMainWidget.cpp
View File

@ -20,330 +20,306 @@
namespace LAMPMainWidget { namespace LAMPMainWidget {
QString QHash<QString, MapLayer*>RasterMainWidget::mMaps{};
RasterMainWidget::tutorialUrl() {
return QString{R"(https://gitee.com/qizr_admin/LAMPMainWidget)"};
}
QString RasterMainWidget::RasterMainWidget(QWidget* parent)
RasterMainWidget::srcUrl() { : mUi(new Ui::RasterMainWidget),
return QString{R"(https://gitee.com/qizr_admin/LAMPMainWidget)"}; mMapConvas(new MapCanvas),
} mScaleText(new QLineEdit),
mScaleLabel(new QLabel),
mCenterText(new QLineEdit),
mCenterLabel(new QLabel),
mZoomText(new QLineEdit),
mZoomLabel(new QLabel),
mMapActionGroup(new QActionGroup(dynamic_cast<QObject*>(this))),
mSetLeftTop(true),
mLayerList(),
mLeftTop(),
mRightBottom() {
this->setWindowTitle(tr(u8"LAMP影像处理软件"));
mUi->setupUi(dynamic_cast<QMainWindow*>(this));
setupWindow();
setupTaskWindow();
setupLayers();
setupStatusBar();
setupActions();
setRightToolbox();
QHash<QString, MapLayer *>RasterMainWidget::mMaps{}; mUi->panAction->trigger();
mUi->layerList->setCurrentItem(mLayerList.first());
RasterMainWidget::RasterMainWidget(QWidget *parent)
: mUi(new Ui::RasterMainWidget),
mMapConvas(new MapCanvas),
mScaleText(new QLineEdit),
mScaleLabel(new QLabel),
mCenterText(new QLineEdit),
mCenterLabel(new QLabel),
mZoomText(new QLineEdit),
mZoomLabel(new QLabel),
mMapActionGroup(new QActionGroup(dynamic_cast<QObject *>(this))),
mSetLeftTop(true),
mLayerList(),
mLeftTop(),
mRightBottom() {
this->setWindowTitle(tr(u8"LAMP影像处理软件"));
mUi->setupUi(dynamic_cast<QMainWindow*>(this));
setupWindow();
setupTaskWindow();
setupLayers();
setupStatusBar();
setupActions();
setRightToolbox();
//mUi->panAction->trigger(); this->show();// 强制显示窗口
//mUi->layerList->setCurrentItem(mLayerList.first()); // 绑定消息显示
RasterMessageShow::RasterWidgetMessageShow* messageshow = RasterMessageShow::RasterWidgetMessageShow::getInstance(this);
messageshow->bandingTextBrowserMessage(this->mUi->textBrowserMessage);
}
RasterMainWidget::~RasterMainWidget() {
delete mUi;
delete mMapConvas;
delete mScaleText;
delete mScaleLabel;
delete mCenterText;
delete mCenterLabel;
}
void
RasterMainWidget::setupTaskWindow() {
mUi->taskTable->setColumnCount(5);
mUi->taskTable->setHorizontalHeaderLabels(QStringList{
"名称", "范围", "zoom值", "数据源", "进度"
});
mUi->taskTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
}
void
RasterMainWidget::setupActions() {
mMapActionGroup->addAction(mUi->panAction);
mMapActionGroup->addAction(mUi->zoomInAction);
mMapActionGroup->addAction(mUi->zoomOutAction);
mMapActionGroup->addAction(mUi->selectAction);
mUi->selectAction->setEnabled(false);
QObject::connect(mUi->panAction, &QAction::triggered, this, &RasterMainWidget::panHandle);
QObject::connect(mUi->zoomInAction, &QAction::triggered, this, &RasterMainWidget::zoomInHandle);
QObject::connect(mUi->zoomOutAction, &QAction::triggered, this, &RasterMainWidget::zoomOutHandle);
QObject::connect(mUi->refreshAction, &QAction::triggered, this, &RasterMainWidget::refreshHandle);
QObject::connect(mUi->sponsorAction, &QAction::triggered, this, &RasterMainWidget::sponsorHandle);
QObject::connect(mUi->selectAction, &QAction::triggered, this, &RasterMainWidget::selectHandle);
QObject::connect(mUi->downloadAction, &QAction::triggered, this, &RasterMainWidget::createDownloadTask);
QObject::connect(mUi->drawlineAction, &QAction::triggered, this, &RasterMainWidget::drawlineHandle);
}
void RasterMainWidget::setupWindow() {
mUi->mapCanvasLayout->addWidget(mMapConvas);
//setFixedSize(size());
//setWindowFlags(windowFlags() | Qt::WindowMinMaxButtonsHint | Qt::WindowSystemMenuHint);
QObject::connect(mMapConvas, &MapCanvas::zoomChanged, this, &RasterMainWidget::zoomChangedHandle);
QObject::connect(mMapConvas, &MapCanvas::clicked, this, &RasterMainWidget::clickedHandle);
QObject::connect(mMapConvas, &MapCanvas::mapCenterChanged, this, &RasterMainWidget::centerChangedHandle);
QObject::connect(mUi->layerList, &QListWidget::currentItemChanged, this, &RasterMainWidget::layerChanged);
QObject::connect(mUi->leftTopBtn, &QPushButton::clicked, this, &RasterMainWidget::leftTopClickedHandle);
QObject::connect(mUi->rightBottomBtn, &QPushButton::clicked, this, &RasterMainWidget::rightBottomClickedHandle);
}
void RasterMainWidget::setupStatusBar() {
/// 比例尺
mScaleLabel->setText("比例尺");
mScaleText->setText(QString("1cm : %1m").arg(mMapConvas->scale()));
mScaleText->setFixedWidth(150);
mScaleText->setReadOnly(true);
mUi->statusbar->addWidget(mScaleLabel);
mUi->statusbar->addWidget(mScaleText);
/// 空白间隔
mUi->statusbar->addWidget(spacerWiget(30));
/// zoom值
mZoomLabel->setText("Zoom值=>");
mZoomText->setText(QString("%1").arg(mMapConvas->zoomValue()));
mZoomText->setFixedWidth(80);
mZoomText->setReadOnly(true);
mUi->statusbar->addWidget(mZoomLabel);
mUi->statusbar->addWidget(mZoomText);
/// 空白间隔
mUi->statusbar->addWidget(spacerWiget(30));
/// 视图中心坐标
mCenterLabel->setText("视图中心坐标=>");
PointXY center = mMapConvas->mapCenter();
mCenterText->setText(QString("lon:%1, lat:%2").arg(center.x()).arg(center.y()));
mCenterText->setFixedWidth(300);
mCenterText->setReadOnly(true);
mUi->statusbar->addWidget(mCenterLabel);
mUi->statusbar->addWidget(mCenterText);
}
void RasterMainWidget::setupLayers() {
initMaps();
auto i = mMaps.constBegin();
for (; i != mMaps.constEnd(); ++i) {
mLayerList.append(new QListWidgetItem(i.key(), mUi->layerList));
}
}
void
RasterMainWidget::initMaps() {
if (false&&mMaps.isEmpty()) {
mMaps = QHash<QString, MapLayer*>{
{"Openstreet地图", new TmsLayer(OSTNormalMap, "ostnormalmap", mMapConvas)},
{"高德地图", new TmsLayer(GaodeNormapMap, "gaodenormalmap", mMapConvas)}
};
}
}
void RasterMainWidget::setRightToolbox()
{
this->toolboxDockWidget = new QDockWidget(tr(u8"工具箱"), this);
toolboxDockWidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
toolBoxWidget = new ToolBoxWidget(this);
toolboxDockWidget->setWidget(toolBoxWidget);
addDockWidget(Qt::LeftDockWidgetArea, toolboxDockWidget);
setDockOptions(QMainWindow::AllowNestedDocks | QMainWindow::AllowTabbedDocks);
this->initToolbox();
}
void RasterMainWidget::initToolbox()
{
QString appPath = QCoreApplication::applicationDirPath();
QString pluginPath = JoinPath(appPath, "Toolbox");
toolBoxWidget->initToolbox(pluginPath);
}
QWidget* RasterMainWidget::spacerWiget(int width) const {
auto spacer = new QWidget{};
spacer->setHidden(true);
spacer->setVisible(true);
spacer->setFixedWidth(width);
return spacer;
}
void
RasterMainWidget::panHandle(bool checked) {
mMapConvas->selectTool(QString{ "pan_tool" });
}
void
RasterMainWidget::zoomInHandle(bool checked) {
mMapConvas->selectTool(QString{ "zoomin_tool" });
}
void
RasterMainWidget::zoomOutHandle(bool checked) {
mMapConvas->selectTool(QString{ "zoomout_tool" });
}
void RasterMainWidget::drawlineHandle(bool checked)
{
mMapConvas->selectTool("drawline_tool");
}
void
} RasterMainWidget::sponsorHandle(bool checked) {
auto* window = new SponsorWindow(dynamic_cast<QWidget*>(this));
RasterMainWidget::~RasterMainWidget() { window->exec();
delete mUi; window->deleteLater();
delete mMapConvas; }
delete mScaleText;
delete mScaleLabel; void
delete mCenterText; RasterMainWidget::refreshHandle(bool checked) {
delete mCenterLabel; mMapConvas->refreshMap();
} }
void void
RasterMainWidget::setupTaskWindow() { RasterMainWidget::selectHandle(bool checked) {
mUi->taskTable->setColumnCount(5); mMapConvas->selectTool(QString{ "select_tool" });
mUi->taskTable->setHorizontalHeaderLabels(QStringList{ }
"名称", "范围", "zoom值", "数据源", "进度"
}); void
mUi->taskTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch); RasterMainWidget::centerChangedHandle(LAMPMainWidget::PointXY pos) {
} mCenterText->setText(QString("lon:%1, lat:%2").arg(pos.x()).arg(pos.y()));
}
void
RasterMainWidget::setupActions() { void
mMapActionGroup->addAction(mUi->panAction); RasterMainWidget::zoomChangedHandle(int zoom) {
mMapActionGroup->addAction(mUi->zoomInAction); mZoomText->setText(QString("%1").arg(zoom));
mMapActionGroup->addAction(mUi->zoomOutAction); mScaleText->setText(QString("1cm:%1m").arg(this->mMapConvas->scale()));
mMapActionGroup->addAction(mUi->selectAction); }
mUi->selectAction->setEnabled(false); void
RasterMainWidget::clickedHandle(LAMPMainWidget::PointXY pos) {
QObject::connect(mUi->panAction, &QAction::triggered, this, &RasterMainWidget::panHandle); QString posText = QString("%1, %2").arg(pos.x()).arg(pos.y());
QObject::connect(mUi->zoomInAction, &QAction::triggered, this, &RasterMainWidget::zoomInHandle); if (mSetLeftTop) {
QObject::connect(mUi->zoomOutAction, &QAction::triggered, this, &RasterMainWidget::zoomOutHandle); mUi->leftTopText->setText(posText);
QObject::connect(mUi->tutorialAction, &QAction::triggered, this, &RasterMainWidget::tutorialHanle); mLeftTop = pos;
QObject::connect(mUi->srcAction, &QAction::triggered, this, &RasterMainWidget::srcHandle); }
QObject::connect(mUi->refreshAction, &QAction::triggered, this, &RasterMainWidget::refreshHandle); else {
QObject::connect(mUi->sponsorAction, &QAction::triggered, this, &RasterMainWidget::sponsorHandle); mUi->rightBottomText->setText(posText);
QObject::connect(mUi->selectAction, &QAction::triggered, this, &RasterMainWidget::selectHandle); mRightBottom = pos;
QObject::connect(mUi->downloadAction, &QAction::triggered, this, &RasterMainWidget::createDownloadTask); }
QObject::connect(mUi->drawlineAction, &QAction::triggered, this, &RasterMainWidget::drawlineHandle); }
}
void
void RasterMainWidget::setupWindow() { RasterMainWidget::leftTopClickedHandle() {
mUi->mapCanvasLayout->addWidget(mMapConvas); mSetLeftTop = true;
//setFixedSize(size()); mUi->selectAction->trigger();
//setWindowFlags(windowFlags() | Qt::WindowMinMaxButtonsHint | Qt::WindowSystemMenuHint); }
QObject::connect(mMapConvas, &MapCanvas::zoomChanged, this, &RasterMainWidget::zoomChangedHandle); void
QObject::connect(mMapConvas, &MapCanvas::clicked, this, &RasterMainWidget::clickedHandle); RasterMainWidget::rightBottomClickedHandle() {
QObject::connect(mMapConvas, &MapCanvas::mapCenterChanged, this, &RasterMainWidget::centerChangedHandle); mSetLeftTop = false;
QObject::connect(mUi->layerList, &QListWidget::currentItemChanged, this, &RasterMainWidget::layerChanged); mUi->selectAction->trigger();
QObject::connect(mUi->leftTopBtn, &QPushButton::clicked, this, &RasterMainWidget::leftTopClickedHandle); }
QObject::connect(mUi->rightBottomBtn, &QPushButton::clicked, this, &RasterMainWidget::rightBottomClickedHandle);
void
RasterMainWidget::layerChanged(QListWidgetItem* current, QListWidgetItem* previous) {
RasterMessageShow::RasterWidgetMessageShow* messageshow = RasterMessageShow::RasterWidgetMessageShow::getInstance(this); auto mapName = current->text();
messageshow->bandingTextBrowserMessage(this->mUi->textBrowserMessage); if (!mMaps.contains(mapName)) {
qDebug() << mapName << "不支持";
return;
} }
void RasterMainWidget::setupStatusBar() { auto layer = mMaps.value(mapName);
/// 比例尺 auto i = mMaps.begin();
mScaleLabel->setText("比例尺"); for (; i != mMaps.end(); ++i) {
mScaleText->setText(QString("1cm : %1m").arg(mMapConvas->scale())); if (i.key() == mapName) {
mScaleText->setFixedWidth(150); i.value()->setVisiblity(true);
mScaleText->setReadOnly(true); qDebug() << i.key() << i.value()->isVisible();
mUi->statusbar->addWidget(mScaleLabel); continue;
mUi->statusbar->addWidget(mScaleText); }
/// 空白间隔 i.value()->setVisiblity(false);
mUi->statusbar->addWidget(spacerWiget(30)); }
/// zoom值 mMapConvas->addLayer(layer);
mZoomLabel->setText("Zoom值=>"); mMapConvas->setCurrentLayer(layer->id());
mZoomText->setText(QString("%1").arg(mMapConvas->zoomValue())); mMapConvas->refreshMap();
mZoomText->setFixedWidth(80);
mZoomText->setReadOnly(true); zoomChangedHandle(mMapConvas->zoomValue());
mUi->statusbar->addWidget(mZoomLabel); centerChangedHandle(mMapConvas->mapCenter());
mUi->statusbar->addWidget(mZoomText); }
/// 空白间隔 void
mUi->statusbar->addWidget(spacerWiget(30)); RasterMainWidget::createDownloadTask() {
auto taskWindow = new TaskWindow(dynamic_cast<QWidget*>(this));
/// 视图中心坐标 taskWindow->exec();
mCenterLabel->setText("视图中心坐标=>"); taskWindow->deleteLater();
PointXY center = mMapConvas->mapCenter(); }
mCenterText->setText(QString("lon:%1, lat:%2").arg(center.x()).arg(center.y()));
mCenterText->setFixedWidth(300); void
mCenterText->setReadOnly(true); RasterMainWidget::changeTaskTable(int row, int col, QString text) {
mUi->statusbar->addWidget(mCenterLabel); mUi->taskTable->takeItem(row, col);
mUi->statusbar->addWidget(mCenterText); mUi->taskTable->setItem(row, col, new QTableWidgetItem(text));
} }
void RasterMainWidget::setupLayers() {
initMaps(); void RasterMainWidget::on_drawArea_triggered()
auto i = mMaps.constBegin(); {
for (; i != mMaps.constEnd(); ++i) { mMapConvas->selectTool("drawarea_tool");
mLayerList.append(new QListWidgetItem(i.key(), mUi->layerList)); }
}
}
void RasterMainWidget::on_addPlaneaction_triggered()
void {
RasterMainWidget::initMaps() { mMapConvas->selectTool("addplane_tool");
if (mMaps.isEmpty()) { }
mMaps = QHash<QString, MapLayer *>{
{"Openstreet地图", new TmsLayer(OSTNormalMap, "ostnormalmap", mMapConvas)}, QTableWidget* RasterMainWidget::getTaskTable()
{"高德地图", new TmsLayer(GaodeNormapMap, "gaodenormalmap", mMapConvas)} {
}; return this->mUi->taskTable;
} }
}
void RasterMainWidget::setRightToolbox()
{
this->toolboxDockWidget = new QDockWidget(tr(u8"工具箱"), this);
toolboxDockWidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
toolBoxWidget = new ToolBoxWidget(this);
toolboxDockWidget->setWidget(toolBoxWidget);
addDockWidget(Qt::LeftDockWidgetArea, toolboxDockWidget);
setDockOptions(QMainWindow::AllowNestedDocks | QMainWindow::AllowTabbedDocks);
this->initToolbox();
}
void RasterMainWidget::initToolbox()
{
QString appPath = QCoreApplication::applicationDirPath();
QString pluginPath = JoinPath(appPath, "Toolbox");
toolBoxWidget->initToolbox(pluginPath);
}
QWidget *RasterMainWidget::spacerWiget(int width) const {
auto spacer = new QWidget{};
spacer->setHidden(true);
spacer->setVisible(true);
spacer->setFixedWidth(width);
return spacer;
}
void
RasterMainWidget::panHandle(bool checked) {
mMapConvas->selectTool(QString{"pan_tool"});
}
void
RasterMainWidget::zoomInHandle(bool checked) {
mMapConvas->selectTool(QString{"zoomin_tool"});
}
void
RasterMainWidget::zoomOutHandle(bool checked) {
mMapConvas->selectTool(QString{"zoomout_tool"});
}
void RasterMainWidget::drawlineHandle(bool checked)
{
mMapConvas->selectTool("drawline_tool");
}
void
RasterMainWidget::tutorialHanle(bool checked) {
if (!QDesktopServices::openUrl(tutorialUrl())) {
QMessageBox::critical(dynamic_cast<QWidget *>(this), "异常", "未能打开系统浏览器");
}
}
void
RasterMainWidget::srcHandle(bool checked) {
if (!QDesktopServices::openUrl(srcUrl())) {
QMessageBox::critical(dynamic_cast<QWidget *>(this), "异常", "未能打开系统浏览器");
}
}
void
RasterMainWidget::sponsorHandle(bool checked) {
auto *window = new SponsorWindow(dynamic_cast<QWidget *>(this));
window->exec();
window->deleteLater();
}
void
RasterMainWidget::refreshHandle(bool checked) {
mMapConvas->refreshMap();
}
void
RasterMainWidget::selectHandle(bool checked) {
mMapConvas->selectTool(QString{"select_tool"});
}
void
RasterMainWidget::centerChangedHandle(LAMPMainWidget::PointXY pos) {
mCenterText->setText(QString("lon:%1, lat:%2").arg(pos.x()).arg(pos.y()));
}
void
RasterMainWidget::zoomChangedHandle(int zoom) {
mZoomText->setText(QString("%1").arg(zoom));
mScaleText->setText(QString("1cm:%1m").arg(this->mMapConvas->scale()));
}
void
RasterMainWidget::clickedHandle(LAMPMainWidget::PointXY pos) {
QString posText = QString("%1, %2").arg(pos.x()).arg(pos.y());
if (mSetLeftTop) {
mUi->leftTopText->setText(posText);
mLeftTop = pos;
} else {
mUi->rightBottomText->setText(posText);
mRightBottom = pos;
}
}
void
RasterMainWidget::leftTopClickedHandle() {
mSetLeftTop = true;
mUi->selectAction->trigger();
}
void
RasterMainWidget::rightBottomClickedHandle() {
mSetLeftTop = false;
mUi->selectAction->trigger();
}
void
RasterMainWidget::layerChanged(QListWidgetItem *current, QListWidgetItem *previous) {
auto mapName = current->text();
if (!mMaps.contains(mapName)) {
qDebug() << mapName << "不支持";
return;
}
auto layer = mMaps.value(mapName);
auto i = mMaps.begin();
for (; i != mMaps.end(); ++i) {
if (i.key() == mapName) {
i.value()->setVisiblity(true);
qDebug() << i.key() << i.value()->isVisible();
continue;
}
i.value()->setVisiblity(false);
}
mMapConvas->addLayer(layer);
mMapConvas->setCurrentLayer(layer->id());
mMapConvas->refreshMap();
zoomChangedHandle(mMapConvas->zoomValue());
centerChangedHandle(mMapConvas->mapCenter());
}
void
RasterMainWidget::createDownloadTask() {
auto taskWindow = new TaskWindow(dynamic_cast<QWidget *>(this));
taskWindow->exec();
taskWindow->deleteLater();
}
void
RasterMainWidget::changeTaskTable(int row, int col, QString text) {
mUi->taskTable->takeItem(row, col);
mUi->taskTable->setItem(row, col, new QTableWidgetItem(text));
}
void RasterMainWidget::on_drawArea_triggered()
{
mMapConvas->selectTool("drawarea_tool");
}
void RasterMainWidget::on_addPlaneaction_triggered()
{
mMapConvas->selectTool("addplane_tool");
}
QTableWidget* RasterMainWidget::getTaskTable()
{
return this->mUi->taskTable;
}
} }

7
RasterMainWidgetGUI/RasterMainWidget/RasterMainWidget.h
View File

@ -52,8 +52,7 @@ namespace LAMPMainWidget {
void zoomInHandle(bool checked); void zoomInHandle(bool checked);
void zoomOutHandle(bool checked); void zoomOutHandle(bool checked);
void drawlineHandle(bool checked); void drawlineHandle(bool checked);
void tutorialHanle(bool checked);
void srcHandle(bool checked);
void sponsorHandle(bool checked); void sponsorHandle(bool checked);
void refreshHandle(bool checked); void refreshHandle(bool checked);
void selectHandle(bool checked); void selectHandle(bool checked);
@ -70,10 +69,6 @@ namespace LAMPMainWidget {
private: private:
QWidget* spacerWiget(int width) const; QWidget* spacerWiget(int width) const;
protected:
static QString tutorialUrl();
static QString srcUrl();
private slots: private slots:
void on_drawArea_triggered(); void on_drawArea_triggered();
void on_addPlaneaction_triggered(); void on_addPlaneaction_triggered();

10
RasterMainWidgetGUI/RasterMainWidget/RasterMainWidget.ui
View File

@ -12,8 +12,8 @@
<rect> <rect>
<x>0</x> <x>0</x>
<y>0</y> <y>0</y>
<width>906</width> <width>898</width>
<height>609</height> <height>580</height>
</rect> </rect>
</property> </property>
<property name="sizePolicy"> <property name="sizePolicy">
@ -84,8 +84,8 @@
<rect> <rect>
<x>0</x> <x>0</x>
<y>0</y> <y>0</y>
<width>906</width> <width>898</width>
<height>23</height> <height>22</height>
</rect> </rect>
</property> </property>
<widget class="QMenu" name="projectMenu"> <widget class="QMenu" name="projectMenu">
@ -122,8 +122,6 @@
<property name="title"> <property name="title">
<string>帮助</string> <string>帮助</string>
</property> </property>
<addaction name="tutorialAction"/>
<addaction name="srcAction"/>
<addaction name="separator"/> <addaction name="separator"/>
</widget> </widget>
<addaction name="projectMenu"/> <addaction name="projectMenu"/>

21
RasterMainWidgetGUI/RasterMainWidget/gaodenormalprovider.cpp
View File

@ -4,17 +4,18 @@
namespace LAMPMainWidget { namespace LAMPMainWidget {
GaodeNormalProvider::GaodeNormalProvider(QObject *parent) GaodeNormalProvider::GaodeNormalProvider(QObject* parent)
: TmsProvider(parent) { : TmsProvider(parent) {
initCache(); initCache();
} }
QString QString
GaodeNormalProvider::tileUrl(const LAMPMainWidget::PointXY &pos, int zoom) const { GaodeNormalProvider::tileUrl(const LAMPMainWidget::PointXY& pos, int zoom) const {
QString urlFmt = {R"(http://wprd01.is.autonavi.com/appmaptile?style=6&x=%1&y=%2&z=%3)"};
return QString(urlFmt).arg(pos.x()).arg(pos.y()).arg(zoom); QString urlFmt = { R"(http://wprd01.is.autonavi.com/appmaptile?style=6&x=%1&y=%2&z=%3)" };
} return QString(urlFmt).arg(pos.x()).arg(pos.y()).arg(zoom);
//http://wprd01.is.autonavi.com/appmaptile?x={x}&y={y}&z={z}&lang=zh_cn&size=1&scl=1&style=6 }
//http://wprd01.is.autonavi.com/appmaptile?x={x}&y={y}&z={z}&lang=zh_cn&size=1&scl=1&style=6
} }

483
RasterMainWidgetGUI/RasterMainWidget/mapcanvas.cpp
View File

@ -15,287 +15,292 @@
namespace LAMPMainWidget { namespace LAMPMainWidget {
PointXY PointXY
MapCanvas::defaultMapCenter() { MapCanvas::defaultMapCenter() {
return PointXY{116.4074, 39.9042}; return PointXY{ 116.4074, 39.9042 };
} }
MapCanvas::MapCanvas(QWidget *parent) MapCanvas::MapCanvas(QWidget* parent)
: QGraphicsView(parent), : QGraphicsView(parent),
mScene(nullptr), mScene(nullptr),
mMapExtent(), mMapExtent(),
mViewExtent(), mViewExtent(),
mDragRect(), mDragRect(),
mIsDragging(false), mIsDragging(false),
mLayers(), mLayers(),
mCurrentLayer(nullptr), mCurrentLayer(nullptr),
mCrs(nullptr), mCrs(nullptr),
mMapCenter(defaultMapCenter()), mMapCenter(defaultMapCenter()),
mZoomValue(kDefaultZoomValue), mZoomValue(kDefaultZoomValue),
mLastXY(), mLastXY(),
mMapUpdateTimer(nullptr), mMapUpdateTimer(nullptr),
mCurrentTool(nullptr), mCurrentTool(nullptr),
mMapTools() { mMapTools() {
setAutoFillBackground(true);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setMouseTracking(true);
setFocusPolicy(Qt::StrongFocus);
mScene = new QGraphicsScene();
setScene(mScene);
mMapUpdateTimer = new QTimer();
QObject::connect(mMapUpdateTimer, &QTimer::timeout, [this]() {
this->mScene->update();
});
mMapUpdateTimer->start(200);
setupTools();
this->startTimer(1000);
}
MapCanvas::~MapCanvas() { setAutoFillBackground(true);
mLayers.clear(); setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
delete mScene; setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
delete mCurrentLayer; setMouseTracking(true);
delete mMapUpdateTimer; setFocusPolicy(Qt::StrongFocus);
} mScene = new QGraphicsScene();
setScene(mScene);
mMapUpdateTimer = new QTimer();
QObject::connect(mMapUpdateTimer, &QTimer::timeout, [this]() {
this->mScene->update();
});
mMapUpdateTimer->start(200);
setupTools();
this->startTimer(1000);
}
void MapCanvas::~MapCanvas() {
MapCanvas::mousePressEvent(QMouseEvent *event) { mLayers.clear();
if (mCurrentTool) { delete mScene;
mCurrentTool->execute(event); delete mCurrentLayer;
} delete mMapUpdateTimer;
QGraphicsView::mousePressEvent(event); }
}
void void
MapCanvas::mouseReleaseEvent(QMouseEvent *event) { MapCanvas::mousePressEvent(QMouseEvent* event) {
if (mCurrentTool) { if (mCurrentTool) {
mCurrentTool->execute(event); mCurrentTool->execute(event);
} }
QGraphicsView::mouseReleaseEvent(event); QGraphicsView::mousePressEvent(event);
} }
void void
MapCanvas::wheelEvent(QWheelEvent *event) { MapCanvas::mouseReleaseEvent(QMouseEvent* event) {
int delta = event->angleDelta().y() / 120; if (mCurrentTool) {
int zoom = zoomValue(); mCurrentTool->execute(event);
zoom += delta; }
setZoomValue(zoom); QGraphicsView::mouseReleaseEvent(event);
} }
void void
MapCanvas::resizeEvent(QResizeEvent *event) { MapCanvas::wheelEvent(QWheelEvent* event) {
updateViewExtent(true); int delta = event->angleDelta().y() / 120;
} int zoom = zoomValue();
zoom += delta;
setZoomValue(zoom);
}
void MapCanvas::mouseMoveEvent(QMouseEvent *event) void
{ MapCanvas::resizeEvent(QResizeEvent* event) {
if (mCurrentTool) { updateViewExtent(true);
mCurrentTool->execute(event); }
}
QGraphicsView::mouseMoveEvent(event);
}
void void MapCanvas::mouseMoveEvent(QMouseEvent* event)
MapCanvas::refreshMap() { {
QMapIterator<QString, MapLayer *> iterator(mLayers); if (mCurrentTool) {
while (iterator.hasNext()) { mCurrentTool->execute(event);
iterator.next(); }
iterator.value()->map()->setViewExtent(mViewExtent); QGraphicsView::mouseMoveEvent(event);
iterator.value()->update(); }
}
mScene->update();
}
void void
MapCanvas::addLayer(MapLayer *const layer) { MapCanvas::refreshMap() {
if (!layer) QMapIterator<QString, MapLayer*> iterator(mLayers);
return; while (iterator.hasNext()) {
iterator.next();
iterator.value()->map()->setViewExtent(mViewExtent);
iterator.value()->update();
}
mScene->update();
}
if (mLayers.contains(layer->id())) { void
qWarning() << layer->id() << "图层已存在"; MapCanvas::addLayer(MapLayer* const layer) {
return; if (!layer)
} return;
mLayers.insert(layer->id(), layer); if (mLayers.contains(layer->id())) {
if (mLayers.count() == 1) { qWarning() << layer->id() << "图层已存在";
setCurrentLayer(layer->id()); return;
} }
mScene->addItem(layer->map());
refreshMap();
}
void mLayers.insert(layer->id(), layer);
MapCanvas::setZoomValue(const int zoom) { if (mLayers.count() == 1) {
mZoomValue = normalizeZoom(zoom); setCurrentLayer(layer->id());
zoomChanged(mZoomValue); }
mScene->addItem(layer->map());
refreshMap();
}
/// 更新每个图层的zoom值 void
QMapIterator<QString, MapLayer *> iterator(mLayers); MapCanvas::setZoomValue(const int zoom) {
while (iterator.hasNext()) { mZoomValue = normalizeZoom(zoom);
iterator.next(); zoomChanged(mZoomValue);
iterator.value()->setZoomValue(mZoomValue);
}
/// 更新可视区域的内容 /// 更新每个图层的zoom值
updateViewExtent(true); QMapIterator<QString, MapLayer*> iterator(mLayers);
} while (iterator.hasNext()) {
iterator.next();
iterator.value()->setZoomValue(mZoomValue);
}
void /// 更新可视区域的内容
MapCanvas::updateViewExtent(bool reset) { updateViewExtent(true);
if (!mCurrentLayer) { }
qDebug() << "未设置当前图层，视图区域无法更新";
return;
}
if (reset) { void
/// 重置视图区域 MapCanvas::updateViewExtent(bool reset) {
mScene->setSceneRect(mCurrentLayer->extent()); if (!mCurrentLayer) {
QRectF testrect=mCurrentLayer->extent(); qDebug() << "未设置当前图层，视图区域无法更新";
mViewExtent.setRect(0, 0, 0, 0); return;
mViewExtent.setSize(size()); }
PointXY crsCenter = mCrs->forward(mMapCenter);
QPointF mapCenter{crsCenter.x() / resolution(), crsCenter.y() / resolution()};
QPointF offset = mapCenter - mViewExtent.center();
mViewExtent.translate(offset.x(), offset.y());
} else {
/// 视图偏移并重置偏移属性
mViewExtent.translate(-mDragRect.width(), -mDragRect.height());
mDragRect.setRect(0, 0, 0, 0);
/// 更新地图可视区域中心点 if (reset) {
QPointF mapCenter = mViewExtent.center(); /// 重置视图区域
PointXY crsCenter{mapCenter.x() * resolution(), mapCenter.y() * resolution()}; mScene->setSceneRect(mCurrentLayer->extent());
mMapCenter = mCrs->inverse(crsCenter); QRectF testrect = mCurrentLayer->extent();
mapCenterChanged(mMapCenter); mViewExtent.setRect(0, 0, 0, 0);
} mViewExtent.setSize(size());
PointXY crsCenter = mCrs->forward(mMapCenter);
QPointF mapCenter{ crsCenter.x() / resolution(), crsCenter.y() / resolution() };
QPointF offset = mapCenter - mViewExtent.center();
mViewExtent.translate(offset.x(), offset.y());
}
else {
qDebug() << "视图区域更新 平移范围 x ,y "<<-mDragRect.width()<<" , "<<-mDragRect.height() ;
/// 视图偏移并重置偏移属性
mViewExtent.translate(-mDragRect.width(), -mDragRect.height());
mDragRect.setRect(0, 0, 0, 0);
/// 刷新地图 /// 更新地图可视区域中心点
centerOn(mViewExtent.center()); QPointF mapCenter = mViewExtent.center();
refreshMap(); PointXY crsCenter{ mapCenter.x() * resolution(), mapCenter.y() * resolution() };
} mMapCenter = mCrs->inverse(crsCenter);
mapCenterChanged(mMapCenter);
}
void /// 刷新地图
MapCanvas::setCrs(const CRS *const crs) { centerOn(mViewExtent.center());
mCrs = crs; refreshMap();
crsChanged(); }
updateViewExtent(true);
}
void void
MapCanvas::setCurrentLayer(const QString &id) { MapCanvas::setCrs(const CRS* const crs) {
if (!mLayers.contains(id)) { mCrs = crs;
qWarning() << "未添加图层=>" << id; crsChanged();
return; updateViewExtent(true);
} }
mCurrentLayer = mLayers[id];
if (!mCrs) {
setCrs(&mCurrentLayer->crs());
}
updateViewExtent(true);
}
double void
MapCanvas::scale() const { MapCanvas::setCurrentLayer(const QString& id) {
return logicalDpiX() * resolution() * 39.37 / 100;; if (!mLayers.contains(id)) {
} qWarning() << "未添加图层=>" << id;
return;
}
mCurrentLayer = mLayers[id];
if (!mCrs) {
setCrs(&mCurrentLayer->crs());
}
updateViewExtent(true);
}
double double
MapCanvas::resolution() const { MapCanvas::scale() const {
if (!mCurrentLayer) { return logicalDpiX() * resolution() * 39.37 / 100;;
qWarning() << "未设置当前图层，无法获取分辨率"; }
return 0;
}
return mCurrentLayer->resolution(); double
} MapCanvas::resolution() const {
if (!mCurrentLayer) {
qWarning() << "未设置当前图层，无法获取分辨率";
return 0;
}
int return mCurrentLayer->resolution();
MapCanvas::zoomValue() const { }
if (!mCurrentLayer) {
qWarning() << "未设置当前图层，默认返回zoom值为0";
return 0;
}
return mCurrentLayer->zoomValue(); int
} MapCanvas::zoomValue() const {
if (!mCurrentLayer) {
qWarning() << "未设置当前图层，默认返回zoom值为0";
return 0;
}
int return mCurrentLayer->zoomValue();
MapCanvas::normalizeZoom(const int zoom) const { }
int z{};
if (zoom <= kMinZoomValue) {
z = kMinZoomValue;
} else if (z >= kMaxZoomValue) {
z = kMaxZoomValue;
} else {
z = zoom;
}
return z; int
} MapCanvas::normalizeZoom(const int zoom) const {
int z{};
if (zoom <= kMinZoomValue) {
z = kMinZoomValue;
}
else if (z >= kMaxZoomValue) {
z = kMaxZoomValue;
}
else {
z = zoom;
}
PointXY return z;
MapCanvas::pixel2Lonlat(const QPointF &point) const { }
QPointF scenePoint = mapToScene(QPoint{static_cast<int>(point.x()), static_cast<int>(point.y())});
QPointF mapPoint{scenePoint.x() * resolution(), scenePoint.y() * resolution()};
PointXY crsPoint = mCrs->inverse(PointXY{mapPoint});
qDebug() << "坐标装换=>{" << point << "=>" << crsPoint << "}";
return crsPoint;
}
bool PointXY
MapCanvas::selectTool(const QString &tool) { MapCanvas::pixel2Lonlat(const QPointF& point) const {
if (!mMapTools.contains(tool)) { QPointF scenePoint = mapToScene(QPoint{ static_cast<int>(point.x()), static_cast<int>(point.y()) });
qWarning() << QString("%1工具不存在").arg(tool); QPointF mapPoint{ scenePoint.x() * resolution(), scenePoint.y() * resolution() };
return false; PointXY crsPoint = mCrs->inverse(PointXY{ mapPoint });
} qDebug() << "坐标装换=>{" << point << "=>" << crsPoint << "}";
return crsPoint;
}
auto toolPtr = mMapTools.value(tool); bool
if (mCurrentTool) { MapCanvas::selectTool(const QString& tool) {
mCurrentTool->deSetup(); if (!mMapTools.contains(tool)) {
} qWarning() << QString("%1工具不存在").arg(tool);
mCurrentTool = toolPtr; return false;
toolPtr->setup(); }
return true; auto toolPtr = mMapTools.value(tool);
} if (mCurrentTool) {
mCurrentTool->deSetup();
}
mCurrentTool = toolPtr;
toolPtr->setup();
void MapCanvas::timerEvent(QTimerEvent *event) return true;
{ }
MapToolAddplane *maptoolAddplane=dynamic_cast<MapToolAddplane*>(mMapTools["addplane_tool"]);
QList<MapAutoplane*> planes=maptoolAddplane->getPlanes();
foreach(MapAutoplane *plane,planes){
plane->updatePos();
}
}
void void MapCanvas::timerEvent(QTimerEvent* event)
MapCanvas::setupTools() { {
auto panTool = new MapToolPan(this); MapToolAddplane* maptoolAddplane = dynamic_cast<MapToolAddplane*>(mMapTools["addplane_tool"]);
mMapTools.insert(panTool->id(), panTool); QList<MapAutoplane*> planes = maptoolAddplane->getPlanes();
foreach(MapAutoplane * plane, planes) {
plane->updatePos();
}
}
auto zoominTool = new MapToolZoomIn(this); void
mMapTools.insert(zoominTool->id(), zoominTool); MapCanvas::setupTools() {
auto panTool = new MapToolPan(this);
mMapTools.insert(panTool->id(), panTool);
auto zoomoutTool = new MapToolZoomOut(this); auto zoominTool = new MapToolZoomIn(this);
mMapTools.insert(zoomoutTool->id(), zoomoutTool); mMapTools.insert(zoominTool->id(), zoominTool);
auto selectTool = new MapToolSelect(this); auto zoomoutTool = new MapToolZoomOut(this);
mMapTools.insert(selectTool->id(), selectTool); mMapTools.insert(zoomoutTool->id(), zoomoutTool);
auto drawlineTool=new MapToolDrawline(this); auto selectTool = new MapToolSelect(this);
mMapTools.insert(drawlineTool->id(),drawlineTool); mMapTools.insert(selectTool->id(), selectTool);
auto drawareTool=new MapToolDrawarea(this); auto drawlineTool = new MapToolDrawline(this);
mMapTools.insert(drawareTool->id(),drawareTool); mMapTools.insert(drawlineTool->id(), drawlineTool);
auto addplaneTool=new MapToolAddplane(this); auto drawareTool = new MapToolDrawarea(this);
mMapTools.insert(addplaneTool->id(),addplaneTool); mMapTools.insert(drawareTool->id(), drawareTool);
auto addplaneTool = new MapToolAddplane(this);
mMapTools.insert(addplaneTool->id(), addplaneTool);
} }
} }

279
RasterMainWidgetGUI/RasterMainWidget/mapcanvas.h
View File

@ -20,170 +20,171 @@
#include <maptool.h> #include <maptool.h>
namespace LAMPMainWidget { namespace LAMPMainWidget {
class MapLayer; class MapLayer;
class MapTool; class MapTool;
/** /**
* 地图容器类，继承自QGraphicsView。 * 地图容器类，继承自QGraphicsView。
* 整个地图的渲染都是基于“Qt GraphicsView Framework”设计。 * 整个地图的渲染都是基于“Qt GraphicsView Framework”设计。
*/ */
class MapCanvas : public QGraphicsView { class MapCanvas : public QGraphicsView {
Q_OBJECT Q_OBJECT
signals: signals:
void zoomChanged(int zoom); void zoomChanged(int zoom);
void crsChanged(); void crsChanged();
void clicked(PointXY pos); void clicked(PointXY pos);
void mapCenterChanged(PointXY pos); void mapCenterChanged(PointXY pos);
friend class MapToolPan; friend class MapToolPan;
friend class MapToolZoomIn; friend class MapToolZoomIn;
friend class MapToolZoomOut; friend class MapToolZoomOut;
friend class MapToolSelect; friend class MapToolSelect;
public: public:
explicit MapCanvas(QWidget *parent = nullptr); explicit MapCanvas(QWidget* parent = nullptr);
~MapCanvas() override; ~MapCanvas() override;
public: public:
/** /**
* 刷新地图容器，这会更新每一个显示的图层的内容 * 刷新地图容器，这会更新每一个显示的图层的内容
*/ */
void refreshMap(); void refreshMap();
/** /**
* 向容器中添加图层，默认情况下容器会使用首个图层的坐标系作为自身的坐标系 * 向容器中添加图层，默认情况下容器会使用首个图层的坐标系作为自身的坐标系
* @param layer 图层对象 * @param layer 图层对象
*/ */
void addLayer(MapLayer *layer); void addLayer(MapLayer* layer);
/** /**
* 获取地图容器的比例尺 * 获取地图容器的比例尺
* @return 容器的比例尺 * @return 容器的比例尺
*/ */
double scale() const; double scale() const;
/** /**
* 获取地图容器的解析度 * 获取地图容器的解析度
* @return * @return
*/ */
double resolution() const; double resolution() const;
/** /**
* 获取容器的zoom值 * 获取容器的zoom值
* @return 容器的zoom值 * @return 容器的zoom值
*/ */
int zoomValue() const; int zoomValue() const;
/** /**
* 设置容器的zoom值 * 设置容器的zoom值
* @param zoom zoom值 * @param zoom zoom值
*/ */
void setZoomValue(int zoom); void setZoomValue(int zoom);
/** /**
* 获取容器当前所显示的地图区域 * 获取容器当前所显示的地图区域
* @return 当前所显示地图区域 * @return 当前所显示地图区域
*/ */
const QRectF &viewExtent() const { return mViewExtent; } const QRectF& viewExtent() const { return mViewExtent; }
/** /**
* 设置容器坐标系，设置过后会更新所有图层坐标系。 * 设置容器坐标系，设置过后会更新所有图层坐标系。
* 默认会对容器中的图层做投影变换处理 * 默认会对容器中的图层做投影变换处理
* @param crs 坐标系 * @param crs 坐标系
*/ */
void setCrs(const CRS *crs); void setCrs(const CRS* crs);
/** /**
* 获取地图容器的坐标系 * 获取地图容器的坐标系
* @return 地图容器坐标系 * @return 地图容器坐标系
*/ */
const CRS &crs() const { return *mCrs; } const CRS& crs() const { return *mCrs; }
/** /**
* 设置地图容器的当前选中图层 * 设置地图容器的当前选中图层
* @param id 图层的id * @param id 图层的id
*/ */
void setCurrentLayer(const QString &id); void setCurrentLayer(const QString& id);
/** /**
* 获取地图容器当前选中图层 * 获取地图容器当前选中图层
* @return 当前选中图层 * @return 当前选中图层
*/ */
const MapLayer *currentLayer() { return mCurrentLayer; } const MapLayer* currentLayer() { return mCurrentLayer; }
/** /**
* 获取地图当前视图中心点经纬度坐标 * 获取地图当前视图中心点经纬度坐标
* @return 视图中心点经纬度坐标 * @return 视图中心点经纬度坐标
*/ */
const PointXY &mapCenter() const { return mMapCenter; } const PointXY& mapCenter() const { return mMapCenter; }
/** /**
* 选择地图工具 * 选择地图工具
* @param tool 工具名称 * @param tool 工具名称
* @return 是否选择成功 * @return 是否选择成功
*/ */
bool selectTool(const QString &tool); bool selectTool(const QString& tool);
void timerEvent(QTimerEvent *event); void timerEvent(QTimerEvent* event);
protected: protected:
/** /**
* 更新容器的可视化区域。 * 更新容器的可视化区域。
* 每次拖动操作和resize事件会调用该方法 * 每次拖动操作和resize事件会调用该方法
*/ */
void updateViewExtent(bool reset = false); void updateViewExtent(bool reset = false);
/** /**
* 将屏幕坐标转换为经纬度坐标 * 将屏幕坐标转换为经纬度坐标
* @param point 屏幕上点 * @param point 屏幕上点
* @return 经纬度坐标 * @return 经纬度坐标
*/ */
PointXY pixel2Lonlat(const QPointF &point) const; PointXY pixel2Lonlat(const QPointF& point) const;
/** /**
* 初始设置地图必须具备的工具 * 初始设置地图必须具备的工具
*/ */
void setupTools(); void setupTools();
private: private:
/** /**
* 确保zoom值在限定的范围之内 * 确保zoom值在限定的范围之内
* @param zoom 待设置zoom值 * @param zoom 待设置zoom值
* @return 可使用zoom值 * @return 可使用zoom值
*/ */
int normalizeZoom(int zoom) const; int normalizeZoom(int zoom) const;
protected: protected:
void mousePressEvent(QMouseEvent *event) override; void mousePressEvent(QMouseEvent* event) override;
void mouseReleaseEvent(QMouseEvent *event) override; void mouseReleaseEvent(QMouseEvent* event) override;
void wheelEvent(QWheelEvent *event) override; void wheelEvent(QWheelEvent* event) override;
void resizeEvent(QResizeEvent *event) override; void resizeEvent(QResizeEvent* event) override;
void mouseMoveEvent(QMouseEvent *event) override; void mouseMoveEvent(QMouseEvent* event) override;
protected: protected:
QGraphicsScene *mScene; QGraphicsScene* mScene;
QRectF mMapExtent; QRectF mMapExtent;
QRectF mViewExtent; QRectF mViewExtent;
QRectF mDragRect; QRectF mDragRect;
bool mIsDragging; bool mIsDragging;
QMap<QString, MapLayer *> mLayers; QMap<QString, MapLayer*> mLayers;
MapLayer *mCurrentLayer; MapLayer* mCurrentLayer;
const CRS *mCrs; const CRS* mCrs;
PointXY mMapCenter; PointXY mMapCenter;
int mZoomValue; int mZoomValue;
PointXY mLastXY; PointXY mLastXY;
QTimer *mMapUpdateTimer; QTimer* mMapUpdateTimer;
MapTool *mCurrentTool; MapTool* mCurrentTool;
QHash<QString, MapTool *> mMapTools; QHash<QString, MapTool*> mMapTools;
private: private:
const static int kDefaultZoomValue{8}; const static int kDefaultZoomValue{ 8 };
static const int kMaxZoomValue{20}; static const int kMaxZoomValue{ 20 };
static const int kMinZoomValue{1}; static const int kMinZoomValue{ 1 };
protected: protected:
static PointXY defaultMapCenter(); // 设置默认地图中心点
}; static PointXY defaultMapCenter();
};
} }

40
RasterMainWidgetGUI/RasterMainWidget/mapcanvasmap.cpp
View File

@ -10,28 +10,28 @@
namespace LAMPMainWidget { namespace LAMPMainWidget {
void void
MapCanvasMap::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { MapCanvasMap::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) {
if (!mLayer->provider().hasContent()) { if (!mLayer->provider().hasContent()) {
return; return;
} }
painter->drawImage(mViewExtent.topLeft(), mLayer->provider().preparedImage()); painter->drawImage(mViewExtent.topLeft(), mLayer->provider().preparedImage());
} }
QRectF QRectF
MapCanvasMap::boundingRect() const { MapCanvasMap::boundingRect() const {
auto width = mViewExtent.size().width(); auto width = mViewExtent.size().width();
auto height = mViewExtent.size().height(); auto height = mViewExtent.size().height();
return mViewExtent + QMarginsF(1024, 1024, 1024, 1024); return mViewExtent + QMarginsF(1024, 1024, 1024, 1024);
} }
void MapCanvasMap::setViewExtent(const QRectF &rect) { void MapCanvasMap::setViewExtent(const QRectF& rect) {
//qDebug() << "更新图层显示对象边界=>" << rect; //qDebug() << "更新图层显示对象边界=>" << rect;
if (rect != mViewExtent) { if (rect != mViewExtent) {
prepareGeometryChange(); prepareGeometryChange();
mViewExtent = rect; mViewExtent = rect;
} }
} }
} }

156
RasterMainWidgetGUI/RasterMainWidget/maplayer.cpp
View File

@ -7,84 +7,84 @@
namespace LAMPMainWidget { namespace LAMPMainWidget {
MapLayer::MapLayer( MapLayer::MapLayer(
const QString &id, const QString& id,
LAMPMainWidget::CRS *crs, LAMPMainWidget::CRS* crs,
LAMPMainWidget::MapCanvas *mapCanvas) LAMPMainWidget::MapCanvas* mapCanvas)
: mId(id), : mId(id),
mCrs(crs), mCrs(crs),
mZValue(-1), mZValue(-1),
mZoomValue(kDefaultZoomValue), mZoomValue(kDefaultZoomValue),
mProvider(nullptr), mProvider(nullptr),
mMapCanvasMap(new MapCanvasMap(this)), mMapCanvasMap(new MapCanvasMap(this)),
mMapCanvas(mapCanvas) { mMapCanvas(mapCanvas) {
} }
MapLayer::~MapLayer() { MapLayer::~MapLayer() {
delete mCrs; delete mCrs;
delete mProvider; delete mProvider;
} }
MapLayer::MapLayer(const MapLayer &other) { MapLayer::MapLayer(const MapLayer& other) {
mId = other.mId; mId = other.mId;
mZValue = other.mZValue; mZValue = other.mZValue;
mCrs = other.mCrs; mCrs = other.mCrs;
mMapCanvas = other.mMapCanvas; mMapCanvas = other.mMapCanvas;
} }
MapLayer::MapLayer(MapLayer &&other) noexcept { MapLayer::MapLayer(MapLayer&& other) noexcept {
mId = other.mId; mId = other.mId;
mZValue = other.mZValue; mZValue = other.mZValue;
mCrs = other.mCrs; mCrs = other.mCrs;
mMapCanvas = other.mMapCanvas; mMapCanvas = other.mMapCanvas;
other.mId = QString{}; other.mId = QString{};
other.mCrs = nullptr; other.mCrs = nullptr;
other.mZValue = 0; other.mZValue = 0;
other.mMapCanvas = nullptr; other.mMapCanvas = nullptr;
} }
MapLayer & MapLayer&
MapLayer::operator=(const MapLayer &other) { MapLayer::operator=(const MapLayer& other) {
if (this != &other) { if (this != &other) {
mId = other.mId; mId = other.mId;
mZValue = other.mZValue; mZValue = other.mZValue;
mCrs = other.mCrs; mCrs = other.mCrs;
mMapCanvas = other.mMapCanvas; mMapCanvas = other.mMapCanvas;
} }
return *this; return *this;
} }
MapLayer & MapLayer&
MapLayer::operator=(MapLayer &&other) noexcept { MapLayer::operator=(MapLayer&& other) noexcept {
if (this != &other) { if (this != &other) {
mId = other.mId; mId = other.mId;
mZValue = other.mZValue; mZValue = other.mZValue;
mCrs = other.mCrs; mCrs = other.mCrs;
mMapCanvas = other.mMapCanvas; mMapCanvas = other.mMapCanvas;
other.mId = QString{}; other.mId = QString{};
other.mCrs = nullptr; other.mCrs = nullptr;
other.mZValue = 0; other.mZValue = 0;
other.mMapCanvas = nullptr; other.mMapCanvas = nullptr;
} }
return *this; return *this;
} }
void void
MapLayer::update() { MapLayer::update() {
if(!isVisible()){ if (!isVisible()) {
qDebug() << id() << "=>图层不显示，跳过刷新操作"; qDebug() << id() << "=>图层不显示，跳过刷新操作";
mMapCanvasMap->hide(); mMapCanvasMap->hide();
return; return;
} }
//qDebug() << "刷新图层内容=>" << mMapCanvas->viewExtent()<<QDateTime::currentDateTime()<<"zoom"<<mZoomValue; //qDebug() << "刷新图层内容=>" << mMapCanvas->viewExtent()<<QDateTime::currentDateTime()<<"zoom"<<mZoomValue;
mProvider->createTask(mMapCanvas->viewExtent(), mZoomValue); mProvider->createTask(mMapCanvas->viewExtent(), mZoomValue);
mMapCanvasMap->show(); mMapCanvasMap->show();
} }
} }

230
RasterMainWidgetGUI/RasterMainWidget/maplayer.h
View File

@ -9,141 +9,141 @@
#include <mapcanvasmap.h> #include <mapcanvasmap.h>
namespace LAMPMainWidget { namespace LAMPMainWidget {
class MapCanvas; class MapCanvas;
/* /*
* 地图容器中的图层，属于数据的集合并不包含任何显示需要的数据 * 地图容器中的图层，属于数据的集合并不包含任何显示需要的数据
*/ */
class MapLayer { class MapLayer {
public: public:
MapLayer(const QString &id, CRS *crs, MapCanvas *mapCanvas); MapLayer(const QString& id, CRS* crs, MapCanvas* mapCanvas);
MapLayer(const MapLayer &other); MapLayer(const MapLayer& other);
MapLayer(MapLayer &&other) noexcept; MapLayer(MapLayer&& other) noexcept;
virtual ~MapLayer(); virtual ~MapLayer();
MapLayer &operator=(const MapLayer &other); MapLayer& operator=(const MapLayer& other);
MapLayer &operator=(MapLayer &&other) noexcept; MapLayer& operator=(MapLayer&& other) noexcept;
public: public:
/* /*
* 获取图层的id * 获取图层的id
* @return 图层id字符串 * @return 图层id字符串
*/ */
const QString &id() const { return mId; } const QString& id() const { return mId; }
/* /*
* 获取图层的显示z值 * 获取图层的显示z值
* @return z值 * @return z值
*/ */
const int zValue() const { return mZValue; } const int zValue() const { return mZValue; }
/* /*
* 获取图层的坐标系 * 获取图层的坐标系
* @return 图层的坐标系 * @return 图层的坐标系
*/ */
const CRS &crs() const { return *mCrs; } const CRS& crs() const { return *mCrs; }
/* /*
* 获取图层所属的map容器 * 获取图层所属的map容器
* @return 图层所属的map容器 * @return 图层所属的map容器
*/ */
const MapCanvas &mapCanvas() const { return *mMapCanvas; } const MapCanvas& mapCanvas() const { return *mMapCanvas; }
/* /*
* 获取图层的数据提供对象 * 获取图层的数据提供对象
* @return 图层的数据提供对象 * @return 图层的数据提供对象
*/ */
const LayerProvider &provider() const { return *mProvider; } const LayerProvider& provider() const { return *mProvider; }
/* /*
* 设置图层的id * 设置图层的id
* @param id 图层id * @param id 图层id
*/ */
void setId(const QString &id) { mId = id; } void setId(const QString& id) { mId = id; }
/* /*
* 设置图层的z值 * 设置图层的z值
* @param zValue 图层z值 * @param zValue 图层z值
*/ */
void setZValue(const int zValue) { mZValue = zValue; } void setZValue(const int zValue) { mZValue = zValue; }
/* /*
* 设置图层的坐标系 * 设置图层的坐标系
* @param crs 图层坐标系 * @param crs 图层坐标系
*/ */
void setCrs(CRS *const crs) { mCrs = crs; } void setCrs(CRS* const crs) { mCrs = crs; }
/* /*
* 设置图层的数据提供对象 * 设置图层的数据提供对象
* @param provider 图层的数据提供对象 * @param provider 图层的数据提供对象
*/ */
void setProvider(LayerProvider *const provider) { mProvider = provider; } void setProvider(LayerProvider* const provider) { mProvider = provider; }
/* /*
* 获取图层的pixel:m比例尺 * 获取图层的pixel:m比例尺
* @return 图层的分辨率 * @return 图层的分辨率
*/ */
virtual double resolution() const = 0; virtual double resolution() const = 0;
/* /*
* 获取图层的整个显示边界 * 获取图层的整个显示边界
* @return 图层的显示边界 * @return 图层的显示边界
*/ */
virtual QRectF extent() const = 0; virtual QRectF extent() const = 0;
/* /*
* 获取图层的当前zoom值 * 获取图层的当前zoom值
* @return 图层的当前zoom值 * @return 图层的当前zoom值
*/ */
int zoomValue() const { return mZoomValue; } int zoomValue() const { return mZoomValue; }
/* /*
* 设置图层的当前zoom值 * 设置图层的当前zoom值
* @param zoom 图层zoom值 * @param zoom 图层zoom值
*/ */
virtual void setZoomValue(int zoom) { mZoomValue = zoom; } virtual void setZoomValue(int zoom) { mZoomValue = zoom; }
/* /*
* 设置图层所属的地图容器 * 设置图层所属的地图容器
* @param map 图层所属的地图容器 * @param map 图层所属的地图容器
*/ */
void setMap(MapCanvasMap *map) { mMapCanvasMap = map; } void setMap(MapCanvasMap* map) { mMapCanvasMap = map; }
/* /*
* 获取图层的显示图元，这是图层最终的显示对象 * 获取图层的显示图元，这是图层最终的显示对象
* @return 图层的显示图元 * @return 图层的显示图元
*/ */
MapCanvasMap *map() const { return mMapCanvasMap; } MapCanvasMap* map() const { return mMapCanvasMap; }
/* /*
* 判断图层是否可显示 * 判断图层是否可显示
* @return 图层是否可显示，true显示，false则不显示 * @return 图层是否可显示，true显示，false则不显示
*/ */
bool isVisible() const {return mIsVisible;} bool isVisible() const { return mIsVisible; }
/* /*
* 设值图层的可显示属性 * 设值图层的可显示属性
* @param visible true为显示，false则不显示 * @param visible true为显示，false则不显示
*/ */
void setVisiblity(bool visible) {mIsVisible = visible;} void setVisiblity(bool visible) { mIsVisible = visible; }
/* /*
* 刷新图层内容 * 刷新图层内容
* @return 刷新图层内容，true则成功，否则为失败 * @return 刷新图层内容，true则成功，否则为失败
*/ */
virtual void update(); virtual void update();
protected: protected:
QString mId; QString mId;
CRS *mCrs; CRS* mCrs;
int mZValue; int mZValue;
int mZoomValue; int mZoomValue;
LayerProvider *mProvider; LayerProvider* mProvider;
MapCanvasMap *mMapCanvasMap; MapCanvasMap* mMapCanvasMap;
const MapCanvas *mMapCanvas; const MapCanvas* mMapCanvas;
bool mIsVisible{false}; bool mIsVisible{ false };
private: private:
const static int kDefaultZoomValue{10}; const static int kDefaultZoomValue{ 10 };
}; };
} }

60
RasterMainWidgetGUI/RasterMainWidget/maptool.h
View File

@ -3,40 +3,40 @@
#include <QtGui/QMouseEvent> #include <QtGui/QMouseEvent>
namespace LAMPMainWidget { namespace LAMPMainWidget {
class MapCanvas; class MapCanvas;
/** /**
* 地图的处理工具 * 地图的处理工具
*/ */
class MapTool { class MapTool {
public: public:
MapTool(MapCanvas *mapCanvas) : mMapCanvas(mapCanvas) {} MapTool(MapCanvas* mapCanvas) : mMapCanvas(mapCanvas) {}
virtual ~MapTool(); virtual ~MapTool();
public: public:
/** /**
* 具体的工具处理程序 * 具体的工具处理程序
* @param event 鼠标事件 * @param event 鼠标事件
*/ */
virtual void execute(QMouseEvent *event) = 0; virtual void execute(QMouseEvent* event) = 0;
/** /**
* 提示将使用工具，此方法中可以为工具的环境做一些准备 * 提示将使用工具，此方法中可以为工具的环境做一些准备
*/ */
virtual void setup() = 0; virtual void setup() = 0;
/** /**
* 当工具不使用时，将相关环境还原至原先状态 * 当工具不使用时，将相关环境还原至原先状态
*/ */
virtual void deSetup() = 0; virtual void deSetup() = 0;
/** /**
* 获取工具的名称 * 获取工具的名称
* @return 工具名称 * @return 工具名称
*/ */
virtual QString id() = 0; virtual QString id() = 0;
protected: protected:
MapCanvas *mMapCanvas; MapCanvas* mMapCanvas;
}; };
} }

56
RasterMainWidgetGUI/RasterMainWidget/maptoolpan.cpp
View File

@ -6,39 +6,39 @@
namespace LAMPMainWidget { namespace LAMPMainWidget {
void void
MapToolPan::execute(QMouseEvent *event) { MapToolPan::execute(QMouseEvent* event) {
if(!(event->button() & Qt::LeftButton)){ if (!(event->button() & Qt::LeftButton)) {
return; return;
} }
auto type = event->type(); auto type = event->type();
if (QEvent::MouseButtonPress == type) { if (QEvent::MouseButtonPress == type) {
mDragStartPos = event->pos(); mDragStartPos = event->pos();
} }
if (QEvent::MouseButtonRelease == type) { if (QEvent::MouseButtonRelease == type) {
mDragEndPos = event->pos(); mDragEndPos = event->pos();
QRectF dragRect{mDragStartPos, mDragEndPos}; QRectF dragRect{ mDragStartPos, mDragEndPos };
mMapCanvas->mDragRect = dragRect; mMapCanvas->mDragRect = dragRect;
mMapCanvas->updateViewExtent(); mMapCanvas->updateViewExtent();
} }
} }
void void
MapToolPan::setup() { MapToolPan::setup() {
mMapCanvas->setDragMode(MapCanvas::DragMode::ScrollHandDrag); mMapCanvas->setDragMode(MapCanvas::DragMode::ScrollHandDrag);
} }
QString QString
MapToolPan::id() { MapToolPan::id() {
return QString{"pan_tool"}; return QString{ "pan_tool" };
} }
void void
MapToolPan::deSetup() { MapToolPan::deSetup() {
mMapCanvas->setDragMode(MapCanvas::DragMode::NoDrag); mMapCanvas->setDragMode(MapCanvas::DragMode::NoDrag);
} }
} }

6
RasterMainWidgetGUI/RasterMainWidget/ostnormalprovider.cpp
View File

@ -10,9 +10,9 @@ OSTNormalProvider::OSTNormalProvider(QObject *parent)
} }
QString QString
OSTNormalProvider::tileUrl(const LAMPMainWidget::PointXY &pos, int zoom) const { OSTNormalProvider::tileUrl(const LAMPMainWidget::PointXY& pos, int zoom) const {
QString urlFmt = {"https://tile.openstreetmap.org/%1/%2/%3.png"}; QString urlFmt = { "https://tile.openstreetmap.org/%1/%2/%3.png" };
return QString(urlFmt).arg(zoom).arg(pos.y()).arg(pos.x()); return QString(urlFmt).arg(zoom).arg(pos.y()).arg(pos.x());
} }
//https://tile.openstreetmap.org/{z}/{x}/{y}.png //https://tile.openstreetmap.org/{z}/{x}/{y}.png
} }

335
RasterMainWidgetGUI/RasterMainWidget/taskwindow.cpp
View File

@ -17,193 +17,192 @@
namespace LAMPMainWidget namespace LAMPMainWidget
{ {
void void
DownloadTask::run() DownloadTask::run()
{ {
auto currentLayer = dynamic_cast<const TmsLayer *>(mTaskInfo.layer); auto currentLayer = dynamic_cast<const TmsLayer*>(mTaskInfo.layer);
auto provider = dynamic_cast<const TmsProvider*>(&currentLayer->provider()); auto provider = dynamic_cast<const TmsProvider*>(&currentLayer->provider());
auto tileSize = provider->tileSize(); auto tileSize = provider->tileSize();
QHash<QPoint, QString> tiles{}; QHash<QPoint, QString> tiles{};
QSize imgSize{}; QSize imgSize{};
if (!currentLayer->parseTiles(mTaskInfo.extent, mTaskInfo.zoom, tiles, imgSize)) { if (!currentLayer->parseTiles(mTaskInfo.extent, mTaskInfo.zoom, tiles, imgSize)) {
qCritical() << "瓦片路径解析错误"; qCritical() << "瓦片路径解析错误";
generateErrorRow(); generateErrorRow();
return; return;
} }
generateSuccessRow(); generateSuccessRow();
ImgWriter imgWriter{mTaskInfo.taskPath, imgSize}; ImgWriter imgWriter{ mTaskInfo.taskPath, imgSize };
QByteArray tileData{}; QByteArray tileData{};
Network web{}; Network web{};
auto item = tiles.constBegin(); auto item = tiles.constBegin();
auto count = tiles.count(); auto count = tiles.count();
int completed{0}; int completed{ 0 };
for (; item != tiles.constEnd(); ++item) { for (; item != tiles.constEnd(); ++item) {
tileData = web.httpsRequest(item.value()); tileData = web.httpsRequest(item.value());
if (tileData.isEmpty()) { if (tileData.isEmpty()) {
qCritical() << item.value() << "下载数据为空"; qCritical() << item.value() << "下载数据为空";
return; return;
} }
++completed; ++completed;
auto pos = QPoint(item.key().x() * tileSize.width(), item.key().y() * tileSize.height()); auto pos = QPoint(item.key().x() * tileSize.width(), item.key().y() * tileSize.height());
if (!imgWriter.write(pos, tileData)) { if (!imgWriter.write(pos, tileData)) {
qCritical() << "瓦片写出失败"; qCritical() << "瓦片写出失败";
} }
double progress = static_cast<double>(completed) / count; double progress = static_cast<double>(completed) / count;
auto progessStr = QString("%1").arg(progress * 100); auto progessStr = QString("%1").arg(progress * 100);
mTaskInfo.display->takeItem(mRowId, 4); mTaskInfo.display->takeItem(mRowId, 4);
mTaskInfo.display->setItem(mRowId, 4, mTaskInfo.display->setItem(mRowId, 4,new QTableWidgetItem(QString("%1").arg(progress * 100)));
new QTableWidgetItem(QString("%1").arg(progress * 100))); // mTaskInfo.display->resizeColumnsToContents();
// mTaskInfo.display->resizeColumnsToContents(); // mTaskInfo.display->horizontalHeader()->setStretchLastSection(true);
// mTaskInfo.display->horizontalHeader()->setStretchLastSection(true); }
} }
}
void void
DownloadTask::generateCommonRow() DownloadTask::generateCommonRow()
{ {
auto provider = dynamic_cast<const TmsProvider*>(&mTaskInfo.layer->provider()); auto provider = dynamic_cast<const TmsProvider*>(&mTaskInfo.layer->provider());
mRowId = mTaskInfo.display->rowCount(); mRowId = mTaskInfo.display->rowCount();
mTaskInfo.display->insertRow(mRowId); mTaskInfo.display->insertRow(mRowId);
mTaskInfo.display->setItem(mRowId, 0, new QTableWidgetItem(mTaskInfo.taskName)); mTaskInfo.display->setItem(mRowId, 0, new QTableWidgetItem(mTaskInfo.taskName));
mTaskInfo.display->setItem(mRowId, 1, new QTableWidgetItem(getExtentStr())); mTaskInfo.display->setItem(mRowId, 1, new QTableWidgetItem(getExtentStr()));
mTaskInfo.display->setItem(mRowId, 2, new QTableWidgetItem(QString("%1").arg(mTaskInfo.zoom))); mTaskInfo.display->setItem(mRowId, 2, new QTableWidgetItem(QString("%1").arg(mTaskInfo.zoom)));
mTaskInfo.display->setItem(mRowId, 3, new QTableWidgetItem(provider->id())); mTaskInfo.display->setItem(mRowId, 3, new QTableWidgetItem(provider->id()));
} }
void void
DownloadTask::generateErrorRow() DownloadTask::generateErrorRow()
{ {
generateCommonRow(); generateCommonRow();
mTaskInfo.display->setItem(mRowId, 4, new QTableWidgetItem("任务新建失败")); mTaskInfo.display->setItem(mRowId, 4, new QTableWidgetItem("任务新建失败"));
mTaskInfo.display->resizeColumnsToContents(); mTaskInfo.display->resizeColumnsToContents();
} }
void void
DownloadTask::generateSuccessRow() DownloadTask::generateSuccessRow()
{ {
generateCommonRow(); generateCommonRow();
mTaskInfo.display->setItem(mRowId, 4, new QTableWidgetItem("0.0%")); mTaskInfo.display->setItem(mRowId, 4, new QTableWidgetItem("0.0%"));
mTaskInfo.display->resizeColumnsToContents(); mTaskInfo.display->resizeColumnsToContents();
} }
QString QString
DownloadTask::getExtentStr() DownloadTask::getExtentStr()
{ {
auto leftTop = mTaskInfo.extent.topLeft(); auto leftTop = mTaskInfo.extent.topLeft();
auto rightBottom = mTaskInfo.extent.bottomRight(); auto rightBottom = mTaskInfo.extent.bottomRight();
return QString("[%1, %2], [%3, %4]").arg(leftTop.x()).arg(leftTop.y()) return QString("[%1, %2], [%3, %4]").arg(leftTop.x()).arg(leftTop.y())
.arg(rightBottom.x()).arg(rightBottom.y()); .arg(rightBottom.x()).arg(rightBottom.y());
} }
TaskWindow::TaskWindow(QWidget* parent) TaskWindow::TaskWindow(QWidget* parent)
: mUi(new Ui::TaskWindow), : mUi(new Ui::TaskWindow),
mParent(dynamic_cast<RasterMainWidget *>(parent)), mParent(dynamic_cast<RasterMainWidget*>(parent)),
mSavePath(), mSavePath(),
QDialog(parent) QDialog(parent)
{ {
mUi->setupUi(this); mUi->setupUi(this);
setupWindow(); setupWindow();
setupAction(); setupAction();
} }
TaskWindow::~TaskWindow() TaskWindow::~TaskWindow()
{ {
delete mUi; delete mUi;
} }
void void
TaskWindow::setupWindow() TaskWindow::setupWindow()
{ {
setFixedSize(size()); setFixedSize(size());
auto currentLayer = dynamic_cast<const TmsLayer *>(mParent->mMapConvas->currentLayer()); auto currentLayer = dynamic_cast<const TmsLayer*>(mParent->mMapConvas->currentLayer());
auto minZoom = currentLayer->minZoom(); auto minZoom = currentLayer->minZoom();
auto maxZoom = currentLayer->maxZoom(); auto maxZoom = currentLayer->maxZoom();
for (auto i = minZoom; i <= maxZoom; ++i) { for (auto i = minZoom; i <= maxZoom; ++i) {
mUi->zoomValueCbx->addItem(QString("%1").arg(i), i); mUi->zoomValueCbx->addItem(QString("%1").arg(i), i);
} }
mUi->leftTopText->setText( mUi->leftTopText->setText(
QString("%1, %2").arg(mParent->mLeftTop.x()).arg(mParent->mLeftTop.y())); QString("%1, %2").arg(mParent->mLeftTop.x()).arg(mParent->mLeftTop.y()));
mUi->rightBottomText->setText( mUi->rightBottomText->setText(
QString("%1, %2").arg(mParent->mRightBottom.x()).arg(mParent->mRightBottom.y())); QString("%1, %2").arg(mParent->mRightBottom.x()).arg(mParent->mRightBottom.y()));
} }
void void
TaskWindow::setupAction() TaskWindow::setupAction()
{ {
QObject::connect(mUi->exitBtn, &QPushButton::clicked, this, &TaskWindow::close); QObject::connect(mUi->exitBtn, &QPushButton::clicked, this, &TaskWindow::close);
QObject::connect(mUi->createBtn, &QPushButton::clicked, this, &TaskWindow::createTask); QObject::connect(mUi->createBtn, &QPushButton::clicked, this, &TaskWindow::createTask);
QObject::connect(mUi->saveDirBtn, &QPushButton::clicked, this, &TaskWindow::setupSaveDir); QObject::connect(mUi->saveDirBtn, &QPushButton::clicked, this, &TaskWindow::setupSaveDir);
QObject::connect(mUi->taskNameText, &QLineEdit::textChanged, this, &TaskWindow::setupTaskName); QObject::connect(mUi->taskNameText, &QLineEdit::textChanged, this, &TaskWindow::setupTaskName);
QObject::connect(mUi->zoomValueCbx, QOverload<int>::of(&QComboBox::currentIndexChanged), QObject::connect(mUi->zoomValueCbx, QOverload<int>::of(&QComboBox::currentIndexChanged),
this, &TaskWindow::setupZoomValue); this, &TaskWindow::setupZoomValue);
} }
void void
TaskWindow::createTask() TaskWindow::createTask()
{ {
if (!taskInfoCheck()) { if (!taskInfoCheck()) {
return; return;
} }
mSavePath.append("/").append(mTaskName).append(".tiff"); mSavePath.append("/").append(mTaskName).append(".tiff");
auto savePath = QDir::toNativeSeparators(mSavePath); auto savePath = QDir::toNativeSeparators(mSavePath);
auto extent = QRectF(QPointF(mParent->mLeftTop.x(), mParent->mLeftTop.y()), auto extent = QRectF(QPointF(mParent->mLeftTop.x(), mParent->mLeftTop.y()),
QPointF(mParent->mRightBottom.x(), mParent->mRightBottom.y())); QPointF(mParent->mRightBottom.x(), mParent->mRightBottom.y()));
auto tileInfo = TaskInfo{ mTaskName, savePath, extent, auto tileInfo = TaskInfo{ mTaskName, savePath, extent,
mZoomValue, mZoomValue,
mParent->mMapConvas->currentLayer(), mParent->mMapConvas->currentLayer(),
mParent->getTaskTable() mParent->getTaskTable()
/*mParent->mUi->taskTable*/}; /*mParent->mUi->taskTable*/ };
auto task = new DownloadTask(tileInfo); auto task = new DownloadTask(tileInfo);
QThreadPool::globalInstance()->start(task); QThreadPool::globalInstance()->start(task);
close(); close();
} }
void void
TaskWindow::setupSaveDir() TaskWindow::setupSaveDir()
{ {
auto saveDir = QFileDialog::getExistingDirectory(dynamic_cast<QWidget *>(this), "存储路径选择"); auto saveDir = QFileDialog::getExistingDirectory(dynamic_cast<QWidget*>(this), "存储路径选择");
if (saveDir.isEmpty()) { if (saveDir.isEmpty()) {
qWarning() << "未选择存储路径"; qWarning() << "未选择存储路径";
return; return;
} }
mSavePath = saveDir; mSavePath = saveDir;
mUi->saveDirText->setText(mSavePath); mUi->saveDirText->setText(mSavePath);
} }
void void
TaskWindow::setupTaskName(const QString& text) TaskWindow::setupTaskName(const QString& text)
{ {
qDebug() << "任务名=>" << text; qDebug() << "任务名=>" << text;
mTaskName = text; mTaskName = text;
} }
bool bool
TaskWindow::taskInfoCheck() TaskWindow::taskInfoCheck()
{ {
if (mTaskName.isEmpty()) { if (mTaskName.isEmpty()) {
QMessageBox::critical(dynamic_cast<QWidget *>(this), "错误", "任务名称为空"); QMessageBox::critical(dynamic_cast<QWidget*>(this), "错误", "任务名称为空");
return false; return false;
} }
if (mSavePath.isEmpty()) { if (mSavePath.isEmpty()) {
QMessageBox::critical(dynamic_cast<QWidget *>(this), "错误", "存储路径为空"); QMessageBox::critical(dynamic_cast<QWidget*>(this), "错误", "存储路径为空");
return false; return false;
} }
return true; return true;
} }
void void
TaskWindow::setupZoomValue(int index) TaskWindow::setupZoomValue(int index)
{ {
auto zoom = mUi->zoomValueCbx->itemData(index).toInt(); auto zoom = mUi->zoomValueCbx->itemData(index).toInt();
qDebug() << "设置下载任务zoom值=>" << zoom; qDebug() << "设置下载任务zoom值=>" << zoom;
mZoomValue = zoom; mZoomValue = zoom;
} }
} }

135
RasterMainWidgetGUI/RasterMainWidget/tmslayer.cpp
View File

@ -10,88 +10,91 @@
namespace LAMPMainWidget { namespace LAMPMainWidget {
TmsLayer::TmsLayer(LAMPMainWidget::TmsProviders provider, TmsLayer::TmsLayer(LAMPMainWidget::TmsProviders provider,
const QString &id, const QString& id,
LAMPMainWidget::MapCanvas *mapCanvas, LAMPMainWidget::MapCanvas* mapCanvas,
LAMPMainWidget::CRS *crs) LAMPMainWidget::CRS* crs)
: MapLayer(id, crs, mapCanvas) { : MapLayer(id, crs, mapCanvas) {
setProvider(TmsProviderFactory::create(provider)); setProvider(TmsProviderFactory::create(provider));
} }
double double
TmsLayer::resolution() const { TmsLayer::resolution() const {
auto pd = dynamic_cast<const TmsProvider *>(&provider()); auto pd = dynamic_cast<const TmsProvider*>(&provider());
auto sz = pd->tileSize(); auto sz = pd->tileSize();
double length = crs().extent().width(); double length = crs().extent().width();
double result = length / ((power2(zoomValue())) * sz.width()); double result = length / ((power2(zoomValue())) * sz.width());
#ifdef DEBUG #ifdef DEBUG
qDebug() << "resolution=>" << result; qDebug() << "resolution=>" << result;
#endif #endif
return result; return result;
} }
QRectF QRectF
TmsLayer::extent() const { TmsLayer::extent() const {
auto pd = dynamic_cast<const TmsProvider *>(&provider()); auto pd = dynamic_cast<const TmsProvider*>(&provider());
QSize sz = pd->tileSize(); QSize sz = pd->tileSize();
int width = power2(zoomValue()) * sz.width(); int width = power2(zoomValue()) * sz.width();
int height = power2(zoomValue()) * sz.height(); int height = power2(zoomValue()) * sz.height();
//#ifdef DEBUG //#ifdef DEBUG
// qDebug() << "layer extent=>{width:" << width << ", height:" << height << "}"; // qDebug() << "layer extent=>{width:" << width << ", height:" << height << "}";
//#endif //#endif
return {0, 0, static_cast<qreal>(width), static_cast<qreal>(height)}; return { 0, 0, static_cast<qreal>(width), static_cast<qreal>(height) };
} }
void void
TmsLayer::setZoomValue(int zoom) { TmsLayer::setZoomValue(int zoom) {
int zoomValue{}; int zoomValue{};
if (zoom <= minZoom()) { if (zoom <= minZoom()) {
zoomValue = minZoom(); zoomValue = minZoom();
} else if (zoom >= maxZoom()) { }
zoomValue = maxZoom(); else if (zoom >= maxZoom()) {
} else { zoomValue = maxZoom();
zoomValue = zoom; }
} else {
zoomValue = zoom;
}
mZoomValue = zoomValue; mZoomValue = zoomValue;
} }
bool bool
TmsLayer::parseTiles(const QRectF &rect, int zoom, QHash<QPoint, QString> &tiles, QSize &size) const { TmsLayer::parseTiles(const QRectF& rect, int zoom, QHash<QPoint, QString>& tiles, QSize& size) const {
auto pd = dynamic_cast<const TmsProvider *>(&provider());
auto tileSize = pd->tileSize();
auto resolution = mCrs->extent().width() / ((power2(zoom)) * tileSize.width());
auto crsLeftTop = mCrs->forward(PointXY(rect.topLeft())); auto pd = dynamic_cast<const TmsProvider*>(&provider());
auto crsRightBottom = mCrs->forward(PointXY(rect.bottomRight())); auto tileSize = pd->tileSize();
auto resolution = mCrs->extent().width() / ((power2(zoom)) * tileSize.width());
auto mapLeftTop = QPointF(crsLeftTop.x() / resolution, crsLeftTop.y() / resolution); auto crsLeftTop = mCrs->forward(PointXY(rect.topLeft()));
auto mapRightBottom = QPointF(crsRightBottom.x() / resolution, crsRightBottom.y() / resolution); auto crsRightBottom = mCrs->forward(PointXY(rect.bottomRight()));
auto xMin = qFloor(mapLeftTop.x() / tileSize.width());
auto xMax = qFloor(mapRightBottom.x() / tileSize.width());
auto yMin = qFloor(mapLeftTop.y() / tileSize.height());
auto yMax = qFloor(mapRightBottom.y() / tileSize.height());
if((xMin > xMax) || (yMin > yMax)){
qDebug() << "下载区边界错误";
return false;
}
size.setWidth((xMax - xMin + 1) * tileSize.width()); auto mapLeftTop = QPointF(crsLeftTop.x() / resolution, crsLeftTop.y() / resolution);
size.setHeight((yMax - yMin + 1) * tileSize.height()); auto mapRightBottom = QPointF(crsRightBottom.x() / resolution, crsRightBottom.y() / resolution);
auto xMin = qFloor(mapLeftTop.x() / tileSize.width());
auto xMax = qFloor(mapRightBottom.x() / tileSize.width());
auto yMin = qFloor(mapLeftTop.y() / tileSize.height());
auto yMax = qFloor(mapRightBottom.y() / tileSize.height());
if ((xMin > xMax) || (yMin > yMax)) {
qDebug() << "下载区边界错误";
return false;
}
for (int i = xMin; i <= xMax; ++i) { size.setWidth((xMax - xMin + 1) * tileSize.width());
for (int j = yMin; j <= yMax; ++j) { size.setHeight((yMax - yMin + 1) * tileSize.height());
auto url = pd->tileUrl(PointXY(i, j), zoom);
tiles.insert(QPoint(i - xMin, j - yMin), url);
}
}
return true; for (int i = xMin; i <= xMax; ++i) {
} for (int j = yMin; j <= yMax; ++j) {
auto url = pd->tileUrl(PointXY(i, j), zoom);
tiles.insert(QPoint(i - xMin, j - yMin), url);
}
}
return true;
}
} }

338
RasterMainWidgetGUI/RasterMainWidget/tmsprovider.cpp
View File

@ -11,192 +11,192 @@
namespace LAMPMainWidget namespace LAMPMainWidget
{ {
TileDownloadTask::TileDownloadTask(TileInfo tile, QObject* parent) TileDownloadTask::TileDownloadTask(TileInfo tile, QObject* parent)
: QObject(parent), : QObject(parent),
mTile(std::move(tile)) mTile(std::move(tile))
{ {
} }
void void
TileDownloadTask::run() TileDownloadTask::run()
{ {
Network web{}; Network web{};
QByteArray data = web.httpsRequest(mTile.url); QByteArray data = web.httpsRequest(mTile.url);
mTile.data = data; mTile.data = data;
tileReady(mTile); tileReady(mTile);
} }
TmsProvider::TmsProvider(QObject* parent) TmsProvider::TmsProvider(QObject* parent)
: LayerProvider(parent), : LayerProvider(parent),
mImage(nullptr) mImage(nullptr)
{ {
if (!QFile::exists(mDbName)) { if (!QFile::exists(mDbName)) {
QFile dbFile{mDbName}; QFile dbFile{ mDbName };
dbFile.open(QIODevice::ReadWrite); dbFile.open(QIODevice::ReadWrite);
dbFile.close(); dbFile.close();
} }
} }
TmsProvider::~TmsProvider() TmsProvider::~TmsProvider()
{ {
delete mImage; delete mImage;
} }
bool bool
TmsProvider::initCache() TmsProvider::initCache()
{ {
mDbConn = QSqlDatabase::addDatabase("QSQLITE", id()); mDbConn = QSqlDatabase::addDatabase("QSQLITE", id());
mDbConn.setDatabaseName(mDbName); mDbConn.setDatabaseName(mDbName);
if (!mDbConn.open()) { if (!mDbConn.open()) {
qCritical() << "缓存数据库打开失败"; qCritical() << "缓存数据库打开失败";
return false; return false;
} }
QSqlQuery sql{mDbConn}; QSqlQuery sql{ mDbConn };
if (!mDbConn.tables().contains(mTableName)) { if (!mDbConn.tables().contains(mTableName)) {
sql.prepare(QString("create table %1 (" sql.prepare(QString("create table %1 ("
"id integer primary key autoincrement," "id integer primary key autoincrement,"
"provider text not null," "provider text not null,"
"zoom integer not null," "zoom integer not null,"
"position text not null," "position text not null,"
"data blob not null" "data blob not null"
")").arg(mTableName)); ")").arg(mTableName));
if (!sql.exec()) { if (!sql.exec()) {
qCritical() << "缓存表创建失败" << sql.lastError().text(); qCritical() << "缓存表创建失败" << sql.lastError().text();
return false; return false;
} }
} }
mDbConn.close(); mDbConn.close();
return true; return true;
} }
QByteArray QByteArray
TmsProvider::getCache(const QPoint& pos, int zoom) TmsProvider::getCache(const QPoint& pos, int zoom)
{ {
QByteArray res{}; QByteArray res{};
mDbConn.open(); mDbConn.open();
QSqlQuery select{mDbConn}; QSqlQuery select{ mDbConn };
select.prepare(QString("select data from %1 " select.prepare(QString("select data from %1 "
"where provider = :provider " "where provider = :provider "
"and zoom = :zoom " "and zoom = :zoom "
"and position = :position " "and position = :position "
"order by id desc limit 1" "order by id desc limit 1"
).arg(mTableName)); ).arg(mTableName));
select.bindValue(":provider", id()); select.bindValue(":provider", id());
select.bindValue(":zoom", zoom); select.bindValue(":zoom", zoom);
select.bindValue(":position", QString("%1:%2").arg(pos.x()).arg(pos.y())); select.bindValue(":position", QString("%1:%2").arg(pos.x()).arg(pos.y()));
if (!select.exec()) { if (!select.exec()) {
qDebug() << pos << "查询失败=>" << select.lastError().text(); qDebug() << pos << "查询失败=>" << select.lastError().text();
mDbConn.close(); mDbConn.close();
return res; return res;
} }
if (!select.seek(0)) { if (!select.seek(0)) {
mDbConn.close(); mDbConn.close();
return res; return res;
} }
res = select.value(0).toByteArray(); res = select.value(0).toByteArray();
mDbConn.close(); mDbConn.close();
return res; return res;
} }
bool bool
TmsProvider::addCache(const QPoint& pos, int zoom, QByteArray data) TmsProvider::addCache(const QPoint& pos, int zoom, QByteArray data)
{ {
if (data.isEmpty()) { if (data.isEmpty()) {
qWarning() << "瓦片数据为空"; qWarning() << "瓦片数据为空";
return false; return false;
} }
mDbConn.open(); mDbConn.open();
QSqlQuery sql{mDbConn}; QSqlQuery sql{ mDbConn };
sql.prepare(QString{ sql.prepare(QString{
"insert into %1 (provider, zoom, position, data)" "insert into %1 (provider, zoom, position, data)"
"values( :provider, :zoom, :position, :data)" "values( :provider, :zoom, :position, :data)"
}.arg(mTableName)); }.arg(mTableName));
sql.bindValue(":tbname", mTableName); sql.bindValue(":tbname", mTableName);
sql.bindValue(":provider", id()); sql.bindValue(":provider", id());
sql.bindValue(":zoom", zoom); sql.bindValue(":zoom", zoom);
sql.bindValue(":position", QString("%1:%2").arg(pos.x()).arg(pos.y())); sql.bindValue(":position", QString("%1:%2").arg(pos.x()).arg(pos.y()));
sql.bindValue(":data", data); sql.bindValue(":data", data);
if (!sql.exec()) { if (!sql.exec()) {
qCritical() << pos << "=>" << sql.lastError().text(); qCritical() << pos << "=>" << sql.lastError().text();
mDbConn.close(); mDbConn.close();
return false; return false;
} }
mDbConn.close(); mDbConn.close();
return true; return true;
} }
bool bool
TmsProvider::cacheContains(const QPoint& pos, int zoom) TmsProvider::cacheContains(const QPoint& pos, int zoom)
{ {
QByteArray res = getCache(pos, zoom); QByteArray res = getCache(pos, zoom);
return !res.isEmpty(); return !res.isEmpty();
} }
void void
TmsProvider::createTask(const QRectF& rect, int zoom) TmsProvider::createTask(const QRectF& rect, int zoom)
{ {
newImage(rect); newImage(rect);
/// 创建下载瓦片任务 /// 创建下载瓦片任务
const QSize sz = tileSize(); const QSize sz = tileSize();
int xMin = qFloor(rect.topLeft().x() / sz.width()); int xMin = qFloor(rect.topLeft().x() / sz.width());
double xOffset = rect.topLeft().x() / sz.width() - xMin; double xOffset = rect.topLeft().x() / sz.width() - xMin;
int xMax = qFloor(rect.bottomRight().x() / sz.width()); int xMax = qFloor(rect.bottomRight().x() / sz.width());
int yMin = qFloor(rect.topLeft().y() / sz.height()); int yMin = qFloor(rect.topLeft().y() / sz.height());
double yOffset = rect.topLeft().y() / sz.height() - yMin; double yOffset = rect.topLeft().y() / sz.height() - yMin;
int yMax = qFloor(rect.bottomRight().y() / sz.height()); int yMax = qFloor(rect.bottomRight().y() / sz.height());
for (int i = xMin; i <= xMax; ++i) { for (int i = xMin; i <= xMax; ++i) {
for (int j = yMin; j <= yMax; ++j) { for (int j = yMin; j <= yMax; ++j) {
TileInfo tile{}; TileInfo tile{};
tile.index = QPointF{i - xMin - xOffset, j - yMin - yOffset}; tile.index = QPointF{ i - xMin - xOffset, j - yMin - yOffset };
tile.position = QPoint{i, j}; tile.position = QPoint{ i, j };
tile.zoom = zoom; tile.zoom = zoom;
tile.coord = QPoint{i - xMin, j - yMin}; tile.coord = QPoint{ i - xMin, j - yMin };
tile.url = tileUrl(PointXY{static_cast<double>(i), static_cast<double>(j)}, zoom); tile.url = tileUrl(PointXY{ static_cast<double>(i), static_cast<double>(j) }, zoom);
auto tileData = getCache(tile.position, tile.zoom); auto tileData = getCache(tile.position, tile.zoom);
if (!tileData.isEmpty()) { if (!tileData.isEmpty()) {
tile.data = tileData; tile.data = tileData;
tileReady(tile); tileReady(tile);
continue; continue;
} }
auto* task = new TileDownloadTask(tile); auto* task = new TileDownloadTask(tile);
QObject::connect(task, &TileDownloadTask::tileReady, this, &TmsProvider::tileReady); QObject::connect(task, &TileDownloadTask::tileReady, this, &TmsProvider::tileReady);
QThreadPool::globalInstance()->start(task); QThreadPool::globalInstance()->start(task);
} }
} }
} }
void void
TmsProvider::tileReady(TileInfo tile) TmsProvider::tileReady(TileInfo tile)
{ {
if (!cacheContains(tile.position, tile.zoom)) { if (!cacheContains(tile.position, tile.zoom)) {
addCache(tile.position, tile.zoom, tile.data); addCache(tile.position, tile.zoom, tile.data);
} }
QPainter painter{mImage}; QPainter painter{ mImage };
QImage img = QImage::fromData(tile.data); QImage img = QImage::fromData(tile.data);
if (img.isNull()) { if (img.isNull()) {
return; return;
} }
double xPos = tile.index.x() * tileSize().width(); double xPos = tile.index.x() * tileSize().width();
double yPos = tile.index.y() * tileSize().height(); double yPos = tile.index.y() * tileSize().height();
painter.drawImage(QPointF(xPos, yPos), img); painter.drawImage(QPointF(xPos, yPos), img);
} }
void void
TmsProvider::newImage(const QRectF& rect) TmsProvider::newImage(const QRectF& rect)
{ {
QSize imgSize{int(rect.width()), int(rect.height())}; QSize imgSize{ int(rect.width()), int(rect.height()) };
if (!mImage || imgSize != mImage->size()) { if (!mImage || imgSize != mImage->size()) {
mImage = new QImage(imgSize, QImage::Format_RGB32); mImage = new QImage(imgSize, QImage::Format_RGB32);
} }
mImage->fill(Qt::white); mImage->fill(Qt::white);
} }
} }

52
RasterMainWidgetGUI/RasterMainWidget/tmsproviderfactory.cpp
View File

@ -5,33 +5,35 @@
namespace LAMPMainWidget { namespace LAMPMainWidget {
QHash<TmsProviders, LayerProvider *> TmsProviderFactory::mProviders{}; QHash<TmsProviders, LayerProvider*> TmsProviderFactory::mProviders{};
LayerProvider * LayerProvider*
TmsProviderFactory::create(LAMPMainWidget::TmsProviders provider) { TmsProviderFactory::create(LAMPMainWidget::TmsProviders provider) {
LayerProvider *result = nullptr; LayerProvider* result = nullptr;
switch (provider) { switch (provider) {
case OSTNormalMap: case OSTNormalMap:
if (mProviders.contains(OSTNormalMap)) { if (mProviders.contains(OSTNormalMap)) {
result = mProviders.value(OSTNormalMap); result = mProviders.value(OSTNormalMap);
} else { }
result = new OSTNormalProvider(); else {
mProviders.insert(OSTNormalMap, result); result = new OSTNormalProvider();
} mProviders.insert(OSTNormalMap, result);
break; }
case GaodeNormapMap: break;
if (mProviders.contains(GaodeNormapMap)) { case GaodeNormapMap:
result = mProviders.value(GaodeNormapMap); if (mProviders.contains(GaodeNormapMap)) {
} else { result = mProviders.value(GaodeNormapMap);
result = new GaodeNormalProvider(); }
mProviders.insert(GaodeNormapMap, result); else {
} result = new GaodeNormalProvider();
break; mProviders.insert(GaodeNormapMap, result);
default:break; }
} break;
default:break;
}
return result; return result;
} }
} }

5
RasterMainWidgetGUI/RasterMainWidgetGUI.vcxproj
View File

@ -106,6 +106,7 @@
<IncludePath>.;.\RasterMainWidget;..\RasterProcessToolWidget;..\RasterProcessToolWidget\ToolBoxManager;..\BaseCommonLibrary;..\BaseCommonLibrary\BaseTool;..\BaseCommonLibrary\ToolAbstract;..\GPUBaseLib\GPUTool;..\GPUBaseLib;..\RasterMainWidgetGUI;..\RasterMainWidgetGUI\RasterMainWidget;$(IncludePath)</IncludePath> <IncludePath>.;.\RasterMainWidget;..\RasterProcessToolWidget;..\RasterProcessToolWidget\ToolBoxManager;..\BaseCommonLibrary;..\BaseCommonLibrary\BaseTool;..\BaseCommonLibrary\ToolAbstract;..\GPUBaseLib\GPUTool;..\GPUBaseLib;..\RasterMainWidgetGUI;..\RasterMainWidgetGUI\RasterMainWidget;$(IncludePath)</IncludePath>
<CopyLocalProjectReference>true</CopyLocalProjectReference> <CopyLocalProjectReference>true</CopyLocalProjectReference>
<CopyCppRuntimeToOutputDir>true</CopyCppRuntimeToOutputDir> <CopyCppRuntimeToOutputDir>true</CopyCppRuntimeToOutputDir>
<LinkIncremental>true</LinkIncremental>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'"> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
<IncludePath>.;.\RasterMainWidget;..\RasterProcessToolWidget;..\RasterProcessToolWidget\ToolBoxManager;..\BaseCommonLibrary;..\BaseCommonLibrary\BaseTool;..\BaseCommonLibrary\ToolAbstract;..\GPUBaseLib\GPUTool;..\GPUBaseLib;..\RasterMainWidgetGUI;..\RasterMainWidgetGUI\RasterMainWidget;$(IncludePath)</IncludePath> <IncludePath>.;.\RasterMainWidget;..\RasterProcessToolWidget;..\RasterProcessToolWidget\ToolBoxManager;..\BaseCommonLibrary;..\BaseCommonLibrary\BaseTool;..\BaseCommonLibrary\ToolAbstract;..\GPUBaseLib\GPUTool;..\GPUBaseLib;..\RasterMainWidgetGUI;..\RasterMainWidgetGUI\RasterMainWidget;$(IncludePath)</IncludePath>
@ -115,6 +116,10 @@
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile> <ClCompile>
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING;RASTERMAINWIDGETGUI_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions> <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING;RASTERMAINWIDGETGUI_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<OpenMPSupport>true</OpenMPSupport>
<DebugInformationFormat>EditAndContinue</DebugInformationFormat>
<WholeProgramOptimization>false</WholeProgramOptimization>
<Optimization>Disabled</Optimization>
</ClCompile> </ClCompile>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">

3
RasterMainWidgetGUI/RasterMainWidgetGUI.vcxproj.filters
View File

@ -21,6 +21,9 @@
<UniqueIdentifier>{639EADAA-A684-42e4-A9AD-28FC9BCB8F7C}</UniqueIdentifier> <UniqueIdentifier>{639EADAA-A684-42e4-A9AD-28FC9BCB8F7C}</UniqueIdentifier>
<Extensions>ts</Extensions> <Extensions>ts</Extensions>
</Filter> </Filter>
<Filter Include="RasterLayer">
<UniqueIdentifier>{1a65f538-c16c-4824-895f-105eb2fc502e}</UniqueIdentifier>
</Filter>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<QtRcc Include="RasterMainWidgetGUI.qrc"> <QtRcc Include="RasterMainWidgetGUI.qrc">

3
RasterMainWidgetGUI/RasterWidgetMessageShow.cpp
View File

@ -7,6 +7,7 @@ namespace RasterMessageShow {
RasterWidgetMessageShow::RasterWidgetMessageShow(QObject* parant):QObject(parant) RasterWidgetMessageShow::RasterWidgetMessageShow(QObject* parant):QObject(parant)
{ {
this->textBrowserMessage = nullptr;
QObject::connect(this, SIGNAL(ShowMessage(QString)), this, SLOT(ShowMessageInfo(QString))); QObject::connect(this, SIGNAL(ShowMessage(QString)), this, SLOT(ShowMessageInfo(QString)));
} }
@ -26,12 +27,12 @@ namespace RasterMessageShow {
void RasterWidgetMessageShow::ShowMessageInfo(QString Message) void RasterWidgetMessageShow::ShowMessageInfo(QString Message)
{ {
std::cout << Message.toLocal8Bit().constData() << std::endl;
if (nullptr != this->textBrowserMessage) { if (nullptr != this->textBrowserMessage) {
this->textBrowserMessage->append(Message); this->textBrowserMessage->append(Message);
this->textBrowserMessage->moveCursor(QTextCursor::MoveOperation::End); this->textBrowserMessage->moveCursor(QTextCursor::MoveOperation::End);
this->textBrowserMessage->repaint(); this->textBrowserMessage->repaint();
std::cout << Message.toLocal8Bit().constData() << std::endl; std::cout << Message.toLocal8Bit().constData() << std::endl;
} }
else {} else {}
} }

2
RasterMainWidgetGUI/main.cpp
View File

@ -1,6 +1,8 @@
#include "LAMPMainWidgetRunProgram.h" #include "LAMPMainWidgetRunProgram.h"
#include <QtWidgets/QApplication> #include <QtWidgets/QApplication>
// 这个项目是基于easygis项目，原项目地址： https://gitee.com/stormeye2020/easygis.git
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
QApplication a(argc, argv); QApplication a(argc, argv);