map-display/displayroutedialog.cpp

#include "displayroutedialog.h"
#include "Geometry/UGGeoLine.h"
#include "mapdatamaneger.h"
#include "qdebug.h"
//#include <QMap>
//#include <QString>
#include <map>
#include <string>
#include "ui_displayroutedialog.h"
#include "geofeatureoperator.h"
#include "translator.h"
#include "messagetips.h"
#include "Map/UGLayer.h"
#include "Map/UGMap.h"
#include "Geometry/UGGeoPoint.h"
#include "routeglobalvariant.h"
#include "layeroperator.h"
#include "Scene/UGLayer3D.h"
#include "Scene/UGTrackingLayer3D.h"
#include "Layer3DDataset/UGLayer3DDatasetVector.h"

DisplayRouteDialog::DisplayRouteDialog(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::DisplayRouteDialog)
{
    ui->setupUi(this);
    this->resize(600,400);
    this->setWindowTitle("显示航线");
    this->setWindowFlags(Qt::WindowCloseButtonHint);  //关闭右上角帮助(?)按钮。

    RouteType = routeGVar.getRouteType();

    this->is3DMap = false;

}

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

void DisplayRouteDialog::setDataset(UGDatasetPtr dt)
{
    this->dt = dt;
    this->dtv = (UGDatasetVector*)dt.get();
}

void DisplayRouteDialog::setMapEditorWnd(UGMapEditorWnd *pMapEditorWnd)
{
    this->pMapEditorWnd = pMapEditorWnd;
    this->is3DMap = false;
}

void DisplayRouteDialog::setSceneControl(SceneControl *pSceneControl)
{
    this->pSceneControl = pSceneControl;
    this->is3DMap = true;
}

void DisplayRouteDialog::addRouteTypeItem()
{
    GeoFeatureOperator gftOpt;
    UGRecordsetPtr res = gftOpt.queryFeature(dtv);
    if(!res) return;
    res->MoveFirst();
    UGVariant v;
//    QSet<int> typeset;
    std::set<int> typeset;
    while(!res->IsEOF())
    {//获取航线类型唯一值
        res->GetFieldValue(_U("RouteType"),v);
        typeset.insert(v.ToInt());
        res->MoveNext();
    }
    for(auto i = typeset.begin(); i != typeset.end(); i ++)
    {
        ui->RouteTypeCbbox->addItem(RouteType[*i]);
    }
}

void DisplayRouteDialog::addRouteNumberItem(UGRecordsetPtr res)
{
    ui->RouteNumberCbbox->clear();
    QStringList strl;
    UGVariant v;
    res->MoveFirst();
    if(res)
    {
        while (!res->IsEOF()) { //获取航线编号
            res->GetFieldValue(_U("RouteNumber"),v);
            strl << Translator::UGStr2QStr(v.ToString());
            res->MoveNext();
        }
    }

    ui->RouteNumberCbbox->addItems(strl);
}

