#include "mainwindow.h"
#include "FileParser/UGModelConfigParams.h"
#include "collisiondetectionthread.h"
#include "computeoffsetpositiondialog.h"
#include "displayroutedialog.h"
#include "geospatialanalysis.h"
#include "importscenedatadialog.h"
#include "flysimulateddlg.h"
#include "maplocationdialog.h"
#include "qregularexpression.h"
#include "realtimepositioninfothread.h"
#include "routeglobalvariant.h"
//#include "QCustomPlot/qcustomplot.h"
#include "ui_mainwindow.h"

#include "routeanalysisdialog.h"
#include "saveroutedialog.h"
#include "bindroutedialog.h"
#include "loadonlinemapdialog.h"
#include "geofileparser.h"
#include "layeroperator.h"
#include "geofeatureoperator.h"
#include "mapthread.h"
#include "settingflightpoint3ddialog.h"
#include "plane.h"
#include "showplane.h"
#include "showplane3d.h"
#include "chart.h"

#include <QToolBar>
#include <QToolButton>
#include <QMessageBox>
#include <QFileDialog>
#include <QDebug>
#include <QLabel>
#include <QDialog>
#include <QProgressBar>
#include <QProgressDialog>
#include <QRegularExpressionValidator>
#include <QThreadPool>
#include <QSystemTrayIcon>

#include "math.h"
#include "cmath"
#include "mapdatamaneger.h"
#include "loadscenedatathread.h"
#include "symbolresources.h"
#include "QNotify/NotifyManager.h"
//三维
#include "Toolkit/UGEnvironment.h"
#include "sceneview.h"
#include "workspace.h"
#include "Scene/UGTrackingLayer3D.h"
#include "Scene/UGPlottingLayer3D.h"
#include "Scene/UGScreenLayer3D.h"
#include "Geometry3D/UGGeoPoint3D.h"
#include "Geometry3D/UGGeoModelPro.h"
#include "Render/UGCameraGlobal.h"
#include "Render/UGKmlFeature3D.h"
#include "Scene/UGLayer3DFactory.h"
#include "Scene/UGLayer3DManager.h"
#include "Render/UGRenderManager.h"
#include "Render/UGRenderModelPro.h"
#include "Render/UGRenderLine3D.h"
#include "Render/UGRenderPoint3D.h"
#include "Base3D/UGBoundingBox.h"
#include "Geometry/UGGeoPicture.h"
#include "Geometry3D/UGGeoPlacemark.h"
#include "Geometry3D/UGGeoBillboard.h"
#include "Geometry3D/UGGeoLine3D.h"
#include "GeometryPlot/UGGOLibraryManager.h"

#include "Layer3DFile/UGLayer3DDynamic.h"
#include "Layer3DFile/UGLayer3DModel.h"
#include "Layer3DFile/UGLayer3DVector.h"
//#include "Layer3DTree/UGLayer3DTree.h"
#include "Base3D/UGMathEngine.h"
#include "Scene/UGFlyRoute.h"
#include "Scene/UGFlyManager.h"
#include "Scene/UGFlyRoutes.h"
#include "Scene/UGFlyRouteStops.h"
#include "Scene/UGFlyRouteStop.h"
#include "Scene/UGFlyInterpolatedTool.h"
//SuperMap库
#include "qmapcontrol.h"//引用QMapControl头文件
#include "QDynamicLayers.h"
#include "QDynamicLayer.h"
#include "QDynamicObject.h"
#include "translator.h"//引用QMapControl工程中的头文件
#include "Workspace/UGWorkspace.h"//引用iObjects C++组件中的工作空间UGWorkspace头文件
#include "Workspace/UGResources.h"
#include "Map/UGMap.h"//引用iObjects C++组件中的UGMap.h头文件
#include "MapEditor/UGMapEditorWnd.h"
#include "Geometry/UGGeometry.h"
#include "Geometry/UGGeoLine.h"
#include "Geometry/UGGeoMultiPoint.h"
//#include "Geometry/UGGeoRegion.h"
#include "Projection/UGPrjCoordSys.h"
#include "Engine/UGTable.h"
#include "Engine/UGDatasetVector.h"
#include "Engine/UGRecordset.h"
//#include "Toolkit/UGProgress.h"
//#include "Toolkit/UGRegistry.h"
#include "DataExchange/UGDataExchange.h"
#include "FileParser/UGKMLConfigParams.h"
#include "FileParser/UGKMZConfigParams.h"
#include "FileParser/UGGTiffConfigParams.h"
#include "FileParser/UGExchangeParamsManager.h"
//#include "FileParser/UGFileParseModel.h"
//#include "FileParser/UGFileParseFactory.h"
//#include "FileParser/UGFileParseManager.h"
//#include "FileParser/UG3dsConfigParams.h"
//#include "FileParser/UGFileParserTile.h"
//#include "FileParser/UGSimpleConfigParams.h"
//#include "FileParser/UGFileParseVector.h"
//#include "private/Layer3DTree/UGKmlContainerSeal.h"
//#include "private/Layer3DTree/UGLayer3DTree.h"
//#include "private/Layer3DGML/UGLayer3DGML.h"
#include "private/Layer3DFile/UGLayer3DDynamic.h"
#include "private/Layer3DDatasetModel/UGLayer3DDatasetModelPro.h"
#include "Symbol/UGMarkerSymbolLib.h"
#include "GeoOperation/UGGeoOperator.h"

//工作空间及数据源默认存储路径及别名
const QString wsName = "MapWorkspace"; //工作空间别名
QString wsFullName; //工作空间存储路径
QString routeFullName; //航线数据存储路径
/*2D*/
const QString routeName = "Route";   //航线矢量数据源别名
UGString pointSetAlias = _U("Marks"); //点数据集别名
UGString lineSetAlias = _U("FlightLines"); //线数据集别名
UGString polygonSetAlias = _U("Geofencing"); //面数据集别名
UGString NodeLabelSetAlias = _U("NodeLabel"); //节点标签数据集别名
/*3D*/
//const QString route3DName = "Scene";   //三维场景数据源别名
UGString line3DSetAlias = _U("FlightLines3D"); //3D线数据集别名

//设置线段自动闭合
void UGSTDCALL AfterGeometryAddedCallback(UGlong pWnd, UGbool &bCancel, UGint nGeometryID, UGLayer *pLayer)
{//此回调函数已经往数据集添加了对象，bCancel字段为是否添加（本质是将已添加的记录删除）
    //nGeometryID 对应属性表的"SmID"字段，该字段默认是被隐藏
    qDebug()<<"******************nGeometryID:"<<nGeometryID;

    QMapControl* pControl = (QMapControl*)pWnd;
    pControl->resetWayPointLabel();
    UGRecordsetPtr editRes = pLayer->GetEditRecordset(); //只包含当前编辑线段的一条记录
//    editRes->Edit();

    UGDatasetVector* dv = (UGDatasetVector*)(pLayer->GetDataset().get());

    //对地图操作一下，防止弹出Dialog后地图消失
    QPoint p = pControl->getLMousePressPoint();
    pControl->GetUGMapWnd()->OnMouseMove(pControl->getGraphics(),0,Translator::QPoint2UGPoint(p));
    //调出航线设置对话框
    saveRouteDialog dlg;
    dlg.setMaxValue(1);
    dlg.setDrawMode(1);
    int ret = dlg.exec();

    UGGeometry* pGeometry = NULL;
    UGGeoLine l;
    editRes->GetGeometry(pGeometry);

    QMap<QString,QString> fieldsValue;
    GeoFeatureOperator geoFtOperator;
    RouteGlobalVariant routeGVar;
    if(ret==QDialog::Accepted)
    {
        fieldsValue.insert(routeGVar.routeFieldsName.RouteID,QString::number(dv->GetObjectCount()));
        fieldsValue.insert(routeGVar.routeFieldsName.RouteHeight,QString::number(dlg.getRouteHeight()[1]));
        fieldsValue.insert(routeGVar.routeFieldsName.RouteNumber,QString::number(dlg.getRouteNumber()[1]));
        fieldsValue.insert(routeGVar.routeFieldsName.RouteType,QString::number(dlg.getRouteType()[1]));
        fieldsValue.insert(routeGVar.routeFieldsName.IsClosedRoute,QString::number(dlg.getRouteClosedState()[1]));
        int s = geoFtOperator.importFeatureAttribute(dv,pGeometry,fieldsValue,false);
        if(s==1)
        {
            bCancel = true;
        }
    }

    if(dlg.isClickedCloseBtn)
    {
        bCancel = true;
    }
    /*
    if(ret==QDialog::Accepted)
    {
        qint16 routeID_dlg = dv->GetObjectCount(); //数量为属性集已有记录数+1
        double routeHeight_dlg = dlg.getRouteHeight()[1];
        int  routeType_dlg = dlg.getRouteType()[1];
        int routeNumber_dlg = dlg.getRouteNumber()[1];
        UGString routeName_dlg = Translator::QStr2UGStr(dlg.getRouteText()+QString::number(routeNumber_dlg));


        QString queryFilter = "RouteType=" + QString::number(routeType_dlg) + " and " +
                               ("RouteNumber=") + QString::number(routeNumber_dlg);

        UGRecordsetPtr saveRes = pControl->queryFeature(dv,Translator::QStr2UGStr(queryFilter));

        UGGeometry* pTem = NULL;
        UGGeoLine l;

        if(dlg.isCloseRoute())
        {//自动闭合线段
            editRes->GetGeometry(pTem,0);
            pTem->ConvertToLine(l,0);
            UGPoint2D addPoint = l.GetStartNode();
            l.InsertPoint(0,l.GetPointCount(),addPoint); //添加首节点
            editRes->SetGeometry(l); //替换原线段
            editRes->ModifyFieldValue(_U("IsClosedRoute"),1);
        }
        else
        {
            editRes->ModifyFieldValue(_U("IsClosedRoute"),0);
        }

        if(!saveRes->IsEmpty())
        {//记录已存在，覆盖
            QMessageBox::StandardButton saveBtn;
            saveBtn = QMessageBox::question(pControl, u8"提示", u8"航线已存在，是否覆盖?", QMessageBox::Yes|QMessageBox::No);
            if (saveBtn == QMessageBox::Yes)
            {
                saveRes->Edit();
                saveRes->SetGeometry(l);
                saveRes->ModifyFieldValue(_U("RouteHeight"),UGVariant(routeHeight_dlg));
                saveRes->Update();
                bCancel = true;
            }
            else
            {

            }
        }
        else
        {//航线不存在，新增航线
            editRes->ModifyFieldValue(_U("RouteID"),UGVariant(routeID_dlg));
            editRes->ModifyFieldValue(_U("RouteNumber"),UGVariant(routeNumber_dlg));
            editRes->ModifyFieldValue(_U("RouteType"),UGVariant(routeType_dlg));
            editRes->ModifyFieldValue(_U("RouteHeight"),UGVariant(routeHeight_dlg));
            editRes->ModifyFieldValue(_U("RouteName"),UGVariant(routeName_dlg));
            //提交记录修改
            editRes->Update();
        }
    }
    */
    if(ret==QDialog::Rejected)
    {
        bCancel = true;
    }

//    pControl->GetMap()->m_Layers.ClearLayersSelection();
//        pControl->GetMap()->m_Layers.Remove(pLayer);
    dv = NULL;
}

#pragma region{
//void UGSTDCALL AfterGeometryDeletedProcCallback(UGlong pWnd, UGbool &bCancel, UGint nGeometryID, UGLayer *pLayer)
//{
//    qDebug()<<"**************************AfterGeometryDeletedProcCallback";
//    qDebug()<<"**************************AfterGeometryDeletedProcCallback";
//}

//void UGSTDCALL BeforeGeometryDeletedProcCallback(UGlong pWnd, UGbool &bCancel, UGint nGeometryID, UGLayer *pLayer)
//{
//    qDebug()<<"**************************BeforeGeometryDeletedProcCallback";
//    qDebug()<<"**************************BeforeGeometryDeletedProcCallback";
//}



void UGSTDCALL BeginEditHandleProcCallback(UGlong pWnd, UGbool &bCancel, UGint nEditSelType, UGint *pHandle, UGint nCount, UGdouble dx, UGdouble dy)
{
    qDebug()<<"**************************BeginEditHandleProcCallback";
    qDebug()<<"**************************nEditSelType"<<nEditSelType;
    qDebug()<<"**************************nCount"<<nCount;
}

//void UGSTDCALL EditHandleCanceledProcCallback(UGlong pWnd, UGint nEditSelType, UGint *pHandle, UGint nCount)
//{
//    qDebug()<<"**************************EditHandleCanceledProcCallback";
//    qDebug()<<"**************************EditHandleCanceledProcCallback";
//}

//void UGSTDCALL AfterGeometryModifiedProcCallback(UGlong pWnd, UGint nGeometryID, UGLayer *pLayer)
//{
//    qDebug()<<"**************************AfterGeometryModifiedProcCallback";
//    qDebug()<<"**************************AfterGeometryModifiedProcCallback";
//}

void UGSTDCALL BeforeGeometryModifiedProcCallback(UGlong pWnd, UGbool &bCancel, UGint nGeometryID, UGLayer *pLayer)
{
    qDebug()<<"**************************BeforeGeometryModifiedProcCallback";
    qDebug()<<"**************************BeforeGeometryModifiedProcCallback";
}


//void UGSTDCALL AffterDatasetModifiedProcCallback(void* pLayerDataset,UGint nID,UGRect2D rect2D,UGModifyDatasetFlag flg)
//{
//    qDebug()<<"**************************BeforeDatasetModifiedProcCallback";
//    qDebug()<<"**************************BeforeDatasetModifiedProcCallback";
//}

//void UGSTDCALL TrackedProcCallback(UGlong pWnd)
//{
//    qDebug()<<"**************************TrackedProcCallback";
//    qDebug()<<"**************************TrackedProcCallback";
//}
#pragma endregion}


void UGSTDCALL AfterPointInputCallback(UGlong pWnd, UGdouble &dx, UGdouble &dy, UGdouble &dz)
{//dx:lon  dy:lat
    qDebug()<<"**************************AfterPointInputCallback";
    qDebug()<<"**************************AfterPointInputCallback";

    qDebug()<<"**************************x:"<<dx;

    QMapControl* pControl = (QMapControl*)pWnd;
//    emit pControl->beginTracking(true); //
    qDebug()<<"******************drawMode:"<<pControl->drawMode;

    if(pControl->drawMode>1) emit pControl->sendPreviousPoint(dx,dy);

//    ComputeOffsetPositionDialog inputPosDlg;
//    inputPosDlg.exec();

//    double bearing = inputPosDlg.getBearing().toDouble();
//    double dist = inputPosDlg.getDistance().toDouble();
}


void UGSTDCALL GeometrySelectedCallback(UGlong pWnd, UGint nSelectedGeometryCount)
{//左键点击选中触发
    qDebug()<<"**************************GeometrySelectedCallback";
//    qDebug()<<"**************************nSelectedGeometryCount:"<<nSelectedGeometryCount;
    QMapControl* pMapControl = (QMapControl*)pWnd;
    if(pMapControl->getEditStatus())
    {//编辑模式下设置当前选中图层可编辑
        UGLayer* selectedLayer = pMapControl->getSelectionLayer();
        if(!selectedLayer->IsEditable())
        {
            pMapControl->setEditable(pMapControl->getSelectionLayer(),true);
        }

        selectedLayer = NULL;
    }

    pMapControl = NULL;

    /*
    LayerOperator LO;
    QMap<int,QStringList> featureInfo;
    featureInfo = LO.getSelectedFeature(pControl->GetMap());

    QStringList filterlist;
    QList<int> types = featureInfo.keys();
    for(int i = 0; i < types.size(); i++)
    {
        filterlist<< "(RouteNumber in (" + featureInfo[types[i]].join(",") + ") and " + "RouteType = " + QString::number(types[i]) + ")";
    }
    QString filter = filterlist.join(" or ");
    qDebug()<<"**************************GeometryID:"<< filter;
    */
}



MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    drawMode = 0;

    setupUI(this);//调用界面构建函数

    addMapConnect();//调用连接信号和槽的函数

    addEditConnect();

    // 给窗口设置策略: Qt::DefaultContextMenu
    // 在窗口中按下鼠标右键, 这个事件处理器函数被qt框架调用 QWidget::contextMenuEvent()
    setContextMenuPolicy(Qt::DefaultContextMenu);

    SymbolResources symbolRs;
    symbolRs.setResources(m_pWorkspace->GetResources());
    symbolRs.reLoading();
    symbolRs.addSymbol();

//    UGString symbolPath = _U("D:/Symbol/Plane.sym");
//    UGMarkerSymbolLib* ms = m_pWorkspace->GetResources()->GetMarkerSymbolLib();
//    bool ss = ms->LoadFromFile(symbolPath);
//    bool fs = ms->SaveToFile(_U("D:/test.sym"));

    qDebug()<<"***********msCount:"<<m_pWorkspace->GetResources()->GetMarkerSymbolLib()->GetSymbolCount();
    bool s = m_pWorkspace->GetResources()->GetMarkerSymbolLib()->IsIDExisted(318);
    qDebug()<<"***********s2:"<<s;

