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

614
RasterMainWidgetGUI/RasterMainWidget/RasterMainWidget.cpp
View File

@ -20,330 +20,306 @@
namespace LAMPMainWidget {
QString
RasterMainWidget::tutorialUrl() {
return QString{R"(https://gitee.com/qizr_admin/LAMPMainWidget)"};
}
QHash<QString, MapLayer*>RasterMainWidget::mMaps{};
QString
RasterMainWidget::srcUrl() {
return QString{R"(https://gitee.com/qizr_admin/LAMPMainWidget)"};
}
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();
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();
//mUi->layerList->setCurrentItem(mLayerList.first());
this->show();// 强制显示窗口
// 绑定消息显示
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->tutorialAction, &QAction::triggered, this, &RasterMainWidget::tutorialHanle);
QObject::connect(mUi->srcAction, &QAction::triggered, this, &RasterMainWidget::srcHandle);
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);
RasterMessageShow::RasterWidgetMessageShow* messageshow = RasterMessageShow::RasterWidgetMessageShow::getInstance(this);
messageshow->bandingTextBrowserMessage(this->mUi->textBrowserMessage);
}
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 (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::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;
}
}
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));
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 zoomOutHandle(bool checked);
void drawlineHandle(bool checked);
void tutorialHanle(bool checked);
void srcHandle(bool checked);
void sponsorHandle(bool checked);
void refreshHandle(bool checked);
void selectHandle(bool checked);
@ -70,10 +69,6 @@ namespace LAMPMainWidget {
private:
QWidget* spacerWiget(int width) const;
protected:
static QString tutorialUrl();
static QString srcUrl();
private slots:
void on_drawArea_triggered();
void on_addPlaneaction_triggered();

10
RasterMainWidgetGUI/RasterMainWidget/RasterMainWidget.ui
View File

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

21
RasterMainWidgetGUI/RasterMainWidget/gaodenormalprovider.cpp
View File

@ -4,17 +4,18 @@
namespace LAMPMainWidget {
GaodeNormalProvider::GaodeNormalProvider(QObject *parent)
: TmsProvider(parent) {
initCache();
}
GaodeNormalProvider::GaodeNormalProvider(QObject* parent)
: TmsProvider(parent) {
initCache();
}
QString
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);
}
//http://wprd01.is.autonavi.com/appmaptile?x={x}&y={y}&z={z}&lang=zh_cn&size=1&scl=1&style=6
QString
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);
}
//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 {
PointXY
MapCanvas::defaultMapCenter() {
return PointXY{116.4074, 39.9042};
}
PointXY
MapCanvas::defaultMapCenter() {
return PointXY{ 116.4074, 39.9042 };
}
MapCanvas::MapCanvas(QWidget *parent)
: QGraphicsView(parent),
mScene(nullptr),
mMapExtent(),
mViewExtent(),
mDragRect(),
mIsDragging(false),
mLayers(),
mCurrentLayer(nullptr),
mCrs(nullptr),
mMapCenter(defaultMapCenter()),
mZoomValue(kDefaultZoomValue),
mLastXY(),
mMapUpdateTimer(nullptr),
mCurrentTool(nullptr),
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(QWidget* parent)
: QGraphicsView(parent),
mScene(nullptr),
mMapExtent(),
mViewExtent(),
mDragRect(),
mIsDragging(false),
mLayers(),
mCurrentLayer(nullptr),
mCrs(nullptr),
mMapCenter(defaultMapCenter()),
mZoomValue(kDefaultZoomValue),
mLastXY(),
mMapUpdateTimer(nullptr),
mCurrentTool(nullptr),
mMapTools() {
MapCanvas::~MapCanvas() {
mLayers.clear();
delete mScene;
delete mCurrentLayer;
delete mMapUpdateTimer;
}
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);
}
void
MapCanvas::mousePressEvent(QMouseEvent *event) {
if (mCurrentTool) {
mCurrentTool->execute(event);
}
QGraphicsView::mousePressEvent(event);
}
MapCanvas::~MapCanvas() {
mLayers.clear();
delete mScene;
delete mCurrentLayer;
delete mMapUpdateTimer;
}
void
MapCanvas::mouseReleaseEvent(QMouseEvent *event) {
if (mCurrentTool) {
mCurrentTool->execute(event);
}
QGraphicsView::mouseReleaseEvent(event);
}
void
MapCanvas::mousePressEvent(QMouseEvent* event) {
if (mCurrentTool) {
mCurrentTool->execute(event);
}
QGraphicsView::mousePressEvent(event);
}
void
MapCanvas::wheelEvent(QWheelEvent *event) {
int delta = event->angleDelta().y() / 120;
int zoom = zoomValue();
zoom += delta;
setZoomValue(zoom);
}
void
MapCanvas::mouseReleaseEvent(QMouseEvent* event) {
if (mCurrentTool) {
mCurrentTool->execute(event);
}
QGraphicsView::mouseReleaseEvent(event);
}
void
MapCanvas::resizeEvent(QResizeEvent *event) {
updateViewExtent(true);
}
void
MapCanvas::wheelEvent(QWheelEvent* event) {
int delta = event->angleDelta().y() / 120;
int zoom = zoomValue();
zoom += delta;
setZoomValue(zoom);
}
void MapCanvas::mouseMoveEvent(QMouseEvent *event)
{
if (mCurrentTool) {
mCurrentTool->execute(event);
}
QGraphicsView::mouseMoveEvent(event);
}
void
MapCanvas::resizeEvent(QResizeEvent* event) {
updateViewExtent(true);
}
void
MapCanvas::refreshMap() {
QMapIterator<QString, MapLayer *> iterator(mLayers);
while (iterator.hasNext()) {
iterator.next();
iterator.value()->map()->setViewExtent(mViewExtent);
iterator.value()->update();
}
mScene->update();
}
void MapCanvas::mouseMoveEvent(QMouseEvent* event)
{
if (mCurrentTool) {
mCurrentTool->execute(event);
}
QGraphicsView::mouseMoveEvent(event);
}
void
MapCanvas::addLayer(MapLayer *const layer) {
if (!layer)
return;
void
MapCanvas::refreshMap() {
QMapIterator<QString, MapLayer*> iterator(mLayers);
while (iterator.hasNext()) {
iterator.next();
iterator.value()->map()->setViewExtent(mViewExtent);
iterator.value()->update();
}
mScene->update();
}
if (mLayers.contains(layer->id())) {
qWarning() << layer->id() << "图层已存在";
return;
}
void
MapCanvas::addLayer(MapLayer* const layer) {
if (!layer)
return;
mLayers.insert(layer->id(), layer);
if (mLayers.count() == 1) {
setCurrentLayer(layer->id());
}
mScene->addItem(layer->map());
refreshMap();
}
if (mLayers.contains(layer->id())) {
qWarning() << layer->id() << "图层已存在";
return;
}
void
MapCanvas::setZoomValue(const int zoom) {
mZoomValue = normalizeZoom(zoom);
zoomChanged(mZoomValue);
mLayers.insert(layer->id(), layer);
if (mLayers.count() == 1) {
setCurrentLayer(layer->id());
}
mScene->addItem(layer->map());
refreshMap();
}
/// 更新每个图层的zoom值
QMapIterator<QString, MapLayer *> iterator(mLayers);
while (iterator.hasNext()) {
iterator.next();
iterator.value()->setZoomValue(mZoomValue);
}
void
MapCanvas::setZoomValue(const int zoom) {
mZoomValue = normalizeZoom(zoom);
zoomChanged(mZoomValue);
/// 更新可视区域的内容
updateViewExtent(true);
}
/// 更新每个图层的zoom值
QMapIterator<QString, MapLayer*> iterator(mLayers);
while (iterator.hasNext()) {
iterator.next();
iterator.value()->setZoomValue(mZoomValue);
}
void
MapCanvas::updateViewExtent(bool reset) {
if (!mCurrentLayer) {
qDebug() << "未设置当前图层，视图区域无法更新";
return;
}
/// 更新可视区域的内容
updateViewExtent(true);
}
if (reset) {
/// 重置视图区域
mScene->setSceneRect(mCurrentLayer->extent());
QRectF testrect=mCurrentLayer->extent();
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 {
/// 视图偏移并重置偏移属性
mViewExtent.translate(-mDragRect.width(), -mDragRect.height());
mDragRect.setRect(0, 0, 0, 0);
void
MapCanvas::updateViewExtent(bool reset) {
if (!mCurrentLayer) {
qDebug() << "未设置当前图层，视图区域无法更新";
return;
}
/// 更新地图可视区域中心点
QPointF mapCenter = mViewExtent.center();
PointXY crsCenter{mapCenter.x() * resolution(), mapCenter.y() * resolution()};
mMapCenter = mCrs->inverse(crsCenter);
mapCenterChanged(mMapCenter);
}
if (reset) {
/// 重置视图区域
mScene->setSceneRect(mCurrentLayer->extent());
QRectF testrect = mCurrentLayer->extent();
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());
refreshMap();
}
/// 更新地图可视区域中心点
QPointF mapCenter = mViewExtent.center();
PointXY crsCenter{ mapCenter.x() * resolution(), mapCenter.y() * resolution() };
mMapCenter = mCrs->inverse(crsCenter);
mapCenterChanged(mMapCenter);
}
void
MapCanvas::setCrs(const CRS *const crs) {
mCrs = crs;
crsChanged();
updateViewExtent(true);
}
/// 刷新地图
centerOn(mViewExtent.center());
refreshMap();
}
void
MapCanvas::setCurrentLayer(const QString &id) {
if (!mLayers.contains(id)) {
qWarning() << "未添加图层=>" << id;
return;
}
mCurrentLayer = mLayers[id];
if (!mCrs) {
setCrs(&mCurrentLayer->crs());
}
updateViewExtent(true);
}
void
MapCanvas::setCrs(const CRS* const crs) {
mCrs = crs;
crsChanged();
updateViewExtent(true);
}
double
MapCanvas::scale() const {
return logicalDpiX() * resolution() * 39.37 / 100;;
}
void
MapCanvas::setCurrentLayer(const QString& id) {
if (!mLayers.contains(id)) {
qWarning() << "未添加图层=>" << id;
return;
}
mCurrentLayer = mLayers[id];
if (!mCrs) {
setCrs(&mCurrentLayer->crs());
}
updateViewExtent(true);
}
double
MapCanvas::resolution() const {
if (!mCurrentLayer) {
qWarning() << "未设置当前图层，无法获取分辨率";
return 0;
}
double
MapCanvas::scale() const {
return logicalDpiX() * resolution() * 39.37 / 100;;
}
return mCurrentLayer->resolution();
}
double
MapCanvas::resolution() const {
if (!mCurrentLayer) {
qWarning() << "未设置当前图层，无法获取分辨率";
return 0;
}
int
MapCanvas::zoomValue() const {
if (!mCurrentLayer) {
qWarning() << "未设置当前图层，默认返回zoom值为0";
return 0;
}
return mCurrentLayer->resolution();
}
return mCurrentLayer->zoomValue();
}
int
MapCanvas::zoomValue() const {
if (!mCurrentLayer) {
qWarning() << "未设置当前图层，默认返回zoom值为0";
return 0;
}
int
MapCanvas::normalizeZoom(const int zoom) const {
int z{};
if (zoom <= kMinZoomValue) {
z = kMinZoomValue;
} else if (z >= kMaxZoomValue) {
z = kMaxZoomValue;
} else {
z = zoom;
}
return mCurrentLayer->zoomValue();
}
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
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;
}
return z;
}
bool
MapCanvas::selectTool(const QString &tool) {
if (!mMapTools.contains(tool)) {
qWarning() << QString("%1工具不存在").arg(tool);
return false;
}
PointXY
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;
}
auto toolPtr = mMapTools.value(tool);
if (mCurrentTool) {
mCurrentTool->deSetup();
}
mCurrentTool = toolPtr;
toolPtr->setup();
bool
MapCanvas::selectTool(const QString& tool) {
if (!mMapTools.contains(tool)) {
qWarning() << QString("%1工具不存在").arg(tool);
return false;
}
return true;
}
auto toolPtr = mMapTools.value(tool);
if (mCurrentTool) {
mCurrentTool->deSetup();
}
mCurrentTool = toolPtr;
toolPtr->setup();
void MapCanvas::timerEvent(QTimerEvent *event)
{
MapToolAddplane *maptoolAddplane=dynamic_cast<MapToolAddplane*>(mMapTools["addplane_tool"]);
QList<MapAutoplane*> planes=maptoolAddplane->getPlanes();
foreach(MapAutoplane *plane,planes){
plane->updatePos();
}
}
return true;
}
void
MapCanvas::setupTools() {
auto panTool = new MapToolPan(this);
mMapTools.insert(panTool->id(), panTool);
void MapCanvas::timerEvent(QTimerEvent* event)
{
MapToolAddplane* maptoolAddplane = dynamic_cast<MapToolAddplane*>(mMapTools["addplane_tool"]);
QList<MapAutoplane*> planes = maptoolAddplane->getPlanes();
foreach(MapAutoplane * plane, planes) {
plane->updatePos();
}
}
auto zoominTool = new MapToolZoomIn(this);
mMapTools.insert(zoominTool->id(), zoominTool);
void
MapCanvas::setupTools() {
auto panTool = new MapToolPan(this);
mMapTools.insert(panTool->id(), panTool);
auto zoomoutTool = new MapToolZoomOut(this);
mMapTools.insert(zoomoutTool->id(), zoomoutTool);
auto zoominTool = new MapToolZoomIn(this);
mMapTools.insert(zoominTool->id(), zoominTool);
auto selectTool = new MapToolSelect(this);
mMapTools.insert(selectTool->id(), selectTool);
auto zoomoutTool = new MapToolZoomOut(this);
mMapTools.insert(zoomoutTool->id(), zoomoutTool);
auto drawlineTool=new MapToolDrawline(this);
mMapTools.insert(drawlineTool->id(),drawlineTool);
auto selectTool = new MapToolSelect(this);
mMapTools.insert(selectTool->id(), selectTool);
auto drawareTool=new MapToolDrawarea(this);
mMapTools.insert(drawareTool->id(),drawareTool);
auto drawlineTool = new MapToolDrawline(this);
mMapTools.insert(drawlineTool->id(), drawlineTool);
auto addplaneTool=new MapToolAddplane(this);
mMapTools.insert(addplaneTool->id(),addplaneTool);
auto drawareTool = new MapToolDrawarea(this);
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>
namespace LAMPMainWidget {
class MapLayer;
class MapTool;
/**
* 地图容器类，继承自QGraphicsView。
* 整个地图的渲染都是基于“Qt GraphicsView Framework”设计。
*/
class MapCanvas : public QGraphicsView {
Q_OBJECT
class MapLayer;
class MapTool;
/**
* 地图容器类，继承自QGraphicsView。
* 整个地图的渲染都是基于“Qt GraphicsView Framework”设计。
*/
class MapCanvas : public QGraphicsView {
Q_OBJECT
signals:
void zoomChanged(int zoom);
void crsChanged();
void clicked(PointXY pos);
void mapCenterChanged(PointXY pos);
signals:
void zoomChanged(int zoom);
void crsChanged();
void clicked(PointXY pos);
void mapCenterChanged(PointXY pos);
friend class MapToolPan;
friend class MapToolZoomIn;
friend class MapToolZoomOut;
friend class MapToolSelect;
friend class MapToolPan;
friend class MapToolZoomIn;
friend class MapToolZoomOut;
friend class MapToolSelect;
public:
explicit MapCanvas(QWidget *parent = nullptr);
~MapCanvas() override;
public:
explicit MapCanvas(QWidget* parent = nullptr);
~MapCanvas() override;
public:
/**
* 刷新地图容器，这会更新每一个显示的图层的内容
*/
void refreshMap();
public:
/**
* 刷新地图容器，这会更新每一个显示的图层的内容
*/
void refreshMap();
/**
* 向容器中添加图层，默认情况下容器会使用首个图层的坐标系作为自身的坐标系
* @param layer 图层对象
*/
void addLayer(MapLayer *layer);
/**
* 向容器中添加图层，默认情况下容器会使用首个图层的坐标系作为自身的坐标系
* @param layer 图层对象
*/
void addLayer(MapLayer* layer);
/**
* 获取地图容器的比例尺
* @return 容器的比例尺
*/
double scale() const;
/**
* 获取地图容器的比例尺
* @return 容器的比例尺
*/
double scale() const;
/**
* 获取地图容器的解析度
* @return
*/
double resolution() const;
/**
* 获取地图容器的解析度
* @return
*/
double resolution() const;
/**
* 获取容器的zoom值
* @return 容器的zoom值
*/
int zoomValue() const;
/**
* 获取容器的zoom值
* @return 容器的zoom值
*/
int zoomValue() const;
/**
* 设置容器的zoom值
* @param zoom zoom值
*/
void setZoomValue(int zoom);
/**
* 设置容器的zoom值
* @param zoom zoom值
*/
void setZoomValue(int zoom);
/**
* 获取容器当前所显示的地图区域
* @return 当前所显示地图区域
*/
const QRectF &viewExtent() const { return mViewExtent; }
/**
* 获取容器当前所显示的地图区域
* @return 当前所显示地图区域
*/
const QRectF& viewExtent() const { return mViewExtent; }
/**
* 设置容器坐标系，设置过后会更新所有图层坐标系。
* 默认会对容器中的图层做投影变换处理
* @param crs 坐标系
*/
void setCrs(const CRS *crs);
/**
* 设置容器坐标系，设置过后会更新所有图层坐标系。
* 默认会对容器中的图层做投影变换处理
* @param crs 坐标系
*/
void setCrs(const CRS* crs);
/**
* 获取地图容器的坐标系
* @return 地图容器坐标系
*/
const CRS &crs() const { return *mCrs; }
/**
* 获取地图容器的坐标系
* @return 地图容器坐标系
*/
const CRS& crs() const { return *mCrs; }
/**
* 设置地图容器的当前选中图层
* @param id 图层的id
*/
void setCurrentLayer(const QString &id);
/**
* 设置地图容器的当前选中图层
* @param id 图层的id
*/
void setCurrentLayer(const QString& id);
/**
* 获取地图容器当前选中图层
* @return 当前选中图层
*/
const MapLayer *currentLayer() { return mCurrentLayer; }
/**
* 获取地图容器当前选中图层
* @return 当前选中图层
*/
const MapLayer* currentLayer() { return mCurrentLayer; }
/**
* 获取地图当前视图中心点经纬度坐标
* @return 视图中心点经纬度坐标
*/
const PointXY &mapCenter() const { return mMapCenter; }
/**
* 获取地图当前视图中心点经纬度坐标
* @return 视图中心点经纬度坐标
*/
const PointXY& mapCenter() const { return mMapCenter; }
/**
* 选择地图工具
* @param tool 工具名称
* @return 是否选择成功
*/
bool selectTool(const QString &tool);
/**
* 选择地图工具
* @param tool 工具名称
* @return 是否选择成功
*/
bool selectTool(const QString& tool);
void timerEvent(QTimerEvent *event);
void timerEvent(QTimerEvent* event);
protected:
/**
* 更新容器的可视化区域。
* 每次拖动操作和resize事件会调用该方法
*/
void updateViewExtent(bool reset = false);
protected:
/**
* 更新容器的可视化区域。
* 每次拖动操作和resize事件会调用该方法
*/
void updateViewExtent(bool reset = false);
/**
* 将屏幕坐标转换为经纬度坐标
* @param point 屏幕上点
* @return 经纬度坐标
*/
PointXY pixel2Lonlat(const QPointF &point) const;
/**
* 将屏幕坐标转换为经纬度坐标
* @param point 屏幕上点
* @return 经纬度坐标
*/
PointXY pixel2Lonlat(const QPointF& point) const;
/**
* 初始设置地图必须具备的工具
*/
void setupTools();
/**
* 初始设置地图必须具备的工具
*/
void setupTools();
private:
/**
* 确保zoom值在限定的范围之内
* @param zoom 待设置zoom值
* @return 可使用zoom值
*/
int normalizeZoom(int zoom) const;
private:
/**
* 确保zoom值在限定的范围之内
* @param zoom 待设置zoom值
* @return 可使用zoom值
*/
int normalizeZoom(int zoom) const;
protected:
void mousePressEvent(QMouseEvent *event) override;
void mouseReleaseEvent(QMouseEvent *event) override;
void wheelEvent(QWheelEvent *event) override;
void resizeEvent(QResizeEvent *event) override;
void mouseMoveEvent(QMouseEvent *event) override;
protected:
void mousePressEvent(QMouseEvent* event) override;
void mouseReleaseEvent(QMouseEvent* event) override;
void wheelEvent(QWheelEvent* event) override;
void resizeEvent(QResizeEvent* event) override;
void mouseMoveEvent(QMouseEvent* event) override;
protected:
QGraphicsScene *mScene;
QRectF mMapExtent;
QRectF mViewExtent;
QRectF mDragRect;
bool mIsDragging;
QMap<QString, MapLayer *> mLayers;
MapLayer *mCurrentLayer;
const CRS *mCrs;
PointXY mMapCenter;
int mZoomValue;
PointXY mLastXY;
QTimer *mMapUpdateTimer;
MapTool *mCurrentTool;
QHash<QString, MapTool *> mMapTools;
protected:
QGraphicsScene* mScene;
QRectF mMapExtent;
QRectF mViewExtent;
QRectF mDragRect;
bool mIsDragging;
QMap<QString, MapLayer*> mLayers;
MapLayer* mCurrentLayer;
const CRS* mCrs;
PointXY mMapCenter;
int mZoomValue;
PointXY mLastXY;
QTimer* mMapUpdateTimer;
MapTool* mCurrentTool;
QHash<QString, MapTool*> mMapTools;
private:
const static int kDefaultZoomValue{8};
static const int kMaxZoomValue{20};
static const int kMinZoomValue{1};
private:
const static int kDefaultZoomValue{ 8 };
static const int kMaxZoomValue{ 20 };
static const int kMinZoomValue{ 1 };
protected:
static PointXY defaultMapCenter();
};
protected:
// 设置默认地图中心点
static PointXY defaultMapCenter();
};
}

40
RasterMainWidgetGUI/RasterMainWidget/mapcanvasmap.cpp
View File

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

156
RasterMainWidgetGUI/RasterMainWidget/maplayer.cpp
View File

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

230
RasterMainWidgetGUI/RasterMainWidget/maplayer.h
View File

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

60
RasterMainWidgetGUI/RasterMainWidget/maptool.h
View File

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

56
RasterMainWidgetGUI/RasterMainWidget/maptoolpan.cpp
View File

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

6
RasterMainWidgetGUI/RasterMainWidget/ostnormalprovider.cpp
View File

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

335
RasterMainWidgetGUI/RasterMainWidget/taskwindow.cpp
View File

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

135
RasterMainWidgetGUI/RasterMainWidget/tmslayer.cpp
View File

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

52
RasterMainWidgetGUI/RasterMainWidget/tmsproviderfactory.cpp
View File

@ -5,33 +5,35 @@
namespace LAMPMainWidget {
QHash<TmsProviders, LayerProvider *> TmsProviderFactory::mProviders{};
QHash<TmsProviders, LayerProvider*> TmsProviderFactory::mProviders{};
LayerProvider *
TmsProviderFactory::create(LAMPMainWidget::TmsProviders provider) {
LayerProvider *result = nullptr;
switch (provider) {
case OSTNormalMap:
if (mProviders.contains(OSTNormalMap)) {
result = mProviders.value(OSTNormalMap);
} else {
result = new OSTNormalProvider();
mProviders.insert(OSTNormalMap, result);
}
break;
case GaodeNormapMap:
if (mProviders.contains(GaodeNormapMap)) {
result = mProviders.value(GaodeNormapMap);
} else {
result = new GaodeNormalProvider();
mProviders.insert(GaodeNormapMap, result);
}
break;
default:break;
}
LayerProvider*
TmsProviderFactory::create(LAMPMainWidget::TmsProviders provider) {
LayerProvider* result = nullptr;
switch (provider) {
case OSTNormalMap:
if (mProviders.contains(OSTNormalMap)) {
result = mProviders.value(OSTNormalMap);
}
else {
result = new OSTNormalProvider();
mProviders.insert(OSTNormalMap, result);
}
break;
case GaodeNormapMap:
if (mProviders.contains(GaodeNormapMap)) {
result = mProviders.value(GaodeNormapMap);
}
else {
result = new GaodeNormalProvider();
mProviders.insert(GaodeNormapMap, result);
}
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>
<CopyLocalProjectReference>true</CopyLocalProjectReference>
<CopyCppRuntimeToOutputDir>true</CopyCppRuntimeToOutputDir>
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
<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'">
<ClCompile>
<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>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">

3
RasterMainWidgetGUI/RasterMainWidgetGUI.vcxproj.filters
View File

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

3
RasterMainWidgetGUI/RasterWidgetMessageShow.cpp
View File

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

2
RasterMainWidgetGUI/main.cpp
View File

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