//显示二维航线
void DisplayRouteDialog::showRoute()
{
    routeType = QString::number(RouteType.key(ui->RouteTypeCbbox->currentText()));
    QString typeFilter = "RouteType=" + routeType;

    QStringList routeNumberList = ui->RouteNumberCbbox->currentText().replaceInStrings(";",",");
    QString numFilter = "RouteNumber in (" + routeNumberList.join("\\,") + ")";
//    qDebug()<<"******************************:"<<numFilter;
    //图层几何对象过滤语句
    UGString layerFilter = Translator::QStr2UGStr(numFilter + " and " + typeFilter);

    GeoFeatureOperator gftOpt;
    UGRecordsetPtr res = gftOpt.queryFeature(dtv,layerFilter);
    res->MoveFirst();

    /*********************UGLayer方法*********************/
    UGMap* pMap = &pMapEditorWnd->m_mapWnd.m_Map;
    UGString layerName = Translator::QStr2UGStr(("RouteLayer" + routeType));
    if(!pMap->m_Layers.IsLayerExisted(layerName))
    {
        pMap->m_Layers.AddDataset(dt,true,UGLayer::UG_Layer_Normal,layerName);
    }
    UGLayer* layer = pMap->m_Layers.GetLayer(layerName);
    UGQueryDef queryDef;
    res->GetQueryDef(queryDef);
    layer->SetQueryDef(queryDef);
    //图层样式
    UGStyle lineStyle = routeGVar.getRouteStyle(routeType.toInt());
    layer->SetStyle(lineStyle);

    // 航点标记动态图层
    UGString dylayerName = Translator::QStr2UGStr(("LabelDyLayer" + routeType));
    UGDynamicLayer *pDyLayer = NULL;
    getDyLayer(pMap,pDyLayer,dylayerName);
    //添加航点标记
    UGGeometry* pTempGeomtry = NULL;
    QStringList num = routeNumberList.join("\\,").split(",");
    int i = 0;
    LayerOperator layerOpt;
    UGGeoLine* line = NULL;
    while(!res->IsEOF())
    {
//        line->SetStyle(&lineStyle);
        res->GetGeometry(pTempGeomtry);
        line = (UGGeoLine*)pTempGeomtry;

        QString lineAlias = routeType + "_" + num.at(i);
        pDyLayer->Add(Translator::QStr2UGStr(lineAlias),line);

        layerOpt.addNodeLabel(line,pDyLayer,routeType,num.at(i));

        i++;
        res->MoveNext();
        line = NULL;
    }

    pMapEditorWnd->Refresh();
    pMap = NULL;
    pTempGeomtry = NULL;
    pDyLayer = NULL;
    layer = NULL;
    /******************************************/

    /**********************DyLayer********************/
    /*
    UGGeometry* pTempGeomtry = NULL;

    UGMap* pMap = &pMapEditorWnd->m_mapWnd.m_Map;
    UGDynamicLayer* dyRouteLayer = new UGDynamicLayer();
    dyRouteLayer->SetLayerName(_U("RouteDyLayer"));

    UGString dylayerName = Translator::QStr2UGStr(("DyLabelLayer" + routeType));
    UGDynamicLayer *pDyLayer = NULL;
    getDyLayer(pMap,pDyLayer,dylayerName);

    QStringList num = routeNumberList.join("\\,").split(",");
    int i = 0;

    UGStyle sty;
    sty.SetLineStyle(6); //设置线样式
    sty.SetLineColor(getTypeColor(routeType.toInt())); //设置符号颜色
    sty.SetLineWidth(1); //设置线宽度
    while(!res->IsEOF())
    {
        UGGeoLine* line = new UGGeoLine();
        line->SetStyle(&sty);
//        pMap->m_TrackingLayer.SetSelectable(true);
        res->GetGeometry(pTempGeomtry);
        pTempGeomtry->ConvertToLine(*line);
//        dyRouteLayer->Add();

        QString lineAlias = routeType + "_" + num.at(i);
        dyRouteLayer->Add(Translator::QStr2UGStr(lineAlias),line);

        addNodeLabel(line,pDyLayer,routeType,num.at(i));

        i++;
        res->MoveNext();
    }

    pMap->m_DynamicLayers.Add(pDyLayer);
    pMap->m_DynamicLayers.Add(dyRouteLayer);

    pMapEditorWnd->Refresh();


    qDebug()<<"*************************:"<<(res==NULL);

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

}

// 显示三维航线
void DisplayRouteDialog::showRoute3D()
{
    routeType = QString::number(RouteType.key(ui->RouteTypeCbbox->currentText()));
    QString typeFilter = "RouteType=" + routeType;

    QStringList routeNumberList = ui->RouteNumberCbbox->currentText().replaceInStrings(";",",");
    QString numFilter = "RouteNumber in (" + routeNumberList.join("\\,") + ")";
//    qDebug()<<"******************************:"<<numFilter;
    //图层几何对象过滤语句
    UGString layerFilter = Translator::QStr2UGStr(numFilter + " and " + typeFilter);

    GeoFeatureOperator gftOpt;
    UGRecordsetPtr res = gftOpt.queryFeature(dtv,layerFilter);
    res->MoveFirst();

    UGQueryDef queryDef;
    res->GetQueryDef(queryDef);
//    qDebug()<<"******************************RecordCount0:"<<res->GetRecordCount();
    pSceneControl->m_mapDisplayGeometryID[routeType.toInt()] = res;

    const UGString strDataName = routeGVar.workspaceDataName.Line3DDatasetName + _U("@") + routeGVar.workspaceDataName.DatasourceName;
    const UGString layer3DName = _U("RouteLayer3D") + Translator::QStr2UGStr(routeType);
    UGLayer3Ds* layer3Ds = pSceneControl->GetUGLayer3Ds();
    UGLayer3DDatasetVector* layer3DDv = NULL;
    if(layer3Ds->FindNameInner(layer3DName)>=0)
    {//图层已存在，则重新设置Filter
        layer3DDv = (UGLayer3DDatasetVector*)layer3Ds->GetLayerInner(layer3DName);
        layer3DDv->SetDisplayFilter(queryDef);
    }
    else
    {
        layer3DDv = (UGLayer3DDatasetVector*)layer3Ds->AddLayer(strDataName,layer3DName,_U(""));
        layer3DDv->SetDisplayFilter(queryDef);
    };
    UGStyle3D style3D = routeGVar.getRouteStyle3D(routeType.toInt());
    layer3DDv->SetStyle3D(style3D);

    UGTrackingLayer3D* trackingLayer3D = pSceneControl->GetTrackingLayer3D();

    UGRecordsetPtr tempRes = gftOpt.queryFeature(dtv,Translator::QStr2UGStr(typeFilter));
    gftOpt.removeNodeLabel3D(tempRes,trackingLayer3D); //移除该类型航线注记

    gftOpt.addNodeLabel3D(res,trackingLayer3D);//添加航点注记

    pSceneControl->Refresh(layer3DDv);
    /*
    UGLayer3Ds* layers = pSceneControl->GetUGLayer3Ds();
    UGTrackingLayer3D* trackingLayer3D = pSceneControl->GetTrackingLayer3D();
    //添加到显示数据集
    UGString displayDtName = addGeometry3DToDisplayDataset(res,routeType.toInt());
    UGString displayLayerName = displayDtName + _U("@") + routeGVar.workspaceDataName.DatasourceName;
    int index = layers->FindNameInner(displayLayerName);
    if(index>=0)
    {
        layers->TreeRemoveAt(index); //移除已存在的图层
        //移除航点注记
        trackingLayer3D->RemoveAll();
    }
//    UGLayer3D* displayLayer = pSceneControl->AddLayerFromDataset(routeGVar.workspaceDataName.DatasourceName,displayDtName);
    UGLayer3D* displayLayer = layers->AddLayer(displayLayerName);
    gftOpt.addNodeLabel3D(res,trackingLayer3D);//添加航点注记
    UGStyle3D style3D = routeGVar.getRouteStyle3D(routeType.toInt());
    displayLayer->SetStyle3D(style3D);


    pSceneControl->Refresh(displayLayer);
    displayLayer = NULL;
    layers = NULL;
    trackingLayer3D = NULL;
    */

}