//    QString demName = "ASTGTMV003_N32E119_dem";
//    qMapControl->addDEMDataset(demName);



    qDebug()<<"*******************z:"<<abs(-1);

    /*
    qDebug()<<"****************:" <<QDir("./").absolutePath();
    UGDatasetVector* dv = (UGDatasetVector*) m_pWorkspace->GetDataSource(0)->GetDataset(line3DSetAlias).get();
    dv->Open();
    GeoFeatureOperator geoFtOpt;
    UGRecordsetPtr res = geoFtOpt.queryFeature(dv);
    res->MoveLast();
    UGGeometry* pGeometry = NULL;
    res->GetGeometry(pGeometry);
    UGGeoLine3D* l = (UGGeoLine3D*)pGeometry;
    const UGPoint3D* p = NULL;
    p = l->GetPoints();
    for(int i =0;i<pGeometry->GetSubPntCount(0);i++)
    {
        qDebug()<<"****************x:"<<p->x;
        qDebug()<<"****************y:"<<p->y;
        qDebug()<<"****************z:"<<p->z;
        qDebug()<<"*********************";
        p++;
    }
    */

}

MainWindow::~MainWindow()
{
    delete ui;
}


//界面构建函数
void MainWindow::setupUI(QMainWindow *mainWindow)
{
    //设置应用程序界面窗体的显示标题和窗体大小
    mainWindow->setWindowTitle(tr("MapDisplay"));
    mainWindow->resize(1200,800);
    stackedWidget = new QStackedWidget;
    //将地图窗口置于应用程序窗体的中央
    mainWindow->setCentralWidget(stackedWidget);

    //工作空间初始化
    initWorkSpace();

    //二维地图容器初始化
    initMapControl();
    //添加到切换容器中
    stackedWidget->addWidget(qMapControl);
    stackedWidget->setCurrentIndex(0);

    pSceneView = NULL;
    mapType = MapType::Map2D;
    //初始化菜单
    initMenu(mainWindow);

    //初始化工具条
    initMainToolBar(mainWindow);

    //初始化消息通知对象
    initNotifyManager();
}

//全局消息通知对象初始化设置
void MainWindow::initNotifyManager()
{
    notifyManager = new NotifyManager(this);
    notifyManager->setMaxCount(5);
    notifyManager->setDisplayTime(3000);
    notifyManager->setNotifyWndSize(500, 140);
    notifyManager->setStyleSheet("#notify-background {"
                               "background: black;"
                               "}"
                               "#notify-title{"
                               "font: bold 24px 微软雅黑;"
                               "color: #eeeeee;"
                               "}"
                               "#notify-body{"
                               "font: 22px 微软雅黑;"
                               "color: #dddddd;"
                               "}"
                               "#notify-close-btn{ "
                               "border: 0;"
                               "color: #999999;"
                               "}"
                               "#notify-close-btn:hover{ "
                               "background: #444444;"
                               "}", "black");
//    QVariantMap data;
//    data["icon"] = ":/Resources/WarningLevel1.png"; // 自定义消息图标，也可传入QPixmap
//    notifyManager->notify("新消息","前方910m存在高度为126m的地形障碍物;大约45s到达;请尽快提高飞行高度!",data);
}

//工作空间初始化
void MainWindow::initWorkSpace()
{
    //存储在程序所在路径下的MapData文件夹下
    QString workspacePath = (QDir::currentPath() + "/MapData/");
    DirExist(workspacePath);//判断文件夹是否存在,不存在则创建
    //初始化工作空间
    m_pWorkspace = new UGWorkspace();
    wsFullName = workspacePath + wsName + ".smwu"; //工作空间存储路径
    routeFullName = workspacePath + routeName + ".udbx";  //航线数据存储路径
    //工作空间连接信息,用于工作空间的保存
    UGWorkspaceConnection wkCon;
    wkCon.m_strServer = Translator::QStr2UGStr(wsFullName);
    wkCon.m_nWorkspaceType = UGWorkspace::UGWorkspaceType::WS_Version_SMWU;
    wkCon.m_nVersion = m_pWorkspace->GetVersion();

    MapDataManeger mapDataManeger;

    if(!QFile::exists(wsFullName))
    {//不存在工作空间，则新建一个工作空间
        //初始化工作空间，并保存
        m_pWorkspace->SetName(Translator::QStr2UGStr(wsName));
        UGbool bSuc = m_pWorkspace->SaveAs(wkCon); //工作空间另存为
//        mapDataManeger.saveWorkSpace(m_pWorkspace,Translator::QStr2UGStr(wsFullName)); //保存工作空间
    }
    //打开工作空间
    m_pWorkspace->Open(Translator::QStr2UGStr(wsFullName));
    m_pWorkspace->m_WorkspaceConnection = wkCon;

    /**************************Map2D**************************/
    if(!m_pWorkspace->m_DataSources.IsAliasExisted(Translator::QStr2UGStr(routeName)))
    {//工作空间中无Route数据源则新建数据源
        //创建存储航线等矢量数据的数据源
        UGDataSource* pDataSource = mapDataManeger.createDataSource(routeName,UGEngineType::Spatialite,workspacePath);
        /*************************Map2D*************************/
        #pragma region{
        //创建点数据集
        UGDatasetVectorPtr pointDsv = mapDataManeger.createVectorSet(pDataSource,UGDataset::Point,pointSetAlias);
        //添加字段
        pointDsv->CreateField(_U("MarkID"),UGFieldInfo::INT32,4,0);
        pointDsv->CreateField(_U("MarkName"),UGFieldInfo::Text,255,0);

        //创建线数据集
        UGDatasetVectorPtr lineDsv = mapDataManeger.createVectorSet(pDataSource,UGDataset::Line,lineSetAlias); //创建线数据集
        //添加字段
        lineDsv->CreateField(_U("RouteID"),UGFieldInfo::INT32,4,0);
        lineDsv->CreateField(_U("RouteNumber"),UGFieldInfo::INT32,4,0);  //航线编号
        lineDsv->CreateField(_U("RouteType"),UGFieldInfo::INT32,4,0);  //航线类型
        lineDsv->CreateField(_U("RouteHeight"),UGFieldInfo::Float,4,0);  //航线高度
        lineDsv->CreateField(_U("RouteName"),UGFieldInfo::Text,255,0);    //航线名字
        lineDsv->CreateField(_U("IsClosedRoute"),UGFieldInfo::INT32,4,0);  //是否自闭合

        //创建面数据集
        UGDatasetVectorPtr polygonDsv = mapDataManeger.createVectorSet(pDataSource,UGDataset::Region,polygonSetAlias); //创建面数据集
        //添加字段
        polygonDsv->CreateField(_U("GeofencingID"),UGFieldInfo::INT32,4,0);
        polygonDsv->CreateField(_U("GeofencingName"),UGFieldInfo::Text,255,0);

//        //创建节点标签数据集
//        UGDatasetVectorPtr NodeDsv = mapDataManeger.createVectorSet(pDataSource,UGDataset::Text,NodeLabelSetAlias); //创建节点标签数据集
//        //添加字段
//        NodeDsv->CreateField(_U("NodeID"),UGFieldInfo::INT32,4);
//        NodeDsv->CreateField(_U("RouteID"),UGFieldInfo::INT32,4);
//        NodeDsv->CreateField(_U("GeofencingID"),UGFieldInfo::INT32,4);
//        NodeDsv->CreateField(_U("NodeLabel"),UGFieldInfo::Text,255);
        #pragma endregion}

        /*************************Map3D*************************/
        #pragma region{
        //创建3D线数据集
        UGDatasetVectorPtr line3DDsv = mapDataManeger.createVectorSet(pDataSource,UGDataset::LineZ,line3DSetAlias); //创建线数据集
        //添加字段
        line3DDsv->CreateField(_U("RouteID"),UGFieldInfo::INT32,4,0);
        line3DDsv->CreateField(_U("RouteNumber"),UGFieldInfo::INT32,4,0);  //航线编号
        line3DDsv->CreateField(_U("RouteType"),UGFieldInfo::INT32,4,0);  //航线类型
//        line3DDsv->CreateField(_U("RouteHeight"),UGFieldInfo::Float,4,0);  //航线高度
        line3DDsv->CreateField(_U("RouteName"),UGFieldInfo::Text,255,0);    //航线名字
        line3DDsv->CreateField(_U("IsClosedRoute"),UGFieldInfo::INT32,4,0);  //是否自闭合

        #pragma endregion}


        //往工作空间中添加数据源
        m_pWorkspace->m_DataSources.Insert(Translator::QStr2UGStr(routeName),pDataSource);

        //保存工作空间
        m_pWorkspace->m_WorkspaceConnection.m_bFailIfExists = false;//调用save前要设置
        UGbool ss = m_pWorkspace->Save();
        pDataSource = NULL;
    }


//    for (int i=0;i<m_pWorkspace->m_DataSources.GetCount();i++)
//    {
//        qDebug()<<"DataSourceName:"<<Translator::UGStr2QStr(m_pWorkspace->m_DataSources.m_strArrNames[i]);
//    }

}

//二维地图容器初始化
void MainWindow::initMapControl()
{
    //实例化一个地图窗口对象，即QMapControl对象
    qMapControl = new QMapControl;
    qMapControl->GetMap()->SetWorkspace(m_pWorkspace);

    qMapControl->GetUGMapWnd()->SetAfterGeometryAddedFunc(AfterGeometryAddedCallback,(UGlong)qMapControl);
    qMapControl->GetUGMapWnd()->SetAfterPointInputFunc(AfterPointInputCallback,(UGlong)qMapControl);
    qMapControl->GetUGMapWnd()->SetGeometrySelectedFunc(GeometrySelectedCallback,(UGlong)qMapControl);
//    qMapControl->GetUGMapWnd()->SetSingleGeometrySelectedFunc(SingleGeometrySelectedCallback,(UGlong)qMapControl);
//    qMapControl->GetUGMapWnd()->SetTrackedFunc(TrackedProcCallback,(UGlong)qMapControl);
//    qMapControl->GetUGMapWnd()->SetBeforeGeometryDeletedFunc(BeforeGeometryDeletedProcCallback,(UGlong)qMapControl);
//    qMapControl->GetUGMapWnd()->SetAfterGeometryDeletedFunc(AfterGeometryDeletedProcCallback,(UGlong)qMapControl);
//    qMapControl->GetUGMapWnd()->SetEditHandleCanceledFunc(EditHandleCanceledProcCallback,(UGlong)qMapControl);
    qMapControl->GetUGMapWnd()->SetBeginEditHandleFunc(BeginEditHandleProcCallback,(UGlong)qMapControl);
//    qMapControl->GetUGMapWnd()->SetAfterGeometryModifiedFunc(AfterGeometryModifiedProcCallback,(UGlong)qMapControl);
    qMapControl->GetUGMapWnd()->SetBeforeGeometryModifiedFunc(BeforeGeometryModifiedProcCallback,(UGlong)qMapControl);
    qMapControl->setFocus();
}

//菜单初始化
void MainWindow::initMenu(QMainWindow* mainWindow)
{
    //保存航线ui
    saveRouteDlg = new saveRouteDialog;
    /****************************Map右键菜单**************************************/
    //添加地图右键菜单对象
    mapRBtnMenu = new QMenu(mainWindow);
    // 属性右键菜单
    attributeRBtnMenu = new QMenu(mainWindow);
    // 添加菜单QAction
    addMapMenuAction();

    rMenuType = RBtnMenuType::DefaultMenu;

    inputPosDlg = new ComputeOffsetPositionDialog;
}

//工具条初始化
void MainWindow::initMainToolBar(QMainWindow *mainWindow)
{
    //向应用程序窗体中添加工具条对象
    mainToolBar = new QToolBar(mainWindow);
    mainWindow->addToolBar(Qt::TopToolBarArea,mainToolBar);
    //调用addMapAction函数向界面中添加功能按钮
    addMapAction(mainWindow);

    QToolButton *tb = qobject_cast<QToolButton *>(mainToolBar->widgetForAction(actionEdit));
    tb->setStyleSheet("QToolButton::menu-indicator{image:none}");//去掉下拉黑色小箭头
    //编辑工具条
    editToolMenu = new QMenu(mainWindow);
    editToolBar = new QToolBar(mainWindow);
    addEditToolAction();

    wactionEdit = new QWidgetAction(editToolBar);
    wactionEdit->setDefaultWidget(editToolBar);
    editToolMenu->addAction(wactionEdit);
    tb->setMenu(editToolMenu);
    tb->setPopupMode (QToolButton::InstantPopup);
}

//添加QAction
void MainWindow::addMapAction(QMainWindow *mainWindow)
{
    //为"打开工作空间中地图"按钮添加按钮图标并将其置于工具条上
    actionOpen = new QAction(QIcon(":/Resources/Image_Open.png"),"Open", this);
    mainToolBar->addAction(actionOpen);

    //为"添加高程地图"按钮添加按钮图标并将其置于工具条上
    actionOpenDEM = new QAction(QIcon(":/Resources/RasterFile.png"),"添加高程地图", this);
    mainToolBar->addAction(actionOpenDEM);

    //为"全幅显示地图"按钮添加按钮图标并将其置于工具条上
    actionViewEntire = new QAction(QIcon(":/Resources/Entire.png"),"View Entire",this);
    mainToolBar->addAction(actionViewEntire);

    //为"放大地图"按钮添加按钮图标并将其置于工具条上
    actionZoomin = new QAction(QIcon(":/Resources/Zoomin.png"),"Zoom In",this);
    mainToolBar->addAction(actionZoomin);

    //为"缩小地图"按钮添加按钮图标并将其置于工具条上
    actionZoomout = new QAction(QIcon(":/Resources/Zoomout.png"),"Zoom Out",this);
    mainToolBar->addAction(actionZoomout);

    //为"平移浏览地图"按钮添加按钮图标并将其置于工具条上
    actionPan = new QAction(QIcon(":/Resources/Pan.png"),"Pan",this);
    mainToolBar->addAction(actionPan);

    //为"距离量算"按钮添加按钮图标并将其置于工具条上
    actionCalcLength = new QAction(QIcon(":/Resources/Length.png"),"length",this);
    mainToolBar->addAction(actionCalcLength);

    //为"面积量算"按钮添加按钮图标并将其置于工具条上
    actionCalcArea = new QAction(QIcon(":/Resources/Area.png"),"Area",this);
    mainToolBar->addAction(actionCalcArea);

    //为"角度量算"按钮添加按钮图标并将其置于工具条上
    actionCalcAngle = new QAction(QIcon(":/Resources/Angle.png"),"angle",this);
    mainToolBar->addAction(actionCalcAngle);

    //为"选择"按钮添加按钮图标并将其置于工具条上
    actionSelect = new QAction(QIcon(":/Resources/Select.png"),"Select",this);
    mainToolBar->addAction(actionSelect);

    //为"编辑"按钮添加按钮图标并将其置于工具条上
    actionEdit = new QAction(QIcon(":/Resources/Edit.png"),"Edit",this);
    mainToolBar->addAction(actionEdit);

    //为"绘制点"按钮添加按钮图标并将其置于工具条上
    actionDrawPoint = new QAction(QIcon(":/Resources/Image_Point.png"),"DrawPoint",this);
    mainToolBar->addAction(actionDrawPoint);

    //为"绘制线"按钮添加按钮图标并将其置于工具条上
    actionDrawLine = new QAction(QIcon(":/Resources/Image_Line.png"),"DrawLine",this);
    mainToolBar->addAction(actionDrawLine);

    //为"绘制多边形"按钮添加按钮图标并将其置于工具条上
    actionDrawPolygon = new QAction(QIcon(":/Resources/Image_Polygon.png"),"DrawPolygon",this);
    mainToolBar->addAction(actionDrawPolygon);

    //绘制要素时手动输入点触发按钮
    actionInputPoint = new QAction(QIcon(":/Resources/InputPoint.png"),"InputPoint",this);
    mainToolBar->addAction(actionInputPoint);

    //绘制在线地图按钮
    actionOnlineMap = new QAction(QIcon(":/Resources/OnlineMap.png"),"OnlineMap",this);
    mainToolBar->addAction(actionOnlineMap);

    //绘制地图定位按钮
    actionMapLocation = new QAction(QIcon(":/Resources/MapLocation.png"),"地图定位",this);
    mainToolBar->addAction(actionMapLocation);

    //绘制二三维地图切换按钮
    actionTransformMap = new QAction(QIcon(":/Resources/view_3d.png"),"3D地图",this);
    mainToolBar->addAction(actionTransformMap);

    //绘制导入数据按钮
    actionImportData = new QAction(QIcon(":/Resources/import_data.png"),"导入数据",this);
    mainToolBar->addAction(actionImportData);

    //绘制模拟飞行按钮
    actionFlySimulated = new QAction(QIcon(":/Resources/FlySimulated.png"),"仿真飞行",this);
    mainToolBar->addAction(actionFlySimulated);

    /*******************************Test*******************************/
    actionTest = new QAction(QIcon("D:/supermap-iobjectscpp/MyProject/MapDisplay/Resources/Test.png"),"测试",this);
    mainToolBar->addAction(actionTest);
}

//添加地图右键菜单QAction
void MainWindow::addMapMenuAction()
{
    // 地图右键菜单QAction
    actionImportRoute = mapRBtnMenu->addAction(u8"导入航线");
    actionShowRoute = mapRBtnMenu->addAction(u8"显示航线");
    actionBindRoute = mapRBtnMenu->addAction(u8"装订航线");

    //属性右键菜单QAction
    actionAttribute = attributeRBtnMenu->addAction("属性");
    actionExportFile = attributeRBtnMenu->addAction("导出");
    actionRouteAnalyse = attributeRBtnMenu->addAction("航线分析");

}

//声明编辑条的行为函数
void MainWindow::addEditToolAction()
{
    //为"编辑"按钮添加按钮图标并将其置于工具条上
    actionStartEdit = new QAction(QIcon(":/Resources/Edit1.png"),"Edit",this);
    editToolBar->addAction(actionStartEdit);

    //为"编辑节点"按钮添加按钮图标并将其置于工具条上
    actionEditNode = new QAction(QIcon(":/Resources/EditNode1.png"),"编辑节点",this);
    editToolBar->addAction(actionEditNode);
    actionEditNode->setEnabled(false);

    //为"添加节点"按钮添加按钮图标并将其置于工具条上
//    actionAddNode = new QAction(QIcon(":/Resources/AddNode.png"),"添加节点",this);
//    editToolBar->addAction(actionAddNode);

    //为"删除节点"按钮添加按钮图标并将其置于工具条上
//    actionDeleteNode = new QAction(QIcon(":/Resources/DeleteNode.png"),"删除节点",this);
//    editToolBar->addAction(actionDeleteNode);
}

//Map连接信号和槽的函数
void MainWindow::addMapConnect()
{
    connect(actionTest,&QAction::triggered,this,&MainWindow::test);
    /*********************************以上连接仅用于测试**************************************/

    connect(qMapControl,&QMapControl::sendPreviousPoint,inputPosDlg,&ComputeOffsetPositionDialog::acceptPresiousPoint);
    connect(inputPosDlg,&ComputeOffsetPositionDialog::sendComputedPoint,qMapControl,&QMapControl::clickedComputedPoint);

    //连接信号actionOpen和槽openMap
    connect(actionOpen,&QAction::triggered,this,&MainWindow::openRasterMap);

    //连接信号actionOpen和槽AddDEM
    connect(actionOpenDEM,&QAction::triggered,this,&MainWindow::addRasterDEM);

    //连接信号actionViewEntire和槽viewEntire
    connect(actionViewEntire,&QAction::triggered,this,&MainWindow::viewEntire);

    //连接信号actionZoomin和槽zoomIn
    connect(actionZoomin,&QAction::triggered,this,&MainWindow::zoomIn);

    //连接信号actionZoomout和槽zoomOut
    connect(actionZoomout,&QAction::triggered,this,&MainWindow::zoomOut);

    //连接信号actionPan和槽pan
    connect(actionPan,&QAction::triggered,this,&MainWindow::pan);

    //连接信号actionCalcLength和槽calcLength
    connect(actionCalcLength,&QAction::triggered,this,&MainWindow::calcLength);

    //连接信号actionCalcArea和槽calcArea
    connect(actionCalcArea,&QAction::triggered,this,&MainWindow::calcArea);

    //连接信号actionCalcAngle和槽calcAngle
    connect(actionCalcAngle,&QAction::triggered,this,&MainWindow::calcAngle);

    //连接信号actionSelect和槽Select
    connect(actionSelect,&QAction::triggered,this,&MainWindow::Select);

    //连接信号actionDrawPoint和槽drawPoint
    connect(actionDrawPoint,&QAction::triggered,this,&MainWindow::drawPoint);

    //连接信号actionDrawLine和槽drawLine
    connect(actionDrawLine,&QAction::triggered,this,&MainWindow::drawLine);

    //连接信号actionDrawPolygon和槽drawPolygon
    connect(actionDrawPolygon,&QAction::triggered,this,&MainWindow::drawPolygon);

    //连接信号actionInputPoint和槽showComputeOffsetPosition
    connect(actionInputPoint,&QAction::triggered,this,&MainWindow::showComputeOffsetPosition);

    //连接信号actionOnlineMap和槽showOnlineMapDialog
    connect(actionOnlineMap,&QAction::triggered,this,&MainWindow::showOnlineMapDialog);

    //连接信号actionOnlineMap与地图定位弹窗
    connect(actionMapLocation,&QAction::triggered,this,[=](){
        MapLocationDialog mapLocationDlg;
        if(mapType==MapType::Map2D)
            mapLocationDlg.setMap(qMapControl->GetUGMapWnd());
        else
            mapLocationDlg.setScene(pSceneControl);
        mapLocationDlg.exec();
    });

    //连接信号actionTransformMap与槽transformMap
    connect(actionTransformMap,&QAction::triggered,this,&MainWindow::transformMap);

    //连接信号actionImportData与ImportSceneDataDialog对话框
    connect(actionImportData,&QAction::triggered,this,[&](){
        ImportSceneDataDialog importSceneDataDlg;
        connect(&importSceneDataDlg,&ImportSceneDataDialog::sendSceneDataPath,this,&MainWindow::importSceneData);
        importSceneDataDlg.exec();
    });

    //连接信号actionFlySimulated与槽showFlySimulatedDlg
    connect(actionFlySimulated,&QAction::triggered,this,&MainWindow::showFlySimulatedDlg);

    /********************右键菜单信号槽连接********************/
    //连接信号actionBindRoute和槽showBindRouteDialog
    connect(actionBindRoute,&QAction::triggered,this,&MainWindow::showBindRouteDialog);

    // 连接信号actionShowRoute和槽DisplayRouteDialog
    connect(actionShowRoute,&QAction::triggered,this,[=](){
        //获取线数据集
        UGDatasetPtr Route_ds = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName))->GetDataset(lineSetAlias);
        Route_ds->Open();

        DisplayRouteDialog displayRouteDlg;
        displayRouteDlg.setDataset(Route_ds);
        displayRouteDlg.setMapEditorWnd(qMapControl->GetUGMapWnd());
        displayRouteDlg.addRouteTypeItem();

        displayRouteDlg.exec();
        Route_ds = NULL;
    });

    // 连接信号actionImportRoute和槽导入
    connect(actionImportRoute,&QAction::triggered,this,[=](){
        importKMLData();
    });

    /********************属性右键菜单信号槽连接********************/
    connect(qMapControl,&QMapControl::showAttributeMenu,this,&MainWindow::showAttributeMenu);
    //连接航线分析函数
    connect(actionRouteAnalyse,&QAction::triggered,this,[=](){
        showRouteAnalysisDlg();
    });
}

//声明edit连接信号和槽的函数
void MainWindow::addEditConnect()
{
    //连接信号actionEdit和槽Edit
    connect(actionStartEdit,&QAction::triggered,this,&MainWindow::Edit);

    connect(actionEditNode,&QAction::triggered,this,[=](){
        if(!qMapControl->getEditNodeState())
        {//开启节点编辑
            actionEditNode->setIcon(QIcon(":/Resources/EditNode.png"));
            qMapControl->EditNode(true);
            qMapControl->Refresh();
        }
        else
        {//关闭节点编辑
            actionEditNode->setIcon(QIcon(":/Resources/EditNode1.png"));
            qMapControl->EditNode(false);
            qMapControl->Refresh();
        }
    });

    connect(qMapControl,&QMapControl::closeEditNode,this,[=](){
        actionEditNode->setIcon(QIcon(":/Resources/EditNode1.png"));
        qMapControl->EditNode(false);
        qMapControl->Refresh();
    });

//    connect(actionStartEdit,&QAction::triggered,this,[=](){
//        qMapControl->AddNode();
//        qMapControl->Refresh();
//    });
}

//三维场景容器初始化
void MainWindow::initSceneControl(QWidget* parent)
{
    pSceneView = new SceneView();
    pSceneView->setAttribute(Qt::WA_DeleteOnClose); // 关闭后就释放
    pSceneView->resize(parent->width(),parent->height());
//    pSceneView->setFocus();

    pSceneControl = pSceneView->GetSceneControl();
    pSceneControl->SetWorkspace(new Workspace(m_pWorkspace));

    //添加场景右键菜单对象
    initSceneMene();

    //添加信号连接
    addSceneConnect();

    addSceneActionConnect();
}

//三维场景菜单初始化
void MainWindow::initSceneMene()
{
    //添加场景右键菜单对象
    sceneRBtnMenu = new QMenu(this);
    addSceneMenuAction();

    rMenuType = RBtnMenuType::DefaultMenu;
}

//添加场景右键菜单QAction
void MainWindow::addSceneMenuAction()
{
    // 场景右键菜单QAction
    actionSceneImportRoute = sceneRBtnMenu->addAction(u8"导入航线");
    actionSceneShowRoute = sceneRBtnMenu->addAction(u8"显示航线");
    actionSceneBindRoute = sceneRBtnMenu->addAction(u8"装订航线");
}

//Scene QAction连接信号和槽的函数
void MainWindow::addSceneActionConnect()
{
    /********************场景右键菜单信号槽连接********************/
    //连接信号actionBindRoute和槽showBindRouteDialog
    connect(actionSceneBindRoute,&QAction::triggered,this,&MainWindow::showBindRouteDialog);

    // 连接信号actionShowRoute和槽DisplayRouteDialog
    connect(actionSceneShowRoute,&QAction::triggered,this,[=](){
        //获取线数据集
        UGDatasetPtr Route3D_ds = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName))->GetDataset(line3DSetAlias);
        Route3D_ds->Open();
        DisplayRouteDialog displayRouteDlg;
        displayRouteDlg.setDataset(Route3D_ds);
        displayRouteDlg.setSceneControl(pSceneControl);
        displayRouteDlg.addRouteTypeItem();

        displayRouteDlg.exec();
        Route3D_ds = NULL;
    });

    // 连接信号actionImportRoute和槽导入
    connect(actionSceneImportRoute,&QAction::triggered,this,[=](){
        importKML3DData();
    });

    /********************场景右键属性菜单信号槽连接********************/
    //连接actionExportFile与KML导出函数
    connect(actionExportFile,&QAction::triggered,this,&MainWindow::exportKMLFile);
}

//Scene连接信号和槽的函数
void MainWindow::addSceneConnect()
{
//    connect(pSceneView,&SceneView::sendTrackedGeometry,this,&MainWindow::showSaveRoute3DDialog);

    connect(pSceneView,&SceneView::showSettingFlightPointDialg,this,&MainWindow::showSettingFlightPoint3DDialog);

    //连接右键属性菜单信号
    connect(pSceneView,&SceneView::showAttributeMenu,this,&MainWindow::showAttributeMenu);
}


//判断文件夹是否存在
UGbool MainWindow::DirExist(QString fullPath)
{
    QDir dir(fullPath);
    if(dir.exists())
    {
        //存在文件夹
        return true;
    }
    else
    {
        //不存在则创建
        bool ok = dir.mkdir(fullPath); //只创建一级子目录，即必须保证上级目录存在
        //bool ok = dir.mkpath(fullPath);//不存在当前目录，创建，可创建多级目录
        return ok;
    }
}

// 导入KML/KMZ文件
void MainWindow::importKMLData()
{
    //获取文件路径
    QString qStrPath = QFileDialog::getOpenFileName(this,"导入KML/KMZ文件",
                                ":/supermap-iobjectscpp/MyProject/MapDisplay/SampleData/",
                                "Google KML(*.kml *.kmz)");
    if(qStrPath.isEmpty())
    {
        return;
    }

    //获取数据源
    UGDataSource* pDataSource = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));
    if(pDataSource==NULL) return;

    //打开KML文件
    UGString dtName = pDataSource->GetUnoccupiedDatasetName(_U("KML"));//导入数据集名称
    GeoFileParser GeoFP;
    bool issucceed = GeoFP.importKMLData(pDataSource,dtName,qStrPath);

    if(issucceed)
    {
        UGDatasetPtr kmlDt = pDataSource->GetDataset(dtName);
        UGDatasetVector* kmlDv = (UGDatasetVector*) kmlDt.get();
        if(!kmlDv->IsOpen()) kmlDv->Open();

        GeoFeatureOperator geoFtOperator;
        UGRecordsetPtr kmlRes = geoFtOperator.queryFeature(kmlDv);
        LayerOperator layerOperator;
        RouteGlobalVariant routeGVar;
        UGStyle sty;
        routeGVar.getTemporaryStyle(sty);
//        if(mapType==MapType::Map2D)
//            layerOperator.showKMLTemporary(qMapControl,kmlRes);

        //将kml航线临时展示在动态图层
        UGMap* pMap = qMapControl->GetMap();
        UGDynamicLayer* pDyLayer = NULL;
        UGString kmlLayerName = _U("KMLDyLayer");
        layerOperator.getDynamicLayer(pMap,pDyLayer,kmlLayerName);
        layerOperator.addGeometryInDynamicLayer(pDyLayer,kmlRes,sty);
        //设置第一条航线高亮
        routeGVar.getHighLightStyle(sty);
        pDyLayer->GetAt(0)->SetStyle(&sty);
        pMap->m_DynamicLayers.Add(pDyLayer);
        qMapControl->Refresh();

        //航线属性信息导入
        kmlRes->MoveFirst();
        UGDatasetVector* dstDV = (UGDatasetVector*)pDataSource->GetDataset(lineSetAlias).get();
        if(!dstDV->IsOpen()) dstDV->Open();
        UGGeometry* pGeometry = NULL;
        QMap<QString,QString> fieldsValue;
        //连接航线导入状态信号
        connect(this,&MainWindow::sendAddRouteState,saveRouteDlg,&saveRouteDialog::getAddRouteState);
        //连接航线导入信号
        connect(saveRouteDlg,&saveRouteDialog::importRoute,this,[&](int routeID,int routeType,int routeNumber,double routeHeight,int routeClosedState){
            //移动指针到当前航线
            kmlRes->MoveTo(routeID-1);
            //提取航线属性信息
            GeoFeatureOperator geoFtOperator;
            fieldsValue.insert(routeGVar.routeFieldsName.RouteID,QString::number(dstDV->GetObjectCount()+1));
            fieldsValue.insert(routeGVar.routeFieldsName.RouteHeight,QString::number(routeHeight));
            fieldsValue.insert(routeGVar.routeFieldsName.RouteNumber,QString::number(routeNumber));
            fieldsValue.insert(routeGVar.routeFieldsName.RouteType,QString::number(routeType));
            fieldsValue.insert(routeGVar.routeFieldsName.IsClosedRoute,QString::number(routeClosedState));
            //导入数据集
            kmlRes->GetGeometry(pGeometry);
            int ss = geoFtOperator.importFeatureAttribute(dstDV,pGeometry,fieldsValue);
            emit sendAddRouteState(ss);
//qDebug()<<"*******************RecordCount:"<<dstDV->GetObjectCount();
//            kmlRes->MoveNext();
            pGeometry = NULL;
            kmlDv = NULL;
        });

        //高亮当前要导入的航线
        connect(saveRouteDlg,&saveRouteDialog::highLightGeometry,this,[&](int currentGeometryID,int lastGeometryID){
//            UGDynamicLayer* pDyLayer = qMapControl->GetMap()->m_DynamicLayers.GetDynamicLayer(kmlLayerName);
            //取消原高亮几何对象
            routeGVar.getTemporaryStyle(sty);
            pDyLayer->GetAt(lastGeometryID-1)->SetStyle(&sty);
            // 高亮新几何对象
            routeGVar.getHighLightStyle(sty);
            pDyLayer->GetAt(currentGeometryID-1)->SetStyle(&sty);
            qMapControl->Refresh();
        });
        //显示弹窗
        saveRouteDlg->setMaxValue(kmlRes->GetRecordCount());
        int ret = saveRouteDlg->exec();

        //清除数据集和临时航线图层
        pDataSource->DeleteDataset(dtName);
        pDyLayer->RemoveAll();
        qMapControl->Refresh();

        pDyLayer = NULL;
        pDataSource = NULL;
    }
}

//导入三维KML数据
void MainWindow::importKML3DData()
{
    //获取文件路径
    QString qStrPath = QFileDialog::getOpenFileName(this,"导入KML/KMZ文件",
                                                    ":/supermap-iobjectscpp/MyProject/MapDisplay/SampleData/",
                                                    "Google KML(*.kml *.kmz)");
    if(qStrPath.isEmpty())
    {
        return;
    }

    //获取数据源
    UGDataSource* pDataSource = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));
    if(pDataSource==NULL) return;

    //打开KML文件
    UGString dtName = pDataSource->GetUnoccupiedDatasetName(_U("KML3D"));//导入数据集名称
    GeoFileParser GeoFP;
    bool issucceed = GeoFP.importKMLData(pDataSource,dtName,qStrPath);

    if(issucceed)
    {
        UGDatasetPtr kmlDt = pDataSource->GetDataset(dtName);
        UGDatasetVector* kmlDv = (UGDatasetVector*) kmlDt.get();
        if(!kmlDv->IsOpen()) kmlDv->Open();

        GeoFeatureOperator geoFtOperator;
        UGRecordsetPtr kml3DRes = geoFtOperator.queryFeature(kmlDv);
        LayerOperator layerOperator;
        RouteGlobalVariant routeGVar;
        UGStyle3D defaultStyle;
        UGStyle3D highLightStyle;
        routeGVar.getTemporaryStyle3D(defaultStyle);
        routeGVar.getHighLightStyle3D(highLightStyle);
//        sty.SetAltitudeMode(AltitudeMode::Absolute);
        UGTrackingLayer3D* trackingLayer3D = pSceneControl->GetTrackingLayer3D();
        //添加到追踪层
//        layerOperator.addGeometryToTrackingLayer3D(pSceneControl,kml3DRes);
        //设置第一条航线高亮
        UGGeoLine3D* line3D = NULL;
        UGGeometry* pGeometry = NULL;
        UGVariant v;
        UGVariant v1;
        UGString tag;
        kml3DRes->MoveFirst();
        kml3DRes->GetGeometry(pGeometry);
        kml3DRes->GetFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteType),v);
        kml3DRes->GetFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteNumber),v1);
        tag = v.ToString() + _U("_") + v1.ToString();
        line3D = (UGGeoLine3D*)pGeometry;
        line3D->SetStyle3D(&highLightStyle);
        trackingLayer3D->Add(line3D,tag);

        //航线属性信息导入
        kml3DRes->MoveFirst();
        UGDatasetVector* dstDV = (UGDatasetVector*)pDataSource->GetDataset(line3DSetAlias).get();
        if(!dstDV->IsOpen()) dstDV->Open();