//获取二维动态图层
void DisplayRouteDialog::getDyLayer(UGMap* pMap,UGDynamicLayer* &pDyLayer,UGString dyLayerName)
{
//    qDebug()<<"***************:"<<dyLayerName;
    if(pMap->m_DynamicLayers.GetDynamicLayer(dyLayerName)==NULL)
    {
        pDyLayer = new UGDynamicLayer();
        pDyLayer->SetLayerName(dyLayerName);
        pMap->m_DynamicLayers.Add(pDyLayer);
    }
    else
    {
        pDyLayer = pMap->m_DynamicLayers.GetDynamicLayer(dyLayerName);
        pDyLayer->RemoveAll();
    }
}

//创建二维显示图层
void DisplayRouteDialog::createDisplayLayer(UGMap *pMap, UGDatasetPtr dt, QString routeType)
{
    UGString layerName = Translator::QStr2UGStr(("RouteLayer" + routeType));
    if(!pMap->m_Layers.IsLayerExisted(layerName))
        pMap->m_Layers.AddDataset(dt,true,UGLayer::UG_Layer_Normal,layerName);
}

//添加三维对象到显示数据集
UGString DisplayRouteDialog::addGeometry3DToDisplayDataset(UGRecordsetPtr sourceRes,int routeType)
{
//    UGVariant var;
//    sourceRes->MoveFirst();
//    sourceRes->GetFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteType),var);
//    int routeType =var.ToInt();

    QString displayDtName = "ShowRoute3D_" + QString::number(routeType);//显示数据集名称
    UGDataSource* ds = pSceneControl->getUGWorkspace()->GetDataSource(routeGVar.workspaceDataName.DatasourceName);
    if(ds->GetDataset(Translator::QStr2UGStr(displayDtName))==NULL)
    {//为每种航线类型创建用于显示的临时数据集，仅用于显示
        MapDataManeger dataMag;
        UGDatasetVectorPtr dvp = dataMag.createVectorSet(ds,UGDataset::LineZ,Translator::QStr2UGStr(displayDtName));
        dvp->Open();
        UGFieldInfos fieldInfos;
        sourceRes->GetFieldInfos(fieldInfos);
        dvp->CreateFields(fieldInfos);
    }
    //添加到显示数据集
    UGDatasetVector* dv = (UGDatasetVector*)ds->GetDataset(Translator::QStr2UGStr(displayDtName)).get();
    dv->Open();
    UGQueryDef queryDef;
    UGRecordsetPtr displayRes = dv->Query(queryDef);
    if(displayRes->GetRecordCount()>0)
    {//先清除已有几何对象。
        displayRes->DeleteAll();
        displayRes->Update();
    }
    if(sourceRes->GetRecordCount()>0)
    {
        displayRes->Edit();
        UGFeature* ft = NULL;
        while(!sourceRes->IsEOF())
        {
            ft = sourceRes->GetFeature();
            displayRes->AddFeature(ft);
            sourceRes->MoveNext();
        }
        displayRes->Update();
        ft = NULL;
    }
    dv = NULL;
    ds = NULL;

    return Translator::QStr2UGStr(displayDtName);
}