//        UGGeometry* pGeometry = NULL;
        QMap<QString,QString> fieldsValue;
        saveRouteDialog* saveKMLDlg = new saveRouteDialog();
        saveKMLDlg->setHeightVisible(false);
        //连接航线导入状态信号
        connect(this,&MainWindow::sendAddRouteState,saveKMLDlg,&saveRouteDialog::getAddRouteState,Qt::UniqueConnection);
        //连接航线导入信号
        connect(saveKMLDlg,&saveRouteDialog::importRoute,this,[&](int routeID,int routeType,int routeNumber,double routeHeight,int routeClosedState){
            //移动指针到当前航线
            kml3DRes->MoveTo(routeID-1);
            //提取航线属性信息
            GeoFeatureOperator geoFtOperator;
            fieldsValue.insert(routeGVar.routeFieldsName.RouteID,QString::number(dstDV->GetObjectCount()+1));
            fieldsValue.insert(routeGVar.routeFieldsName.RouteHeight,QString::number(routeHeight));
            fieldsValue.insert(routeGVar.routeFieldsName.RouteNumber,QString::number(routeNumber));
            fieldsValue.insert(routeGVar.routeFieldsName.RouteType,QString::number(routeType));
            fieldsValue.insert(routeGVar.routeFieldsName.IsClosedRoute,QString::number(routeClosedState));
            //导入数据集
            kml3DRes->GetGeometry(pGeometry);
            int ss = geoFtOperator.importFeatureAttribute(dstDV,pGeometry,fieldsValue);
            emit sendAddRouteState(ss);
            //qDebug()<<"*******************RecordCount:"<<dstDV->GetObjectCount();
            //            kmlRes->MoveNext();
            pGeometry = NULL;
            kmlDv = NULL;
        });

        //高亮当前要导入的航线
        connect(saveKMLDlg,&saveRouteDialog::highLightGeometry,this,[&](int currentGeometryID,int lastGeometryID){
//            qDebug()<<"********************currentGeometryID:"<<currentGeometryID;
//            qDebug()<<"********************lastGeometryID:"<<lastGeometryID;
//            qDebug()<<"***********************Count:"<<trackingLayer3D->GetCount();
            trackingLayer3D->RemoveAll();

            line3D = NULL;
            pGeometry = NULL;
//            trackingLayer3D->RemoveAt(currentGeometryID-1);
            kml3DRes->MoveTo(currentGeometryID-1);
            kml3DRes->GetGeometry(pGeometry);
            line3D = (UGGeoLine3D*)pGeometry;
            line3D->SetStyle3D(&highLightStyle);
            kml3DRes->GetFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteType),v);
            kml3DRes->GetFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteNumber),v1);
            tag = v.ToString() + _U("_") + v1.ToString();
            trackingLayer3D->Add(line3D,tag);
        });

        //connect(saveKMLDlg,&saveRouteDialog::highLightGeometry,this,&MainWindow::highLightKMLGeometry);
        //显示弹窗
        saveKMLDlg->setMaxValue(kml3DRes->GetRecordCount());
        int ret = saveKMLDlg->exec();
//        saveKMLDlg->show();

        //清除数据集和临时航线图层
        pDataSource->DeleteDataset(dtName);
        trackingLayer3D->RemoveAll();
//        trackingLayer3D->SetRefresh(false);

//        routeGVar.getHighLightStyle3D(sty);
        //        trackingLayer3D->GetAt(0)->SetStyle3D(&sty);
//        routeGVar.getTemporaryStyle3D(sty);
//        trackingLayer3D->GetAt(0)->GetStyle3D()->SetLineColor3D(sty.GetLineColor3D());
//        trackingLayer3D->GetAt(0)->SetStyle3D(&sty);
//        routeGVar.getHighLightStyle3D(sty);
//        trackingLayer3D->GetAt(1)->SetStyle3D(&sty);
//        trackingLayer3D->GetAt(1)->GetStyle3D()->SetLineColor3D(sty.GetLineColor3D());

//        pSceneControl->GetScene3D()->UpdateData();
//        pSceneControl->GetScene3D()->Refresh();
//        pSceneControl->Refresh();

//        pDataSource->DeleteDataset(dtName);

        delete saveKMLDlg;
        pDataSource = NULL;
    }
}

//导出KML文件
void MainWindow::exportKMLFile()
{
    QString savePath = QFileDialog::getSaveFileName(this, tr("导出KML文件"),
                                    "/航线1",
                                    tr("Google KML(*.kml);;Google KML(*.kmz)"));
//    qDebug()<<"*********************************导出被调用了！";
    if(savePath.isEmpty()) return;

    LayerOperator layerOpt;
    QMap<int,QStringList> featureInfo;
    if(mapType==MapType::Map2D)
        featureInfo = layerOpt.getSelectedFeature(qMapControl->GetMap());
    else if(mapType==MapType::Map3D)
        featureInfo = layerOpt.getSelectedFeature3D(pSceneControl);
    //构造SQL查询条件
    QStringList filterlist;
    QList<int> types = featureInfo.keys();
    for(int i = 0; i < types.size(); i++)
    {
        filterlist<< "(RouteNumber in (" + featureInfo[types[i]].join(",") + ") and " + "RouteType = " + QString::number(types[i]) + ")";
    }
    QString filter = filterlist.join(" or ");

    // 导出
    UGDataSource* ds = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));
    if(!ds->IsOpen()) ds->Open();
    GeoFileParser GeoFP;
    RouteGlobalVariant routeGVar;
    if(mapType==MapType::Map2D)
        GeoFP.exportKMLData(ds,Translator::UGStr2QStr(routeGVar.workspaceDataName.LineDatasetName),savePath,filter);
    else if(mapType==MapType::Map3D)
        GeoFP.exportKMLData(ds,Translator::UGStr2QStr(routeGVar.workspaceDataName.Line3DDatasetName),savePath,filter);

    ds = NULL;

}

//加载三维模型数据
void MainWindow::loadModelData()
{
    UGEnvironment::SetHardwareAccelerationEnable(true);
    UGEnvironment::SetCUDAComputingEnabled(true);
    UGEnvironment::SetOpenCLComputingEnabled(true);
    //获取数据源
    UGDataSource* pDataSource = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));
    if(pDataSource==NULL) return;
    if(!pDataSource->IsOpen()) pDataSource->Open();
    QString path = "D:/supermap-iobjectscpp/MyProject/MapDisplay/ModelData/plane.3ds";
    QString path1 = "D:/supermap-iobjectscpp/MyProject/MapDisplay/ModelData/xiaofangche.s3m";
    QString kmlpath = "E:/Plane.kml";
//    QString path = "D:/supermap-iobjectscpp/MyProject/MapDisplay/ModelData/xiaofangche.gltf";
//    GeoFileParser geoFileParser;
//    if(pDataSource->GetDataset(_U("Plane"))==NULL)
//    {
//        bool ss = geoFileParser.importModelData(pDataSource,_U("Plane"),path);
//        if(!ss) return;
//    }
    /*
    UGFlyRoute* flyRoute = new UGFlyRoute();
    UGFlyRouteStop* stop1 = new UGFlyRouteStop();
    UGPoint3D point3D(119.723971,32.220508,30);
    stop1->FromPoint3D(point3D,0);
    UGCameraState cs1;
    cs1.dTilt = UGMathEngine::Degree2Radian(70);
//    stop1->SetCamera(&cs1);

    UGFlyRouteStop* stop2 = new UGFlyRouteStop();
    UGPoint3D point3D2(119.725471,32.216129,30);
    stop2->FromPoint3D(point3D2,1);
//    stop2->SetCamera(&cs1);

    UGFlyRouteStop* stop3 = new UGFlyRouteStop();
    UGPoint3D point3D3(119.723971,32.210508,30);
    stop3->FromPoint3D(point3D3,2);
//    stop3->SetCamera(&cs1);

    flyRoute->m_pRouteStops->Insert(0,stop1);
    flyRoute->m_pRouteStops->Insert(1,stop2);
    flyRoute->m_pRouteStops->Insert(2,stop3);
    qDebug()<<"*****************StopCounts:"<<flyRoute->m_pRouteStops->GetCount();

    UGFlyManager* flymag = new UGFlyManager();
    UGFlyRoutes* flyRoutes = flymag->GetRoutes();
    flyRoute->SetStopsVisible(true);
    flyRoute->SetLinesVisible(true);
    flyRoute->SetSpeed(30);
    flyRoutes->Add(flyRoute);

//    pSceneControl->GetScene3D()->SetFlyManager(flymag);
    flymag->SetScene(pSceneControl->GetScene3D());
//    flymag->SetPlayRate(60);
//    flymag->Update();
    flymag->Play();

    UGFlyRouteStop* stop4 = new UGFlyRouteStop();
    UGPoint3D point3D4(119.723771,32.210208,30);
    stop4->FromPoint3D(point3D4,3);
    flymag->GetRoutes()->GetCurrentRoute()->m_pRouteStops->Add(stop4);
    flymag->Update();
    */


    UGScene3D* scene = pSceneControl->GetScene3D();
    scene->SetDynamicProjection(true);
//    UGString datasetName = _U("Line3DTmp");
    UGLayer3Ds* layers = pSceneControl->GetUGLayer3Ds();
    UGTrackingLayer3D* trackingLayer3D = pSceneControl->GetTrackingLayer3D();
//    UGLayer3D* kmlLayer = pSceneControl->AddLayerFromFile(kmlpath.toStdString());
//    kmlLayer->SetEditable(true);
//    UGLayer3DModel* modelLayer = (UGLayer3DModel*)kmlLayer;
//    UGRenderFeature* rft = modelLayer->GetRenderFeature(0);
//    UGArray<UGuint> arrIDs;
//    arrIDs.Add(0);
//    UGArray<UGFeature*> arrFeatures;
//    modelLayer->GetFeatures(arrIDs,arrFeatures);
//    int i = arrFeatures.GetSize();
//    qDebug()<<"*******************";

//    UGLayer3D* lineLayer3D = pSceneControl->AddLayerFromDataset(pDataSource->GetAlias(),datasetName);
//    qDebug()<<"*******************LayerCount1:"<<layers->GetInnerCount();
//    lineLayer3D->SetSelectable(true);
//    layers->SetEditableLayer(lineLayer3D,true); //设置图层可编辑
//    UGStyle3D style3D;
////    style3D.SetAltitudeMode(AltitudeMode::Absolute);
//    style3D.SetLineWidth(1);
//    style3D.SetLineColor(UGRGB(255,0,0));
//    lineLayer3D->SetStyle3D(style3D);
////    lineLayer3D->SetEditable(true);
////    qDebug()<<"*******************LayerEditable:"<<lineLayer3D->GetEditable();
//    pSceneControl->GetSceneEditWnd()->SetUserAction(UGSceneUserAction::suaEdit,UGEditType3D::ET3D_PolyLine); //
////    pSceneControl->GetSceneEditWnd()->SetUserAction(UGEditType3D::ET3D_PolyLine,UGSceneUserAction::suaCreatePolyline);

    //飞行视角测试
//    UGLayer3D* planeLayer = pSceneControl->GetUGLayer3Ds()->AddLayer(_U("Plane@Route"));
//    UGLayer3DModel* modelLayer = (UGLayer3DModel*)planeLayer;
//    planeLayer->SetEditable(true);
//    planeLayer->SetSelectable(true);
//    UGArray<UGRenderFeature*>* rt = planeLayer->GetEditFeatures();
//    pSceneControl->ViewToModelLayer(planeLayer);
//    UGString objName;
//    UGDynamicObjectlState state;
//    modelLayer->GetObjectState(objName,0,state);
//    qDebug()<<"**************";


//    UGStyle3D tmpSty = planeLayer->GetStyle3D();
//    tmpSty.SetAltitudeMode(AltitudeMode::Absolute);
//    planeLayer->SetVisible(false);
//    layers->SetEditableLayer(planeLayer,true);
//    planeLayer->SetSelectable(true);
//    UGRenderObjectList* rof = planeLayer->GetRenderObjectList();
//    UGRenderFeature* rf = planeLayer->GetRenderFeature(0);
//    UGArray< UGRenderFeature* >* rfs = planeLayer->GetEditFeatures();
//        UGSelection3D* st = planeLayer->GetSelection3D();
//        qDebug()<<"**************SelectionSize:"<<st->GetSize();
//        planeLayer->AddSelectedID(0);
//        qDebug()<<"**************SelectionSize1:"<<st->GetSize();
//        UGArray<UGRenderFeature*>* fts = planeLayer->GetarrSelection();

//    int i = rfs->GetSize();
//    qDebug()<<"**************ss";

//    UGRenderFeature* rf = planeLayer->GetRenderFeature(0);
//    rf->GetInestGeometry3D()->SetPosition(UGPoint3D(119.73,32.25,25));

//    qDebug()<<"**************ss:"<<ss;
//    pDataSource = NULL;

    //模型移动测试
    UGDatasetVector* dv = (UGDatasetVector*)pDataSource->GetDataset(_U("Plane")).get(); //Plane
//    ShowPlane3D* plane3D = new ShowPlane3D(pSceneControl,dv);
//    plane3D->setPlanesCount(1);
//    plane3D->startFly();

    if(!dv->IsOpen()) dv->Open();
    UGQueryDef query;
    UGRecordsetPtr res = dv->Query(query);
//    res->Edit();
    res->MoveFirst();
    UGVariant v;
    res->GetFieldValue(_U("ModelPath"),v);
//    qDebug()<<"*****************RecordCount:"<<res->GetRecordCount();
    UGGeometry* geometry = NULL;
    res->GetGeometry(geometry); //geometryType: GeoModelPro
//    qDebug()<<"*************geometryType:"<<geometry->GetType();
    UGFeature* ft = res->GetFeature();

    UGDatasetVector* dvtest = (UGDatasetVector*)pDataSource->GetDataset(_U("New_Model")).get();
//    dvtest->Append(res);
    if(!dvtest->IsOpen()) dvtest->Open();
    UGRecordsetPtr resTest = dvtest->Query(query);
//    resTest->AddFeature(ft);
//    resTest->AddNew((UGGeoModelPro*)geometry);
//    resTest->Update();


//    res->Edit();
    UGGeoModel* model = (UGGeoModel*)geometry;
    bool b = model->IsFileAttached();
//    UGString fpath = model->GetAttachedFilePath();
//    qDebug()<<"*******modelPath:"<<Translator::UGStr2QStr(model->GetAttachedFilePath());
//    model->SetFilePathName(v.ToString());
//    model->SetAttachedFilePath(_U("Plane@Route"));
//        resTest->AddNew(model);
//        resTest->Update();
//    UGGeoModel* model = new UGGeoModel();
//    model->MakeWithGeometry(geometry);
//    UGPoint3D pos = model->GetPosition();
//    UGPoint3D pos1 = model->GetInnerPoint3D();
//    model->SetPosition(UGPoint3D(119.73,32.234539,25));
//    res->SetGeometry(*model);
//    res->Update();
//    model->SetStyle3D(&tmpSty);
//    UGGeoModel* model = (UGGeoModel*)geometry;

//    scene->SetTrackingGeometry(model);
//    scene->SetTrackOffset(UGVector3d(119.73,32.234539,200));
//    plane3D->startFly();

//    UGGeoModel* model = new UGGeoModel();
//    model->MakeWithGeometry(geometry);
//    model->FromGeoModel(geometry);

//    model->SetAttachedFilePath(Translator::QStr2UGStr(path1));
//    model->SetFilePathName(Translator::QStr2UGStr(path1));
//    bool s = model->IsValid();
//    model->SetPosition(UGPoint3D(119.718414,32.234539,25));

    UGStyle3D* style3D = new UGStyle3D();
//    style3D.SetMarker3D(true);
//    style3D.SetScaleBySymbol(true);
//    style3D->SetFixedPixelSize(true);
    style3D->SetFillStyle(1);
    style3D->SetFill3DMode(UGC::/*UGFill3DMode::*/FILL_FACE);
    style3D->SetAltitudeMode(AltitudeMode::Absolute);
    style3D->SetBottomAltitude(2);
    style3D->SetExtendHeight(1);
    style3D->SetLineWidth(1);
    style3D->SetLineColor(UGRGB(0,0,255));
    style3D->SetFillBackColor(4294967295);
    style3D->SetFillForeColor(4294962109);
//    style3D->SetFillColor(4294967295);
    style3D->SetFixedColor(4294967295);
////    style3D.SetMarker3D(true);
    style3D->SetMarkerHeight(24);
    style3D->SetMarkerWidth(24);
    style3D->SetMarkerSize(24);
//    style3D->SetID(121);
//    style3D.SetMarker3DScaleX(10);
//    model->SetStyle3D(&style3D);
//    geometry->SetStyle(&style3D);
////    geometry->Set3DPoint(UGPoint3D(119.718567,32.234317,20));
//    planeLayer->SetStyle3D(style3D);

    geometry->SetStyle(style3D);

//    UGRefTranslator pj;
//    pj.SetGeoCoordSysDes(UGGeoCoordSys(UGC::EmGeoCoordSysType::GCS_WGS_1984));
//    model->PJConvert(&pj);
//    model->SetFilePathName(Translator::QStr2UGStr(path));
//    model->SetAttachedFilePath(Translator::QStr2UGStr(path));
//    model->SetSGMName(Translator::QStr2UGStr(path));
    model->SetStyle3D(style3D);
//    model->SetStyle(style3D);
//    model->SetScale(3);
    model->SetPosition(UGPoint3D(119.719160032812,32.2338551438965,30));
//    trackingLayer3D->CreateRenderFeature(0);
//    UGRenderFeature* rFte0 = trackingLayer3D->GetRenderFeature(0);
//    UGRenderObject* ro0 = trackingLayer3D->GetAt(0);
    UGRenderObject* ro = trackingLayer3D->Add(model,_U("plane"));
    qDebug()<<"*******trackingLayer Count:"<<trackingLayer3D->GetCount();
    UGModel* rmodel = (UGModel*)ro;

    rmodel->SetFeature(*ft);
//    rmodel->SetStyle3D(style3D);
//    trackingLayer3D->SetStyle3D(*style3D);
//    ro->SetStyle3D(style3D);
//    ro->SetVisible(true);
//    ro->SetAltitudeMode(AltitudeMode::Absolute);
//    pSceneControl->GetCameraWorld()->FlyTo(geometry,3000);
    trackingLayer3D->Render(pSceneControl->GetScene3D()->GetRenderParam());
    scene->UpdateData();
    pSceneControl->GetScene3D()->Refresh();
    pSceneControl->GetSceneEditWnd()->Refresh();


//    UGTrackingLayer3D* modelLayer = (UGTrackingLayer3D*)kmlLayer;
//    modelLayer->SetEditable(true);
//    int type = ro->GetType();
//    UGKmlFeature3D* kmlFt = (UGKmlFeature3D*)ro;
//    UGGeoModel* model1 = (UGGeoModel*)kmlFt->GetGeometry();
//    UGPoint3D ppt = model1->GetPosition();
//    modelLayer->Add(model,_U("plane2"));

//    qDebug()<<"***************FilePathName:"<<Translator::UGStr2QStr(model->GetFilePathName());
//    qDebug()<<"*********TrackingLayer3D GeoCounts0:"<<trackingLayer3D->GetCount();
//    trackingLayer3D->Add(geometry,_U("Plane"));
//    trackingLayer3D->Render(scene->GetRenderParam());
//    qDebug()<<"*********TrackingLayer3D GeoCounts1:"<<trackingLayer3D->GetCount();
//    modelLayer->AddModel(model);
//    layers->AddLayer(modelLayer,_U("model"));

//    UGLayer3D* planeLayer = pSceneControl->GetUGLayer3Ds()->AddLayer(_U("Plane@Route")); //
//    planeLayer->SetStyle3D(style3D);

    UGLayer3DManager layer3DMag;
    bool ls = layer3DMag.LoadLayer3D(_U("D:/supermap-iobjectscpp/bin/bin_x64/SuLayer3DTree.l3d"));
    bool ls1 = layer3DMag.LoadLayer3D(_U("D:/supermap-iobjectscpp/bin/bin_x64/SuLayer3DFile.l3d"));
//    UGLayer3D* planeLayer = layer3DMag.CreateLayer3D(UGLayer3DType::l3dModel);
//    UGLayer3DModel* modelLayer = (UGLayer3DModel*)planeLayer;
//    modelLayer->SetEditable();
//    modelLayer->AddModel(model);
//    layers->AddLayer(modelLayer,_U("model"));
//    UGLayer3DDynamic* p_UGLayer3DDynamic = (UGLayer3DDynamic*)layers->AddLayer(UGC::UGLayer3DType::l3dDynamicModel, _U("AA@Route"), _U("BB"), TRUE);
//    dyLayer3D->SetInitialized(true);
//    UGLayer3DDynamic* dyLayer3D = new UGLayer3DDynamic();
//    UGDynamicObjectlState dyObjState;
//    dyObjState.ID = 0;
//    dyObjState.Altitude = 25;
//    dyObjState.Latitude = 32.234317;
//    dyObjState.Longitude = 119.718567;
//    p_UGLayer3DDynamic->AddObjectFromFile(_U("D:/plane.s3m"),dyObjState,1);
//    p_UGLayer3DDynamic->SetStyle3D(style3D);
//    dyLayer3D->SetStyle3D(style3D);
//    bool ss = dyLayer3D->SaveKML(_U("E:/b.kml"));
//    UGLayer3DModel* modelLayer3D = new UGLayer3DModel();
    qDebug()<<"**************layersCount0:"<<layers->GetInnerCount();
//    layers->SetEditableLayer(modelLayer3D,true);

//    modelLayer3D->SetStyle3D(style3D);
//    UGLayer3D* kmlLayer = pSceneControl->AddLayerFromFile("E:/Plane.kml");
//    qDebug()<<"**************layersType:"<<kmlLayer->GetType();
//    kmlLayer->SetSelectable(false);
//    kmlLayer->SetEditable(true);
//    UGArray< UGRenderFeature * > * rof = kmlLayer->GetEditFeatures();
//    UGLayer3DModel* modelLayer3D = (UGLayer3DModel*)kmlLayer;

//    UGGeoPlacemark* GP = new UGGeoPlacemark();
    UGGeoPoint3D* p = new UGGeoPoint3D();
    p->SetX(119.718567);
    p->SetY(32.234317);
    p->SetZ(20);
//    GP->MakeWithGeometry(p);
//    GP->SetGeometry(p);
//    GP->SetPosition(UGPoint3D(119.718567,32.234317,20));
//    GP->SetName(_U("Test"));
//    UGStyle3D s;
//    s.SetAltitudeMode(AltitudeMode::Absolute);
//    s.SetFill3DMode(UGC::/*UGFill3DMode::*/FILL_FACE);
//    s.SetPicturePath(_U("D:/Icon.png"));
//    s.SetIconScale(5);
//    s.SetPointSize(24);
//    UGTextStyle t;
//    t.SetSize(24);
//    GP->SetNameTextStyle(&t);
//    GP->SetStyle3D(&s);
//    p->SetStyle3D(&s);
//    UGGeoText3D* text3D = new UGGeoText3D();
//    text3D->Make(_U("Text"),UGPoint3D(119.718567,32.234317,20));
//    text3D->AddSub(_U("Text2"),UGPoint3D(119.719567,32.235317,20));
//    RouteGlobalVariant routeGVar;
//    text3D->SetTextStyle(routeGVar.getLabelTextStyle());
//    UGGeoBillboard* billboard = new UGGeoBillboard();
//    billboard->MakeWithGeometry(p);
//    UGStyle3D bbsty;
//    bbsty.SetPicturePath(_U("D:/Icon.png"));
//    bbsty.SetAltitudeMode(AltitudeMode::Absolute);
//    billboard->SetWidth(32);
//    billboard->SetHeight(32);
//    billboard->SetStyle3D(&bbsty);
//    billboard->SetTag(0,_U("1-1"));
//    billboard->SetPosition(UGPoint3D(119.718567,32.234317,20));
//    pSceneControl->GetTrackingLayer3D()->Add(text3D,_U("a"));
//    pSceneControl->GetTrackingLayer3D()->Remove(_U("a"));
//    int i = text3D->IsValid();

//    modelLayer3D->AddModel(model);
//    int layertype = UGLayer3DType::l3dTree;
//    kmlLayer->SetLayerType();
//    layers->SetEditableLayer(pl,true);
//    layers->TreeAddLayer(0,dyLayer3D);
//    layers->TreeAddLayer(0,modelLayer3D);
    qDebug()<<"**************layersCount1:"<<layers->GetInnerCount();
//    layers->SetEditableLayer(modelLayer3D,true);
//    modelLayer3D->AddModel(model);



//    UGFeature* ft = NULL;
//    res->GetFeature(ft);
//    res->MoveFirst();
//    UGFeature* ft = res->GetFeature();

//    UGFeature* ft = new UGFeature();
//    ft->SetGeometry(GP);

//    UGArray< UGFeature > arrFeatures;
//    UGArray< UGFeature* > arrFeatures;
//    int i = arrFeatures.Add(*ft);
//    planeLayer->SetEditable(true);
//    qDebug()<<"***********:"<<arrFeatures.GetSize();
//    planeLayer->SetDataSources(pDataSource);
//    UGRenderObjectList* rol = kmlLayer->GetRenderObjectList();

//    bool b = kmlLayer->AddNewFeatures(arrFeatures);
//    bool b = kmlLayer->ModifyFeatures(arrFeatures);
//    pl->SetStyle3D(style3D);
//    UGLayer3D* pl = layers->AddLayer(planeLayer,_U("Plane"));
//    pl->SetStyle3D(style3D);
//    qDebug()<<"**************layersCount1:"<<layers->GetInnerCount();

//    UGRenderManager rm;
//    UGRenderFeature* rf = rm.CreateRenderFeature(UGGeometry::Type::GeoModel);

//    UGRenderFeature* rf = rm.CreateRenderFeature(geometry);
//    rf->SetGeometry(model);
//    rf->SetName(_U("model"));
//    rf->SetStyle3D(&style3D);
//    UGRenderModelPro* rmp = (UGRenderModels*)rf;
//    rol->Add(rf);
//    rol->Update(scene->GetRenderParam());
//    int rosize = rol->GetSize();
//    kmlLayer->Update(scene->GetRenderParam());
//    kmlLayer->Render(scene->GetRenderParam());
//    scene->UpdateData();
//    kmlLayer->SaveKML(_U("E:/b.kml"));
//    qDebug()<<"**************RenderObjCount:"<<rol->GetSize();
//    pl->Initialize(scene->GetRenderParam());

//    pSceneControl->GetScene3D()->UpdateData();
//    planeLayer->SetStyle3D(style3D);
//    UGLayer3D* pl = layers->GetLayerInnerAt(0);
//    qDebug()<<"**************layerName0:"<<Translator::UGStr2QStr(layers->GetLayerInnerAt(0)->GetName());

//    UGLayer3D* pl = layers->GetLayerInner(_U("Plane"));
//    qDebug()<<"**************layersCount1:";

//    UGDatasetVector* dv = (UGDatasetVector*)pDataSource->GetDataset(_U("Plane")).get();
//    if(!dv->IsOpen()) dv->Open();
//    UGQueryDef query;
//    UGRecordsetPtr res = dv->Query(query);
//    qDebug()<<"*****************RecordCount:"<<res->GetRecordCount();
//    res->MoveLast();
//    UGGeometry* geometry = NULL;
//    res->GetGeometry(geometry);
//    UGGeoModelPro* model = (UGGeoModelPro*)geometry;
//    model->SetPosition(UGPoint3D(119.718567,32.234317,20));
//    model->SetStyle3D(&style3D);

//    kmlLayer->Add(model,_U("model"));

//    UGGeoLine3D* l = (UGGeoLine3D*)geometry;
//    l->SetStyle3D(&style3D);
//    UGStyle3D sty3D;
//    sty3D.SetLineWidth(2);
//    sty3D.SetLineColor3D(UGRGB(0,0,255));
//    sty3D.SetAltitudeMode(AltitudeMode::Absolute);
//    l->SetStyle3D(&sty3D);

//    UGMarkerSymbolLib* ms = m_pWorkspace->GetResources()->GetMarkerSymbolLib();
//    int id = ms->GetIDAt(ms->GetSymbolCount()-1);

//    UGGeoPoint3D* p = new UGGeoPoint3D();
//    p->Make(UGPoint3D(119.718567,32.234317,20));
//    UGGeoPlacemark* pl = new UGGeoPlacemark();
//    pl->SetName(_U("Test"));
//    pl->SetPosition(UGPoint3D(119.718567,32.234317,20));
//    pl->Set3DPoint(UGPoint3D(119.718567,32.234317,20));
//    pl->SetGeometry(p);

//    UGStyle3D sty3D;
//    sty3D.SetMarkerStyle(318); //253268
////    sty3D.SetMarker3D(true);
//    UGColorValue3D(1,0,0);
//    sty3D.SetPointColor(UGColorValue3D(1,0,0));
//    sty3D.SetMarkerSize(30);
//    sty3D.SetFill3DMode(UGC::/*UGFill3DMode::*/FILL_FACE);
//    sty3D.SetAltitudeMode(AltitudeMode::Absolute);
//    sty3D.SetBottomAltitude(20);
//    p->SetStyle3D(&sty3D);
//    pl->SetStyle3D(&sty3D);
//    plotLayer->Add(p,_U("point"));
//    plotLayer->SetRefresh(true);
//    p->SetStyle(&sty3D);

//    UGStyle3D sty;
//    sty.SetMarkerStyle(253268);
//    sty.SetMarkerSize(30);
//    sty.SetFixedPixelSize(true);
//    sty.SetAltitudeMode(AltitudeMode::Absolute);

//    UGLayer3D* planeLayer = pSceneControl->GetUGLayer3Ds()->AddLayer(_U("Test@Route"));
//    planeLayer->SetStyle3D(sty);
//    layers->RefreshRasterLayer(planeLayer);

//    scene->SetTrackingGeometry();

//    UGGeoPlacemark* pm = new UGGeoPlacemark();
//    pm->SetGeometry(geometry);
//    pm->SetStyle3D(&style3D);

//    UGGeoPicture* pt = new UGGeoPicture;
//    geometry->ConvertToPicture(*pt,1);

//    UGStyle3D styE;
//    styE.SetAltitudeMode(AltitudeMode::Absolute);
////    styE.SetMarker3D(true);
//    geometry->Set3DPoint(UGPoint3D(119.718567,32.234317,20));
//    geometry->SetStyle(&styE);

//    UGLayer3Ds* layers = pSceneControl->GetUGLayer3Ds();
//    layers->GetLayerInnerAt(0)->SetVisible(false); //_U("大路机场18@Route")
//    UGGeoPicture* pt = (UGGeoPicture*) geometry;
//    UGGeoLine3D* l = (UGGeoLine3D*) geometry;
//    l->SetStyle3D(&style3D);


//    trackingLayer3D->SetAlwaysRender(true);
//    trackingLayer3D->SetWorkspace(m_pWorkspace);
//    trackingLayer3D->SetUseGeoStyle(true);
//    qDebug()<<"**************TrackingCount0:"<<trackingLayer3D->GetCount();
//    trackingLayer3D->Add(pl,_U("picture"));
//    UGStyle3D* sty1 = trackingLayer3D->GetAt(0)->GetStyle3D();
//    sty1->SetLineColor(UGRGB(0,0,255));
//    trackingLayer3D->GetAt(0)->SetStyle3D(&sty3D);
//    pSceneControl->GetSceneEditWnd()->SetUserAction(UGSceneUserAction::suaEdit,UGEditType3D::ET3D_PolyLine); //
//    trackingLayer3D->SetEditable(true);
//    trackingLayer3D->SetRefresh(false);
//    layers->RefreshRasterLayer(trackingLayer3D);

//    pSceneControl->GetScene3D()->GetCamera(_U("Camera"))->FlyTo(model);
//    qDebug()<<"**************TrackingCount1:"<<trackingLayer3D->GetCount();
////    trackingLayer3D->GetRenderObjectList()
////    qDebug()<<"**************RenderObjectSize0:"<<trackingLayer3D->GetRenderObjectList()->GetSize();
//    qDebug()<<"**************TrackingCount0:"<<trackingLayer3D->GetCount();

//    UGRenderObject* ro = trackingLayer3D->Add(model,_U("point"));
//    ro->SetAltitudeMode(AltitudeMode::Absolute);
//    ro->RenderToScreen(pSceneControl->GetScene3D()->GetRenderParam());
//    ro->Render(pSceneControl->GetScene3D()->GetRenderParam());
//    UGRenderManager rm;
//    UGRenderFeature* rf = rm.CreateRenderFeature(UGGeometry::GeoModel);
//    rf->SetGeometry(model);
//    UGArray< UGFeature > arrRenderFeatures;
//    arrRenderFeatures.Add(*rf);
//    bool b = trackingLayer3D->AddNewFeatures(arrRenderFeatures);
//    trackingLayer3D->Add()

//    qDebug()<<"**************TrackingCount1:"<<trackingLayer3D->GetCount();


//    trackingLayer3D->Initialize(pSceneControl->GetScene3D()->GetRenderParam());
//    trackingLayer3D->Render(pSceneControl->GetScene3D()->GetRenderParam());
//    trackingLayer3D->Update(pSceneControl->GetScene3D()->GetRenderParam());
//    UGRenderObjectList* rol = trackingLayer3D->GetRenderObjectList();
//    qDebug()<<"**************RenderObjectSize1:"<<rol->GetSize();
//    UGRenderObject* ro = trackingLayer3D->GetAt(0);
//    qDebug()<<"**************RenderObjectVisible:"<<ro->IsVisible();
//    pSceneControl->Refresh();
//    scene->UpdateData();
//    scene->Refresh();

//    pSceneControl->GetScene3D()->GetCamera(_U("Camera"))->FlyTo(model);
//    pSceneControl->GetScene3D()->Refresh();
//    scene->ToXML(0,_U("MapWorkspace"));
}

//显示装订航线对话框
void MainWindow::showBindRouteDialog()
{
    UGDataSource* ds = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));
    UGDatasetVector* bindRoute_dv = NULL;
    //获取线数据集
    if(mapType==MapType::Map2D)
        bindRoute_dv = (UGDatasetVector*)ds->GetDataset(lineSetAlias).get();
    else
        bindRoute_dv = (UGDatasetVector*)ds->GetDataset(line3DSetAlias).get();
    bindRoute_dv->Open();

    //显示装订对话框
    bindRouteDialog bindRouteDlg;
    bindRouteDlg.setDataset(bindRoute_dv);
    bindRouteDlg.exec();

    bindRoute_dv = NULL;
    ds = NULL;
}

//显示输入坐标点对话框
void MainWindow::showComputeOffsetPosition()
{
//    qMapControl->ifComputePointMode = true; //开始自动计算点模式

    QPoint LPressPoint = qMapControl->getLMousePressPoint();
//    qDebug()<<"*******************x:"<<LPressPoint.x();
//    qDebug()<<"*******************y:"<<LPressPoint.y();

    inputPosDlg->setGeometry(LPressPoint.x()+5,LPressPoint.y()+5,inputPosDlg->size().width(),inputPosDlg->size().height());
//    inputPosDlg.exec();
    inputPosDlg->show();
}