void DisplayRouteDialog::addGeometryToTrackingLayer3D(UGRecordsetPtr res, UGTrackingLayer3D *pTrackingLayer3D)
{
    res->MoveFirst();
    UGGeometry* geometry = NULL;
    UGGeoLine3D* line3D = NULL;
    UGVariant var;
    QString tag;
    QList<QString> tagList;
    res->GetFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteType),var);
    int type = var.ToInt();
    UGStyle style = routeGVar.getRouteStyle(type);
    style.SetAltitudeMode(AltitudeMode::Absolute);
    while(!res->IsEOF())
    {
        res->GetFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteNumber),var);
        res->GetGeometry(geometry);
        line3D = (UGGeoLine3D*) geometry;
        line3D->SetStyle3D(&style);
        tag = QString::number(type) + "_" + QString::number(var.ToInt());
        qDebug()<<"*****************lineTag:"<< tag;
        pTrackingLayer3D->Add(line3D,Translator::QStr2UGStr(tag));
        tagList.append(tag);
        res->MoveNext();
    }
    routeTags.insert(type,tagList);

    geometry = NULL;
    line3D = NULL;
}

// 移除指定类型航线
void DisplayRouteDialog::removeGeometry(int type,UGTrackingLayer3D *pTrackingLayer3D)
{
    QList<QString> tagList = routeTags[type];
    foreach (QString tag, tagList)
    {
        pTrackingLayer3D->Remove(Translator::QStr2UGStr(tag));
    }
}

void DisplayRouteDialog::on_RouteTypeCbbox_currentIndexChanged(int index)
{
    routeType = QString::number(RouteType.key(ui->RouteTypeCbbox->currentText()));

    QString queryFilter = "RouteType=" + routeType;
    GeoFeatureOperator gftOpt;
    UGRecordsetPtr res2 = gftOpt.queryFeature(dtv,Translator::QStr2UGStr(queryFilter));
    //更新航线编号选项
    addRouteNumberItem(res2);

//    routeNumber = ui->RouteNumberCbbox->currentText();
}


void DisplayRouteDialog::on_displayBtn_clicked()
{
    if(ui->RouteNumberCbbox->currentText().isEmpty())
    {
        QString str = "请选择要显示的航线编号！";
        MessageTips *mMessageTips = new MessageTips(str,this);
        mMessageTips->show();
//        mMessageTips = NULL;
//        this->reject();
//        int type = RouteType.key(ui->RouteTypeCbbox->currentText());
//        pSceneControl->removeLayer3D(Translator::QStr2UGStr("RouteLayer3D"+QString::number(type)));

        return;
    }
    if(is3DMap)
    {
        showRoute3D();
    }
    else
    {
        showRoute();
    }

    this->accept();
}


void DisplayRouteDialog::on_cancelBtn_clicked()
{
    this->close();
}