//显示在线地图对话框
void MainWindow::showOnlineMapDialog()
{
    LoadOnlineMapDialog onlineMapDlg;
    if(mapType==MapType::Map2D)
        onlineMapDlg.setWorkspace(m_pWorkspace,qMapControl->GetUGMapWnd());
    else
    {//3DMap
        onlineMapDlg.setScene(pSceneControl);
    }
    onlineMapDlg.exec();
}

// 显示属性右键菜单
void MainWindow::showAttributeMenu()
{
    rMenuType = RBtnMenuType::AttributeMenu;
    connect(actionExportFile,&QAction::triggered,this,&MainWindow::exportKMLFile,Qt::UniqueConnection);
    attributeRBtnMenu->exec(QCursor::pos());
    rMenuType = RBtnMenuType::DefaultMenu;
}

//显示航线分析对话框
void MainWindow::showRouteAnalysisDlg()
{
    UGSelection* selection = qMapControl->getSelectionLayer()->GetSelection();
    if(selection==NULL || selection->GetSize()==0) return;
    UGRecordsetPtr res = selection->ToRecordset();
//    UGGeometry* geometry = NULL;
//    res->GetGeometry(geometry);

    if(g_DEMCollection.size()==0)
    {
        QMessageBox::information(NULL,"提示","未添加高程数据");
        return;
    }
    //此处应该从g_DEMCollection中搜寻匹配覆盖几何对象的dem数据集，此处先暂时默认使用最近添加的dem。
    UGDatasetPtr tmp = m_pWorkspace->GetDataSource(0)->GetDataset(Translator::QStr2UGStr(g_DEMCollection.at(g_DEMCollection.size()-1)));
    UGDatasetRasterPtr dem = dynamic_pointer_cast<UGDatasetRaster>(tmp);

    RouteAnalysisDialog routeAnalysisDlg;
    routeAnalysisDlg.SetRecordset(res);
    routeAnalysisDlg.SetDem(dem);
    routeAnalysisDlg.InitDialog();
    routeAnalysisDlg.exec();
}

//二三维地图切换
void MainWindow::transformMap()
{
    if(pSceneView == NULL)
    {
        //三维场景容器初始化
        initSceneControl(stackedWidget);
        stackedWidget->addWidget(pSceneView);
        pSceneView->startRender(30);
//        pSceneView->setCursor(Qt::OpenHandCursor);
//        UGDatasetVector* dv = (UGDatasetVector*)m_pWorkspace->GetDataSource(0)->GetDataset(_U("Plane")).get();
//        ShowPlane3D* showPlane3D = new ShowPlane3D(pSceneControl,dv);
//        showPlane3D->setPlanesCount(3);
//        showPlane3D->setPlanesCount(1);
    }

    switch (mapType) {
    case MapType::Map2D://切换为3D地图
        {
            stackedWidget->setCurrentIndex(1);
            actionTransformMap->setIcon(QIcon(":/Resources/view_2d.png"));
            actionTransformMap->setIconText("2D地图");
            mapType = MapType::Map3D;
        }
        break;
    case MapType::Map3D: //切换为2D地图
        {
            stackedWidget->setCurrentIndex(0);
            actionTransformMap->setIcon(QIcon(":/Resources/view_3d.png"));
            actionTransformMap->setIconText("3D地图");
            mapType = MapType::Map2D;
        }
        break;
    default:
        break;
    }
}

//导入场景数据
void MainWindow::importSceneData(QStringList imagePathList, QStringList terrainPathList)
{
    qDebug() << "当前线程对象的地址: " << QThread::currentThread();
    int imageDataCount = imagePathList.size();
    int terrainDataCount = terrainPathList.size();
    //显示进度条
    progressDlg = new QProgressDialog();
    progressDlg->setLabelText("影像文件导入中(0/" + QString::number(imageDataCount) + ")..."
                              + "\n"
                              + "地形文件导入中(0/" + QString::number(terrainDataCount) + ")...");
    progressDlg->setWindowFlags(Qt::CustomizeWindowHint|Qt::WindowMinimizeButtonHint);
    progressDlg->setWindowTitle("提示");
    progressDlg->setCancelButton(nullptr);
    QProgressBar* bar = new QProgressBar(progressDlg);
    bar->setRange(0, 0);
    bar->setValue(0);
    progressDlg->setBar(bar);
    progressDlg->setMinimumWidth(600);
    progressDlg->setMinimumDuration(0);
    progressDlg->setWindowModality(Qt::WindowModal);
    progressDlg->setValue(0);
    progressDlg->setAttribute(Qt::WA_DeleteOnClose);//关闭窗口时自动释放内存
    progressDlg->showNormal();

    /*******************************多线程导入数据(线程池方式)*******************************/
    /*
    // 线程池初始化，设置最大线程池数
    QThreadPool::globalInstance()->setMaxThreadCount(5);
    if(pSceneControl == NULL) return;
    UGDataSource* pDataSource = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));
    if(pDataSource->IsOpen()) pDataSource->Open();
    LoadTiffSceneData* loadImageTask = NULL;
    LoadTiffSceneData* loadTerrianTask = NULL;
    if(!imagePathList.isEmpty())
    {
        for(int i = 0;i<imagePathList.size();i++)
        {
//            progressDlg->setLabelText("影像文件(" + QString::number(i+1) + "/" + QString::number(imagePathList.size()) + ")导入中...");
            QFileInfo fileInfo(imagePathList.at(i));
            imageDataList.append(fileInfo.baseName());
            UGString imageName = Translator::QStr2UGStr(fileInfo.baseName());
            loadImageTask = new LoadTiffSceneData(pSceneControl,pDataSource,imageName,imagePathList.at(i),UGImportParams::ModeIMG);
            connect(loadImageTask,&LoadTiffSceneData::sendTaskName,this,&MainWindow::closedProgressDialog);
            QThreadPool::globalInstance()->start(loadImageTask);
            loadImageTask = NULL;
        }
    }

    if(!terrainPathList.isEmpty())
    {
        for(int j = 0;j<terrainPathList.size();j++)
        {
//            progressDlg->setLabelText("地形文件(" + QString::number(j+1) + "/" + QString::number(terrianPathList.size()) + ")导入中...");
            QFileInfo fileInfo(terrainPathList.at(j));
            terrainDataList.append(fileInfo.baseName());
            UGString terrianName = Translator::QStr2UGStr(fileInfo.baseName());
            loadTerrianTask = new LoadTiffSceneData(pSceneControl,pDataSource,terrianName,terrainPathList.at(j),UGImportParams::ModeGrid);
            connect(loadTerrianTask,&LoadTiffSceneData::sendTaskName,this,&MainWindow::closedProgressDialog);
            QThreadPool::globalInstance()->start(loadTerrianTask);
            loadTerrianTask = NULL;
        }
    }
    */

    /*******************************多线程导入数据*******************************/
    if(pSceneControl == NULL) return;
    UGDataSource* pDataSource = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));
    if(pDataSource->IsOpen()) pDataSource->Open();
//    pSceneView->stopRender();
    // 创建线程对象
    QThread* loadSceneDataThread = new QThread();
    // 创建工作的类对象
    LoadSceneDataThread* loadSceneDataTask = new LoadSceneDataThread;

    loadSceneDataTask->moveToThread(loadSceneDataThread);
    loadSceneDataThread->start();

    connect(this,&MainWindow::sendSceneDataList,loadSceneDataTask,&LoadSceneDataThread::receiveFileList);
//    connect(loadSceneDataTask,&LoadSceneDataThread::sendTaskName,this,&MainWindow::closedProgressDialog);
    connect(loadSceneDataTask,&LoadSceneDataThread::sendTaskFinishedCount,this,[=](int imageFinishedCount,int imageTotalCount,int terrianFinishedCount,int terrianTotalCount){
        progressDlg->setLabelText("影像文件导入中(" + QString::number(imageFinishedCount) + "/" + QString::number(imageTotalCount) + ")..."
                                  + "\n"
                                  + "地形文件导入中(" + QString::number(terrianFinishedCount) + "/" + QString::number(terrianTotalCount) + ")...");
        qDebug()<<"*********************ProgressDlgSetLabelTextSuccessed";
        if((imageFinishedCount == imageTotalCount) && (terrianFinishedCount == terrianTotalCount))
        {
            qDebug()<<"*********************CloseProgressDlg";
            progressDlg->close();
//            delete progressDlg;
            progressDlg = NULL;
            qDebug()<<"*********************DeletedProgressDlg";
            UGScene3D* pScene = pSceneControl->GetSceneEditWnd()->GetScene3D();
            // 显示到数据集范围
            if(imageTotalCount>0)
            {
                //pScene->GetCamera(_U("Camera"))->FlyToBounds(pScene->m_Layers.GetLayerInnerAt(0)->GetBounds(), 1);
                pSceneControl->ViewToLayer(pScene->m_Layers.GetLayerInnerAt(0));
            }
            //释放线程
            loadSceneDataThread->quit();
            loadSceneDataThread->wait();
            loadSceneDataThread->deleteLater();
            qDebug()<<"*********************DeletedThread";
            loadSceneDataTask->deleteLater();
            qDebug()<<"*********************DeletedTask";
            //test代码
            loadModelData();
        }
//        m_mutex.unlock();
    });
//    loadSceneDataTask->receiveFileList(pSceneControl,pDataSource,imagePathList,terrainPathList);

    emit sendSceneDataList(pSceneControl,pDataSource,imagePathList,terrainPathList);

    /*
    QThreadPool::globalInstance()->setMaxThreadCount(8);
    if(pSceneControl == NULL) return;
    UGDataSource* pDataSource = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));
    if(pDataSource->IsOpen()) pDataSource->Open();
    GeoFileParser geoFileParser;
    UGString ugImageLayerName;
    UGLayer3D* pLayer = NULL;
    UGString ugTerrianLayerName;
    UGTerrainAccessor* tm = NULL;

    //导入影像数据
    if(!imagePathList.isEmpty())
    {
//        ShowProgressDialog* progressDlg = new ShowProgressDialog();
//        connect(this,&MainWindow::closedProgressDialog,progressDlg,&ShowProgressDialog::closedProgressDialog);
//        QThreadPool::globalInstance()->start(progressDlg);
//        qDebug()<<"*****************activeThreadCount:"<<QThreadPool::globalInstance()->activeThreadCount();
//        QTimer* timer = new QTimer();
//        connect(timer, &QTimer::timeout, progressDlg, &ShowProgressDialog::updateProgressDialog);
//        timer->start(100);//开启一个没有终点的定时器

        for(int i = 0;i<imagePathList.size();i++)
        {
//            progressDlg->setLabelText("影像文件(" + QString::number(i+1) + "/" + QString::number(imagePathList.size()) + ")导入中...");
            QFileInfo fileInfo(imagePathList.at(i));
            UGString imageName = Translator::QStr2UGStr(fileInfo.baseName());
            QElapsedTimer mstimer;
            mstimer.start();
            bool ss = geoFileParser.importTiffData(pDataSource,imageName,imagePathList.at(i),true);
            float time = (double)mstimer.nsecsElapsed() / (double)1000000;
            qDebug() << "ImageTime:::" << time/1000;
            if(ss)
            {
                ugImageLayerName = imageName + _U("@") + Translator::QStr2UGStr(routeName); // 数据集名@数据源名，图层默认命名格式，也是通过该格式的名称获得关联数据
                pLayer = pSceneControl->GetSceneEditWnd()->GetScene3D()->m_Layers.AddLayer(ugImageLayerName);
            }
        }
        emit closedProgressDialog();
    }
    //导入地形数据
    if(!terrianPathList.isEmpty())
    {
        for(int j = 0;j<terrianPathList.size();j++)
        {
//            progressDlg->setLabelText("地形文件(" + QString::number(j+1) + "/" + QString::number(terrianPathList.size()) + ")导入中...");
            QFileInfo fileInfo(terrianPathList.at(j));
            UGString terrianName = Translator::QStr2UGStr(fileInfo.baseName());
            QElapsedTimer mstimer;
            mstimer.start();
            bool ss = geoFileParser.importTiffData(pDataSource,terrianName,terrianPathList.at(j),true,
                                         UGImportParams::ModeGrid,UGDataCodec::encLZW);
            float time = (double)mstimer.nsecsElapsed() / (double)1000000;
            qDebug() << "TerrianTime:::" << time/1000;
            if(ss)
            {
                ugTerrianLayerName = terrianName + _U("@") + Translator::QStr2UGStr(routeName); // 数据集名@数据源名，图层默认命名格式，也是通过该格式的名称获得关联数据
                tm = pSceneControl->GetSceneEditWnd()->GetScene3D()->m_TerrainLayer3Ds.AddTerrainLayer(ugTerrianLayerName,terrianName);
            }
        }
    }

//    progressDlg->close();
//    delete progressDlg;

    if(!imagePathList.isEmpty())
    {
        pSceneControl->ViewToLayer(pLayer);
    }
    */

}

//显示模拟飞行对话框
void MainWindow::showFlySimulatedDlg()
{
    flySimulatedDlg = new FlySimulatedDlg();
    flySimulatedDlg->show();
}

//关闭进度条
void MainWindow::closedProgressDialog(QString taskName)
{
    /***************************************线程池方式********************************/
    /*
    m_mutex.lock();
    int imageIndex = imageDataList.indexOf(taskName);
    int terrainIndex = terrainDataList.indexOf(taskName);
    if(imageIndex>=0)
    {
        imageDataList.removeAt(imageIndex);
    }
    if(terrainIndex>=0)
    {
        terrainDataList.removeAt(terrainIndex);
    }

    QString importImageCount = QString::number(imageDataCount - imageDataList.size());
    QString importTerrainCount = QString::number(terrainDataCount - terrainDataList.size());

    progressDlg->setLabelText("影像文件导入中(" + importImageCount + "/" + QString::number(imageDataCount) + ")..."
                              + "\n"
                              + "地形文件导入中(" + importTerrainCount + "/" + QString::number(terrainDataCount) + ")...");
    if(imageDataList.isEmpty() && terrainDataList.isEmpty())
    {
        progressDlg->close();
        delete progressDlg;
        progressDlg = NULL;
        UGScene3D* pScene = pSceneControl->GetSceneEditWnd()->GetScene3D();
        // 显示到数据集范围
        pScene->GetCamera(_U("Camera"))->FlyToBounds(pScene->m_Layers.GetLayerInnerAt(0)->GetBounds(), 1);
    }
    m_mutex.unlock();
    */
}

//显示三维航点设置对话框
void MainWindow::showSettingFlightPoint3DDialog()
{
    SettingFlightPoint3DDialog* settingFlightPoint3DDlg = new SettingFlightPoint3DDialog();
    connect(pSceneView,&SceneView::sendTrackingGeometry,settingFlightPoint3DDlg,&SettingFlightPoint3DDialog::receiveTrackingGeometry);
    connect(pSceneView,&SceneView::sendTrackedGeometry,settingFlightPoint3DDlg,&SettingFlightPoint3DDialog::receiveTrackedGeometry);
    connect(settingFlightPoint3DDlg,&SettingFlightPoint3DDialog::showSaveRouteDialog,this,&MainWindow::showSaveRoute3DDialog);
    settingFlightPoint3DDlg->show();
}

//显示三维航线保存对话框
void MainWindow::showSaveRoute3DDialog(UGGeometry* pGeometry)
{
    saveRouteDialog saveRoute3DDlg;
    //显示对话框
    saveRoute3DDlg.setMaxValue(1);
    saveRoute3DDlg.setDrawMode(1);
    saveRoute3DDlg.setHeightVisible(false);
    int ret = saveRoute3DDlg.exec();
    if(ret==QDialog::Rejected) return;

    //获取数据集
    UGDataSource* ds = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));
    UGDatasetVector* dv = (UGDatasetVector*)ds->GetDataset(line3DSetAlias).get();
    if(!dv->Open()) dv->Open();
    //提取属性信息
    RouteGlobalVariant routeGVar;
    QMap<QString,QString> fieldsValue;
    fieldsValue.insert(routeGVar.routeFieldsName.RouteID,QString::number(dv->GetObjectCount()+1));
    fieldsValue.insert(routeGVar.routeFieldsName.RouteNumber,QString::number(saveRoute3DDlg.getRouteNumber()[1]));
    fieldsValue.insert(routeGVar.routeFieldsName.RouteType,QString::number(saveRoute3DDlg.getRouteType()[1]));
    fieldsValue.insert(routeGVar.routeFieldsName.IsClosedRoute,QString::number(saveRoute3DDlg.getRouteClosedState()[1]));

    //写入数据集
    GeoFeatureOperator geoFtOpt;
    geoFtOpt.importGeometry3DAttribute(dv,pGeometry,fieldsValue);
    //移除临时图层
    UGString layername = routeGVar.line3DTempDtName + _U("@") + ds->GetAlias();
    pSceneControl->removeLayer3D(layername);

    ds = NULL;
    dv = NULL;
}

//高亮当前导入的KML 3D几何对象
void MainWindow::highLightKMLGeometry(int currentGeometryID, int lastGeometryID)
{
    UGTrackingLayer3D* trackingLayer3D = pSceneControl->GetTrackingLayer3D();
    qDebug()<<"********************currentGeometryID:"<<currentGeometryID;
    qDebug()<<"********************lastGeometryID:"<<lastGeometryID;
    qDebug()<<"***********************Count:"<<trackingLayer3D->GetCount();
    RouteGlobalVariant routeGVar;
    UGStyle3D sty;
//    取消原高亮几何对象
//    routeGVar.getHighLightStyle3D(sty);
    routeGVar.getTemporaryStyle3D(sty);
    UGRenderObject* ro = trackingLayer3D->GetAt(lastGeometryID-1); //
//    ro->SetAffectedByGlobalEffects(false);
//    ro->SetStyle3D(&sty);
    ro->GetStyle3D()->SetLineColor3D(sty.GetLineColor3D()); //
//                qDebug()<<"********************R:"<<ro->GetStyle3D()->GetLineColor3D().r;
//                qDebug()<<"********************g:"<<ro->GetStyle3D()->GetLineColor3D().g;
//                qDebug()<<"********************b:"<<ro->GetStyle3D()->GetLineColor3D().b;
//                qDebug()<<"********************Type:"<<ro->GetType();
//     高亮新几何对象
    routeGVar.getHighLightStyle3D(sty);
    UGRenderObject* ro1 = trackingLayer3D->GetAt(currentGeometryID-1);//
//    ro1->SetAffectedByGlobalEffects(false);
//    ro1->SetStyle3D(&sty);
    ro1->GetStyle3D()->SetLineColor3D(sty.GetLineColor3D()); //
//    pSceneControl->GetScene3D()->UpdateData();
//    pSceneControl->GetScene3D()->Refresh();
//    pSceneControl->Refresh();
}

//右键菜单处理函数
void MainWindow::contextMenuEvent(QContextMenuEvent *event)
{
    if(rMenuType==RBtnMenuType::DefaultMenu && mapType == MapType::Map2D)
    {
        mapRBtnMenu->exec(QCursor::pos());	// 右键菜单被模态显示出来了
    }

    if(rMenuType==RBtnMenuType::DefaultMenu && mapType == MapType::Map3D)
    {

        UGCameraWorld* camera = pSceneControl->GetScene3D()->GetCamera(_U("Camera"));
        UGCameraState cs = camera->m_StateCamera;
//        pSceneControl->GetCameraWorld()->GetCamera(cs);
        qDebug()<<"*************lat:"<<cs.dLat*180/PI;
        qDebug()<<"*************lon:"<<cs.dLon*180/PI;
        qDebug()<<"*************Distance:"<<cs.dDistance;
        qDebug()<<"*************Altitude:"<<cs.dAltitude;
        qDebug()<<"*************Heading:"<<cs.dHeading*180/PI;
        qDebug()<<"*************Roll:"<<cs.dRoll*180/PI;
        qDebug()<<"*************Tilt:"<<cs.dTilt*180/PI;
        qDebug()<<"******************Lookat***********************";
        UGCameraState cs1 = camera->m_StateLookAt;
        qDebug()<<"*************lat1:"<<cs1.dLat*180/PI;
        qDebug()<<"*************lon1:"<<cs1.dLon*180/PI;
        qDebug()<<"*************Distance1:"<<cs1.dDistance;
        qDebug()<<"*************Altitude1:"<<cs1.dAltitude;
        qDebug()<<"*************Heading1:"<<cs1.dHeading*180/PI;
        qDebug()<<"*************Roll1:"<<cs1.dRoll*180/PI;
        qDebug()<<"*************Tilt1:"<<cs1.dTilt*180/PI;

//        UGVector3d vPos;
//        UGQuaternion4d q;
//        UGCameraWorld::PosAndOrientation2CameraState(vPos,q,cs);
//        qDebug()<<"*************vPos.x:"<<vPos.x;
//        qDebug()<<"*************vPos.y:"<<vPos.y;
//        qDebug()<<"*************vPos.z:"<<vPos.z;

//        qDebug()<<"*************q.x:"<<q.x;
//        qDebug()<<"*************q.y:"<<q.y;
//        qDebug()<<"*************q.z:"<<q.z;
//        qDebug()<<"*************q.w:"<<q.w;



//        if(pSceneControl->GetSceneEditWnd()->GetUserAction() != 105) return;
        if(pSceneView->isEditStateFlag)
        {//处于编辑模式，不弹出右键菜单
            pSceneView->isEditStateFlag = false;
            return;
        }
        sceneRBtnMenu->exec(QCursor::pos());	// 右键菜单被模态显示出来了
    }

    //    qDebug()<<"*****************contextMenuEvent:";
}

//启动接收实时位置数据总线程
void MainWindow::startReceiveRealTimePositionInfoThread()
{
    receiveRealTimePositionInfoThread = new QThread;
    receiveRealTimePositionInfoTask = new RealTimePositionInfoThread;
    receiveRealTimePositionInfoTask->moveToThread(receiveRealTimePositionInfoThread);
    receiveRealTimePositionInfoThread->start();
}

//关闭接收实时位置数据总线程
void MainWindow::closeReceiveRealTimePositionInfoThread()
{
    receiveRealTimePositionInfoTask->deleteLater();
    receiveRealTimePositionInfoThread->quit();
    receiveRealTimePositionInfoThread->wait();
    receiveRealTimePositionInfoThread->deleteLater();
}

//启动碰撞检测子线程
void MainWindow::startCollisionDetectThread(int ms)
{
    collisionThread = new QThread;
    collisionDetectionTask = new CollisionDetectionThread(qMapControl);
    collisionDetectionTask->moveToThread(collisionThread);
    collisionThread->start();

    connect(receiveRealTimePositionInfoTask,&RealTimePositionInfoThread::sendCollisionDetectPosInfo,collisionDetectionTask,&CollisionDetectionThread::receiveLocationData);
    connect(collisionDetectionTask,&CollisionDetectionThread::requestPositionInfo,receiveRealTimePositionInfoTask,&RealTimePositionInfoThread::startSendCollisionDetectionPosInfo);
    connect(this,&MainWindow::startCollisionDetect,collisionDetectionTask,&CollisionDetectionThread::start);
    connect(receiveRealTimePositionInfoTask,&RealTimePositionInfoThread::sendCollisionDetectPosInfo,collisionDetectionTask,&CollisionDetectionThread::receiveLocationData);
    connect(collisionDetectionTask,&CollisionDetectionThread::showNotify,this,&MainWindow::showNotify);

    connect(collisionDetectionTask,&CollisionDetectionThread::closedCollisionDetection,receiveRealTimePositionInfoTask,&RealTimePositionInfoThread::stopSendCollisionDetectionPosInfo);

    emit startCollisionDetect(ms);
}

//关闭碰撞检测子线程
void MainWindow::closeCollisionDetectThread()
{
    connect(this,&MainWindow::closeCollisionDetect,collisionDetectionTask,&CollisionDetectionThread::closedCollisionDetection);
    connect(collisionThread,&QThread::finished,[=](){
        collisionThread->deleteLater();
    });

    emit closeCollisionDetect();
    collisionDetectionTask->deleteLater();//任务对象销毁
    collisionThread->quit();//结束线程消息循环
    collisionThread->wait();
}

//********用于测试*************
void MainWindow::test()
{
    UGLayer3D* layer3D = pSceneControl->GetSceneEditWnd()->GetScene3D()->m_Layers.AddLayer(_U("大陆机场18@Route"));
//    bool b = pSceneControl->GetTrackingLayer3D()->Open(_U("E:/Plane.kml"));
    UGLayer3D* modelLayer = pSceneControl->GetUGLayer3Ds()->AddLayer(_U("Plane@Route"));
//    UGStyle3D style = modelLayer->GetStyle3D();
//    UGColor cFB = style.GetFillBackColor();
//    UGColor cFC = style.GetFillForeColor();
//    UGColor cFix = style.GetFixedColor();
    pSceneControl->ViewToModelLayer(modelLayer);
//    pSceneControl->ViewToLayer(layer3D);

//    UGTrackingLayer3D* trackingLayer = pSceneControl->GetTrackingLayer3D();
//    UGGeoPoint3D* geoPt = new UGGeoPoint3D;
//    geoPt->SetPosition(UGPoint3D(119.719160032812,32.2338551438965,30));
//    UGStyle sty3D;
//    sty3D.SetMarkerSize(16);
//    geoPt->SetStyle3D(&sty3D);
//    trackingLayer->Add(geoPt,_U("point"));
//    UGRenderObject* ro = trackingLayer->GetAt(0);
//    int type = ro->GetType();

//    loadModelData();

    /*地形碰撞检测
    testFlag = !testFlag;
    qDebug()<<"*******************:"<<testFlag;
    qDebug() << "MainThread address: " << QThread::currentThread();

    startReceiveRealTimePositionInfoThread();

    QThread* sendDataThread = new QThread;
    SendDataTestThread* sendDataTask = new SendDataTestThread;
    sendDataTask->moveToThread(sendDataThread);
    sendDataThread->start();
    connect(sendDataTask,&SendDataTestThread::sendPositionData,receiveRealTimePositionInfoTask,&RealTimePositionInfoThread::receiveRealTimePositionInfo);
    connect(this,&MainWindow::startGenerate,sendDataTask,&SendDataTestThread::working);
    connect(this,&MainWindow::stopGenerate,sendDataTask,&SendDataTestThread::stopGenerateData);
    connect(sendDataThread,&QThread::finished,this,[=](){
        qDebug()<<"*******************finished:";
    });

    //二维飞机实时位置显示测试
    ShowPlane* m_pShowPlane = new ShowPlane(qMapControl);
    Plane* plane = new Plane("plane1",2,119.668,32.23);
    m_pShowPlane->addPlane(plane);
    connect(m_pShowPlane,&ShowPlane::requestPositionInfo,receiveRealTimePositionInfoTask,&RealTimePositionInfoThread::startSendDisplayInfo);
    connect(receiveRealTimePositionInfoTask,&RealTimePositionInfoThread::sendDisplayInfo,m_pShowPlane,&ShowPlane::receivePositionInfo);

    if(testFlag)
    {
        emit startGenerate();
//        emit startCollisionDetect(1000);
        startCollisionDetectThread(1000);
    }
    m_pShowPlane->startFly();

    if(!testFlag) emit testEnd();
    */
}

//气泡消息通知
void MainWindow::showNotify(QString title, QString body, QVariantMap data)
{
    notifyManager->notify(title,body,data);
}

//Slot:打开栅格地图
void MainWindow::openRasterMap()
{
    //获取工作空间中的地图对象
    //初始化一个空的地图，并与工作空间建立联系
    //地图中的数据就来源于工作空间打开的数据源
    UGMap* pMap = qMapControl->GetMap();
    pMap->SetLineSmoothingMode(false);
    pMap->SetWorkspace(m_pWorkspace);

    //获取影像文件路径
    QString qStrPath = QFileDialog::getOpenFileName(this,QString::fromLocal8Bit("OpenWorkSpace"),
                                ":/supermap-iobjectscpp/MyProject/MapDisplay/SampleData/",
                                "GeoTIFF"+tr(u8"文件")+"(*.tif)");

    if(qStrPath.isEmpty())
    {
        return;
    }

    //打开文件型数据库
    UGDataSource* dataSource = m_pWorkspace->OpenDataSource(Translator::QStr2UGStr(qStrPath),
                                                            _U("tiffImage"),
                                                            UGEngineType::ImagePlugins);
    if(dataSource == NULL)
    {
        return;
    }
    else
    {
        //获取第一个数据集
        UGDatasetPtr dataset = dataSource->GetDataset(0);
        LayerOperator layerOpt;
        // 用自己实现的方法将dataset展示到地图中
        layerOpt.appendDatasetToMap(dataset,pMap);
    }
    //刷新地图窗口
    qMapControl->Refresh();

//    pMap = NULL;
    dataSource = NULL;

    /************************************test*******************************/

//    UGGeoPoint* p = new UGGeoPoint();
//    p->SetX(119.718414);
//    p->SetY(32.234539);
//    UGStyle sty;
//    sty.SetMarkerStyle(-1);
//    sty.SetMarkerSize(16);
//    sty.SetFillForeColor(UGRGB(0,255,0));
//    sty.SetMarkerStyle(907711); //907711
//    sty.SetMarkerWidth(20);
//    sty.SetMarkerHeight(50);
//    sty.SetFixedPixelSize(true);
//    p->SetStyle(&sty);
//    pMap->m_TrackingLayer.Add(p,_U("a"));
//    UGGeometry* geo = pMap->m_TrackingLayer.GetAt(0)->GetGeometry();
//    delete geo;
//    delete p;
//    pMap->m_TrackingLayer.RemoveAll();
//    pMap->m_TrackingLayer.Remove(_U("a"));
//    qMapControl->Refresh();
//    qDebug()<<"****************:"<<(p==NULL);
//    delete p;
    //    qDebug()<<"****************:"<<(p==NULL);
}

//声明添加高程地图槽函数
void MainWindow::addRasterDEM()
{
    //获取影像文件路径
    QString qStrPath = QFileDialog::getOpenFileName(this,QString::fromLocal8Bit("OpenWorkSpace"),
                                                    ":/supermap-iobjectscpp/MyProject/MapDisplay/SampleData/",
                                                    "GeoTIFF"+tr(u8"文件")+"(*.tif)");
    if(qStrPath.isEmpty())
    {
        return;
    }
    QFileInfo fileinfo(qStrPath);
    QString bName = fileinfo.baseName();
    //打开文件型数据库
    UGDataSource* dataSource = m_pWorkspace->GetDataSource(0);
    if(dataSource == NULL)
    {
        return;
    }
    bool b = geoFileParser.importTiffData(dataSource,Translator::QStr2UGStr(bName),qStrPath,true,UGImportParams::ModeGrid);
    if(b)
    {
        g_DEMCollection.append(bName);
        QMessageBox::information(NULL, "提示","添加高程成功!");
    }
    else
    {
        QMessageBox::information(NULL, "提示","添加高程失败!");
    }

}

/****************地图基础操作**********************/
#pragma region {
//放大地图操作
void MainWindow::zoomIn()
{
   qMapControl->ZoomIn();
}

//缩小地图操作
void MainWindow::zoomOut()
{
    qMapControl->ZoomOut();
}

//全幅显示地图操作
void MainWindow::viewEntire()
{
    qMapControl->ViewEntire();
}

//平移浏览地图操作
void MainWindow::pan()
{
//    pSceneControl->GetScene3D()
//    UGTrackingLayer3D* trackLayer = pSceneControl->GetTrackingLayer3D();
//    trackLayer->SetEditable(true);
////    trackLayer->SetRefresh(false);
//    geoPt = new UGGeoPoint3D();
//    geoPt->SetPosition(UGPoint3D(119.719160032812,32.2338551438965,20));
//    UGStyle3D style3D;
//    style3D.SetMarkerSize(16);
//    geoPt->SetStyle3D(&style3D);
//    UGRenderObject* ro = trackLayer->Add(geoPt,_U("pt"));

//    UGGeoPoint3D* geoPt1 = new UGGeoPoint3D();
//    geoPt1->SetPosition(UGPoint3D(119.73,32.2338551438965,20));
//    geoPt1->SetStyle3D(&style3D);
//    trackLayer->SetGeometryAt(0,geoPt1);

//    UGRenderFeature* rft = (UGRenderFeature*)ro;
//    UGGeoPoint3D* dyPt = (UGGeoPoint3D*)rft->GetGeometry();
////    UGGeoModel* geo = (UGGeoModel*)rft->GetGeometry();
//    UGPoint3D pt1 = dyPt->GetPosition();

//    QTimer* timer1 = new QTimer;
//    connect(timer1,&QTimer::timeout,this,&MainWindow::moveGeoPoint3D);
//    timer1->start(500);


    UGLayer3D* planeLayer = pSceneControl->GetUGLayer3Ds()->GetLayerInnerAt(0);
//    planeLayer->SetRefresh(false);
    //获取模型位置
    UGDatasetVector* dv = (UGDatasetVector*)planeLayer->GetAttachData();
    dv->Open();
    UGQueryDef queryDef;
    UGRecordsetPtr res = dv->Query(queryDef);
//    UGGeometry* temp = NULL;
//    res->GetGeometry(temp);
//    UGGeoModelPro* model = (UGGeoModelPro*)temp;
//    UGPoint3D pt3D = model->GetPosition();
//    model->HitTest3D(pt3D,0.01);


    QTimer* timer = new QTimer;
    connect(timer,&QTimer::timeout,this,[=](){
        res->Edit();
        UGGeometry* temp = NULL;
        //    res->GetGeometryDirect(geometry);
        res->GetGeometry(temp);
        UGGeoModelPro* model = (UGGeoModelPro*)temp;
        UGPoint3D pt3D = model->GetPosition();
        pt3D.z = pt3D.z-1;
        qDebug()<<"******************TimeOut Z:"<<pt3D.z;
        //    model->Offset3D(pt3D.x,pt3D.y,pt3D.z+5);
        model->SetPosition(pt3D);
//        UGPoint3D pt3D1 = model->GetPosition();
        res->SetGeometry(*model);
        res->Update();
        delete temp;

        UGCameraWorld* camera = pSceneControl->GetCameraWorld();
        camera->SetFlyState(true);
        UGCameraState cameraState = camera->m_StateCamera;
        cameraState.dAltitude = pt3D.z;
        camera->SetCamera(cameraState);

    });
    timer->start(500);


    //LookAt
//    UGCameraState lookatState = camera->m_StateLookAt;
//    lookatState.dLon = UGMathEngine::Degree2Radian(pt3D.x);
//    lookatState.dLat = UGMathEngine::Degree2Radian(pt3D.y);
//    lookatState.dAltitude = pt3D.z;
//    lookatState.dDistance = pt3D.z*2;
//    camera->SetLookAt(lookatState);

//    UGGeometry* geometry = NULL;
//    res->GetGeometry(geometry);
//    UGGeoModelPro* model0 = (UGGeoModelPro*)geometry;
//    UGPoint3D pt3D0 = model0->GetPosition();
//    geometry = NULL;

/*********************以上用于测试*********************************/
//    if(mapType==MapType::Map2D)
//        qMapControl->Pan();
//    else if(mapType==MapType::Map3D)
//        pSceneControl->Pan();
}

void MainWindow::moveGeoPoint3D()
{
    UGRenderPoint3D* rPt = (UGRenderPoint3D*)pSceneControl->GetTrackingLayer3D()->GetAt(0);
    if(rPt==NULL) qDebug()<<"******************rPt=NULL:";
    rPt->SetEditable(true);
    UGGeoPoint3D* pt3D = (UGGeoPoint3D*)rPt->GetGeometry();
    UGPoint3D pos = pt3D->GetPosition();
    UGGeoPoint3D* tp = new UGGeoPoint3D;
    tp->SetPosition(UGPoint3D(pos.x+0.0001,pos.y,pos.z));
    tp->SetStyle3D(pt3D->GetStyle3D());
//    rPt->SetGeometry(pt3D);
    pSceneControl->GetTrackingLayer3D()->SetGeometryAt(0,tp);
    //        rft->SetGeometry(pt);

//    tmp->SetPosition(UGPoint3D(pos.x+0.0001,pos.y,pos.z));
//    qDebug()<<"******************Count:"<<pSceneControl->GetTrackingLayer3D()->GetCount();
    qDebug()<<"******************TimeOut x:"<<pos.x+0.0001;

//    pSceneControl->GetTrackingLayer3D()->Update(pSceneControl->GetScene3D()->GetRenderParam());
//    pSceneControl->GetTrackingLayer3D()->Render(pSceneControl->GetScene3D()->GetRenderParam());
//    pSceneControl->GetScene3D()->Refresh();
}

//选择要素操作
void MainWindow::Select()
{
//    pSceneControl->Refresh();

    if(mapType==MapType::Map2D)
        qMapControl->Select();
    else if(mapType==MapType::Map3D)
        pSceneControl->Select();
}

//开启编辑
void MainWindow::Edit()
{
//    UGMapEditorWnd* editorWnd = qMapControl->GetUGMapWnd();
//    editorWnd->SetSnapedPointColor(UGRGB(255,0,0)); //有效
//    editorWnd->SetSnapedLineColor(UGRGB(255,0,0)); //有效
//    editorWnd->SetGridSnape(true);
//    UGStyle sty;
//    sty.SetLineColor(UGRGB(255,0,0));
//    editorWnd->SetSnapedStyle(1,&sty);

    if(mapType==MapType::Map2D)
    {
        if(!qMapControl->getEditStatus())
        {
            qMapControl->setEditStatus(true);
            qMapControl->GetMap()->m_Layers.ClearLayersSelection();
            qMapControl->GetMap()->m_DynamicLayers.RemoveAll();
            actionStartEdit->setIcon(QIcon(":/Resources/Edit.png"));
            actionEditNode->setEnabled(true);
            qMapControl->Refresh();
        }
        else
        {
            qMapControl->setEditStatus(false);
            UGLayers* layers = &qMapControl->GetMap()->m_Layers;
            UGLayer* editLayer = layers->GetEditableLayer().GetHead();
//            layers->SetEditableLayer(editLayer,false);
            qMapControl->setEditable(editLayer,false);

            actionStartEdit->setIcon(QIcon(":/Resources/Edit1.png"));
            actionEditNode->setIcon(QIcon(":/Resources/EditNode1.png"));
            actionEditNode->setEnabled(false);

            LayerOperator layerOpt;
            layerOpt.addNodeLabel(qMapControl,editLayer->GetSelection()->ToRecordset(false));
            editLayer->ClearSelection();
            qMapControl->Refresh();
            if(editLayer!=NULL)
                qDebug()<<"****************editLayer:"<<Translator::UGStr2QStr(editLayer->GetName());
        }
        /*
        UGLayer* editLayer = qMapControl->getSelectionLayer();
        if(editLayer!=NULL)
        {
            if(!editLayer->IsEditable())
            {//开启编辑
                qDebug()<<"***********************OpenEdit:";
                qMapControl->setEditable(editLayer,true);
                qMapControl->GetMap()->m_DynamicLayers.RemoveAll();
                qMapControl->Refresh();

                actionStartEdit->setIcon(QIcon(":/Resources/Edit.png"));
                //actionEditNode->setIcon(QIcon(":/Resources/EditNode.png"));
                actionEditNode->setEnabled(true);
            }
            else
            {//关闭编辑
                qDebug()<<"***********************CloseEdit:";
                qMapControl->setEditable(editLayer,false);
                actionStartEdit->setIcon(QIcon(":/Resources/Edit1.png"));
                actionEditNode->setIcon(QIcon(":/Resources/EditNode1.png"));
                actionEditNode->setEnabled(false);

                LayerOperator layerOpt;
                layerOpt.addNodeLabel(qMapControl,editLayer->GetSelection()->ToRecordset(false));
                editLayer->ClearSelection();
                qMapControl->Refresh();
            }
            editLayer = NULL;
        }
        */
    }
    else
    {//三维
        LayerOperator layerOpt;
        if(!pSceneControl->GetEditStatus())
        {//开启编辑
            pSceneControl->SetEditStatus(true);
            pSceneControl->GetUGLayer3Ds()->ReleaseAllSelection();
            pSceneControl->GetTrackingLayer3D()->RemoveAll();

            actionStartEdit->setIcon(QIcon(":/Resources/Edit.png"));
//            actionEditNode->setEnabled(true);
        }
        else
        {//关闭编辑
            pSceneControl->SetEditStatus(false);
            pSceneControl->SetEditableLayer(pSceneControl->GetUGLayer3Ds()->GetCurrrentLayer(),false);
            actionStartEdit->setIcon(QIcon(":/Resources/Edit1.png"));
            actionEditNode->setIcon(QIcon(":/Resources/EditNode1.png"));
            layerOpt.showNodeLabel3D(pSceneControl);
        }
        /*
        UGLayer3D* editLayer3D = pSceneControl->GetSelectionLayer();
        if(editLayer3D!=NULL)
        {
            if(!editLayer3D->GetEditable())
            {
                pSceneControl->SetEditableLayer(editLayer3D,true);
                pSceneControl->GetTrackingLayer3D()->RemoveAll();

                actionStartEdit->setIcon(QIcon(":/Resources/Edit.png"));
                actionEditNode->setEnabled(true);
                qDebug()<<"*********************EditLayerName1:"<<Translator::UGStr2QStr(pSceneControl->GetUGLayer3Ds()->GetCurrrentLayer()->GetName());
            }
            else
            {
                pSceneControl->SetEditableLayer(editLayer3D,false);
                actionStartEdit->setIcon(QIcon(":/Resources/Edit1.png"));
                actionEditNode->setIcon(QIcon(":/Resources/EditNode1.png"));
                actionEditNode->setEnabled(false);
            }
        }
        */

//        qDebug()<<"*********************1:"<<pSceneControl->GetUGLayer3Ds()->GetInnerCount();
    }
}

#pragma endregion }

/****************地图量算操作**********************/
#pragma region {
//量算距离
void MainWindow::calcLength()
{
    qMapControl->CalcuLength();
}

//量算面积
void MainWindow::calcArea()
{
    qMapControl->CalcuArea();
}

//量算角度
void MainWindow::calcAngle()
{
    qMapControl->CalcuAngle();
}

#pragma endregion}

/****************矢量要素绘制**********************/
#pragma region {
//绘制点
void MainWindow::drawPoint()
{
//    qDebug()<<"isEmpty1:"<<m_pWorkspace->m_DataSources.IsEmpty();
//    for (int i=0;i<m_pWorkspace->m_DataSources.GetCount();i++)
//    {
//        qDebug()<<"DataSourceName:"<<Translator::UGStr2QStr(m_pWorkspace->m_DataSources.m_strArrNames[i]);
//    }
    drawMode = 1;
    qMapControl->drawMode = drawMode;
    //获取数据源
    UGDataSource* ds = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));
//    qDebug()<<"Proj:" << ds->GetPrjCoordSys().GetGeoCoordSys().GetTypeID();

    MapDataManeger mapDataManeger;
    UGString pointAlias = _U("Marks");
    if(!ds->GetDataset(pointAlias))
    {//点数据集不存在则创建
        //创建点数据集
        mapDataManeger.createVectorSet(ds,UGDataset::Point,pointAlias);
    }
    //获取点数据集
    UGDatasetPtr pointSet = ds->GetDataset(pointAlias);
    pointSet->SetPrjCoordSys(UGPrjCoordSys(4326));//设置坐标系为WGS1984
//    qDebug()<<"pointSetProj:" << pointSet->GetPrjCoordSys().GetGeoCoordSys().GetTypeID();
    //将点数据集添加到地图
    UGMap* pUGMap = qMapControl->GetMap();
    UGLayer* pointLayer = pUGMap->m_Layers.AddDataset(pointSet,true, UGLayer::UG_Layer_Normal,pointAlias);
    LayerOperator layerOpt;
    layerOpt.setVectorLayerStyle(pointLayer,UGDataset::Point); //设置图层Style
    if (pointLayer != NULL)
    {
        pointLayer->SetSelectable(true); //设置图层可选择
        pUGMap->m_Layers.SetEditableLayer(pointLayer,true);//设置图层可编辑
        qMapControl->GetUGMapWnd()->SetUserAction(UGDrawParamaters::uaEdit,UGEditType::ET_Point);

    }
    else
    {

    }
}

//绘制线
void MainWindow::drawLine()
{
    //获取数据源
    UGDataSource* ds = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));

    GeoFeatureOperator geoFtOpt;
    RouteGlobalVariant routeGVar;
    if(mapType == MapType::Map3D)
    {
        //创建临时数据集
        const UGString datasetName = routeGVar.line3DTempDtName;
        MapDataManeger mapDataMag;
        UGDatasetVector* dv = NULL;
        UGRecordsetPtr res;
        if(ds->GetDataset(datasetName)==NULL)
            dv = mapDataMag.createVectorSet(ds,UGDataset::LineZ,datasetName).get();
        else
        {//清空临时数据集里的全部记录
            dv = (UGDatasetVector*)(ds->GetDataset(datasetName).get());
            if(!dv->IsOpen()) dv->Open();
            UGQueryDef query;
            res = dv->Query(query);
            qDebug()<<"***************RecordCount:"<<res->GetRecordCount();
            res->DeleteAll();
            res->Update();
        }

        UGString layer3DName = datasetName + _U("@") + ds->GetAlias();  //图层名命名为：数据集名@数据源名

        connect(pSceneView,&SceneView::sendTrackedGeometry,this,[=](UGGeometry* pGeometry){
            //接收绘制完成的航线，添加到临时数据集，并显示
            UGGeoLine3D* line3D = (UGGeoLine3D*)pGeometry;
            res->AddNew(line3D);
            res->Update();
            pSceneControl->Refresh();
        });
//        UGDataSource* ds = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));
//        if(!ds->Open()) ds->Open();
//        ds->GetDataset(line3DSetAlias)->Open();
//        pSceneControl->GetSceneEditWnd()->SetUserAction(UGSceneUserAction::suaMeasureDistance);
//        geoFtOpt.drawLine3D(pSceneView,Translator::QStr2UGStr(routeName),line3DSetAlias);
        geoFtOpt.drawLine3D(pSceneView,layer3DName);
    }

    if(mapType == MapType::Map2D)
    {
        drawMode = 2;
        qMapControl->drawMode = drawMode;
        geoFtOpt.drawLine(qMapControl,ds,lineSetAlias);
    }
    ds = NULL;

    /*
    drawMode = 2;
    qMapControl->drawMode = drawMode;
    //获取数据源
    UGDataSource* ds = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));

    //获取线数据集
    UGDatasetPtr lineSet = ds->GetDataset(lineSetAlias);
    lineSet->SetPrjCoordSys(UGPrjCoordSys(4326));//设置坐标系为WGS1984

    //将线数据集添加到地图
    UGMap* pUGMap = qMapControl->GetMap();
    UGLayer* lineLayer = pUGMap->m_Layers.AddDataset(lineSet,true, UGLayer::UG_Layer_Normal,lineSetAlias);
    LayerOperator layerOpt;
    layerOpt.setVectorLayerStyle(lineLayer,UGDataset::Line); //设置图层Style

//    UGStyle stytest;
//    stytest.SetLineStyle(6); //设置线样式
//    stytest.SetLineColor(UGRGB(255,0,0)); //设置符号颜色
//    stytest.SetLineWidth(1); //设置线宽度

    if (lineLayer != NULL)
    {
        lineLayer->SetSelectable(true); //设置图层可选择
        pUGMap->m_Layers.SetEditableLayer(lineLayer,true);//设置图层可编辑
        UGMapEditorWnd* pEditorWnd = qMapControl->GetUGMapWnd();

        pEditorWnd->SetUserAction(UGDrawParamaters::uaEdit,UGEditType::ET_PolyLine);
//        pEditorWnd->SetTrackingStyle(stytest);  //设置交互式绘制几何对象时的风格。
    }
    else
    {

    }
    */
}

//绘制多边形
void MainWindow::drawPolygon()
{
    drawMode = 3;
    qMapControl->drawMode = drawMode;
    qMapControl->GetUGMapWnd()->SetUserAction(UGDrawParamaters::uaEdit,UGEditType::ET_PolyGon);
//    UGDataSource* ds = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));
//    UGDatasetVector* dv = (UGDatasetVector*) ds->GetDataset(2).get();
//////    qDebug()<<"IsOpen:"<< dv->IsOpen();
////    dv->Open();
//////    qDebug()<<"dsName:" << Translator::UGStr2QStr(dv->GetName());
//////    qDebug()<<"RecordsetCount:"<<dv->GetRecordsetCount();

////    UGGeoRegion* rg = new UGGeoRegion();

//    UGQueryDef queryDef;
//    queryDef.m_nOptions = UGQueryDef::Both;
//    queryDef.m_nType = UGQueryDef::General;
//    queryDef.m_nMode = UGQueryDef::GeneralQuery;
//    queryDef.m_nCursorType = UGQueryDef::OpenStatic;  //OpenStatic,用于读取数据；OpenDynamic,用于数据增删改
//    queryDef.m_strFilter = _U("");
//    UGRecordsetPtr re = dv->Query(queryDef);
////    qDebug()<< "@@@@@2:"<<re->m_nRecordCount;
//    qDebug()<< "@@@@@2:"<<(re==NULL);
//    re->MoveFirst();

//    UGVariant v;
//    re->GetFieldValue(_U("smx"),v);

//    UGGeoRegion* r = new UGGeoRegion();
////    UGGeometry* r1  = new UGGeometry(r);
////    re->GetGeometryDirect();
//    qDebug()<< "@@@@@HasGeometry:"<<re->HasGeometry();
//    qDebug()<< "@@@@@2:"<<(re->IsEmpty());

////    re->GetFeature()->GetGeometry()->ConvertToRegion(*r,0);
////    qDebug()<<"PointsCount:"<<r->GetPointCount();

////    const UGPoint2D* p = r->GetPoints();

//    UGGeoRegion reg;
//    UGGeometry * pTempGeomtry = NULL;
//    re->GetGeometry(pTempGeomtry,0);
//    r = dynamic_cast<UGGeoRegion*>(pTempGeomtry);
//    qDebug()<<"PointsCount:"<<r->GetPointCount();

//    qDebug()<<"p:"<<(p==NULL);
//    qDebug()<<"x:"<<p->x;
//    qDebug()<<"y:"<<p->y;
//    qDebug()<<"p:"<<(!p);
//    while(p)
//    {
//        qDebug()<<"YES";
//        qDebug()<<"x:"<<p->x;
//        qDebug()<<"y:"<<p->y;
//        p++;
//    }


//    re->GetGeometryDirect(region);
//    qDebug()<< "@@@@@2:"<<(re==NULL);
//    qDebug()<< "@@@@@HasGeometry:"<<re->HasGeometry();

//    re->GetGeometry(&rg,0);




    /*******************上面是test*************************/
//    qMapControl->createMode = 3;
//    //获取数据源
//    UGDataSource* ds = m_pWorkspace->GetDataSource(Translator::QStr2UGStr(routeName));

//    MapDataManeger mapDataManeger;
//    UGString polygonAlias = _U("Geofencing");
//    if(!ds->GetDataset(polygonAlias))
//    {//点数据集不存在则创建
//        //创建点数据集
//        mapDataManeger.createVectorSet(ds,UGDataset::Region,polygonAlias);
//    }
//    //获取点数据集
//    UGDatasetPtr polygonSet = ds->GetDataset(polygonAlias);
//    polygonSet->SetPrjCoordSys(UGPrjCoordSys(4326));//设置坐标系为WGS1984

//    //将点数据集添加到地图
//    UGMap* pUGMap = qMapControl->GetMap();
//    UGLayer* polygonLayer = pUGMap->m_Layers.AddDataset(polygonSet,true, UGLayer::UG_Layer_Normal,polygonAlias);
//    LayerOperator layerOpt;
    //    layerOpt.setVectorLayerStyle(polygonLayer,UGDataset::Region); //设置图层Style

//    if (polygonLayer != NULL)
//    {
//        polygonLayer->SetSelectable(true); //设置图层可选择
//        pUGMap->m_Layers.SetEditableLayer(polygonLayer,true);//设置图层可编辑
//        qMapControl->GetUGMapWnd()->SetUserAction(UGDrawParamaters::uaEdit,UGEditType::ET_PolyGon);
//    }
//    else
//    {

//    }
}

#pragma endregion}