map-display/geofeatureoperator.cpp

#include "geofeatureoperator.h"
#include "Engine/UGDataSource.h"
#include "Geometry/UGGeoLine.h"
#include "Geometry3D/UGGeoPoint3D.h"
#include "Map/UGMap.h"
#include "MapEditor/UGMapEditorWnd.h"
#include "qdebug.h"
#include "qvector3d.h"
#include "routeglobalvariant.h"
#include "translator.h"
#include "layeroperator.h"
#include "mapdatamaneger.h"
#include <QMessageBox>
#include "Geometry3D/UGGeoLine3D.h"


GeoFeatureOperator::GeoFeatureOperator()
{

}


// 查询要素
UGRecordsetPtr GeoFeatureOperator::queryFeature(UGDatasetVector *dv, UGString filter)
{
    UGQueryDef queryDef;
    queryDef.m_nOptions = UGQueryDef::Both; //查询选项：几何对象(Geometry)和属性(Attribute)都查询
    queryDef.m_nType = UGQueryDef::General; //查询类型：一般的数下条件查询
    queryDef.m_nMode = UGQueryDef::GeneralQuery; //查询模式：一般查询(非模糊查询)
    queryDef.m_nCursorType = UGQueryDef::OpenStatic;  //OpenStatic,用于读取数据；OpenDynamic,用于数据增删改
    queryDef.m_strFilter = filter;  //查询条件
    return dv->Query(queryDef);
}

//空间查询
UGRecordsetPtr GeoFeatureOperator::queryFeature(UGDatasetVector *dv, UGRect2D bounds)
{
    //对矩形进行规范化
    bounds.Normalize();
    //查询条件设置
    UGQueryDef queryDef;
    //查询类型为地理矩形范围
    queryDef.m_nType = UGQueryDef::Bounds;
    //查询模式为一般查询
    queryDef.m_nMode = UGQueryDef::GeneralQuery;
    //查询几何和属性
    queryDef.m_nOptions = UGQueryDef::Both;
    //查询范围
    queryDef.m_rc2Bounds = bounds;
    //设置游标类型为动态游标
    queryDef.m_nCursorType = UGQueryDef::OpenDynamic;

    return dv->Query(queryDef);
}

//高亮几何对象
void GeoFeatureOperator::highLightGeometry(UGGeometry *pGeometry)
{
    UGStyle sty;
    RouteGlobalVariant routeGVar;
    routeGVar.getHighLightStyle(sty);
    pGeometry->SetStyle(&sty);
}

//导入二维航线信息
int GeoFeatureOperator::importFeatureAttribute(UGDatasetVector *dv, UGGeometry* pGeometry, QMap<QString,QString> fieldsValue,bool isAddGeometry)
{
    RouteGlobalVariant routeGVar;
    QMap<int,QString> typetext = routeGVar.getRouteType();

    /*
    UGArray<UGString> aryFields;
    aryFields.Add(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteID));
    aryFields.Add(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteNumber));
    aryFields.Add(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteType));
    aryFields.Add(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteHeight));
    aryFields.Add(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteName));
    aryFields.Add(Translator::QStr2UGStr(routeGVar.routeFieldsName.IsClosedRoute));
    */

    //提取属性字段值
    int routeID = fieldsValue[routeGVar.routeFieldsName.RouteID].toInt();
    int  routeType = fieldsValue[routeGVar.routeFieldsName.RouteType].toInt();
    int routeNumber = fieldsValue[routeGVar.routeFieldsName.RouteNumber].toInt();
    int isClosedRoute = fieldsValue[routeGVar.routeFieldsName.IsClosedRoute].toInt();
    UGString routeName  = Translator::QStr2UGStr(typetext[routeType]+QString::number(routeNumber));

    double routeHeight = fieldsValue[routeGVar.routeFieldsName.RouteHeight].toDouble();
//    UGArray<UGVariant*> aryValues;

    //查询航线是否已存在
    QString queryFilter = routeGVar.routeFieldsName.RouteType + "=" + QString::number(routeType) + " and " +
                           routeGVar.routeFieldsName.RouteNumber + "=" + QString::number(routeNumber);
    UGRecordsetPtr saveRes = queryFeature(dv,Translator::QStr2UGStr(queryFilter));

    UGGeoLine l;
    UGGeoLine3D* l3D = NULL;
    bool is3D = false;
    if(pGeometry->GetType()==UGGeometry::GeoLine)
    {
        pGeometry->ConvertToLine(l,0);
    }
    else if(pGeometry->GetType()==UGGeometry::GeoLine3D)
    {
        is3D = true;
        l3D = (UGGeoLine3D*) pGeometry;
    }

    if(isClosedRoute)
    {//自动闭合线段
        if(pGeometry->GetType()==UGGeometry::GeoLine)
        {
            if(l.GetStartNode() != l.GetEndNode())
            {
                UGPoint2D addPoint = l.GetStartNode();
                l.InsertPoint(0,l.GetPointCount(),addPoint); //添加首节点
            }
        }
        else if(pGeometry->GetType()==UGGeometry::GeoLine3D)
        {
            if(l3D->GetStartNode() != l3D->GetEndNode())
            {
                UGPoint3D addPoint = l3D->GetStartNode();
                l3D->InsertPoint(0,l3D->GetPointCount(),addPoint); //添加首节点
            }
        }
    }

    if(!saveRes->IsEmpty())
    {//记录已存在，覆盖
        //航线覆盖提示框
        QMessageBox msgBox;
        msgBox.setWindowTitle("警告");
        msgBox.setText("航线已存在! ");
        msgBox.setInformativeText("是否覆盖?");
        msgBox.setStandardButtons(QMessageBox::Yes|QMessageBox::No);
        msgBox.setDefaultButton(QMessageBox::Yes);
        msgBox.setIcon(QMessageBox::Warning);
        int ret = msgBox.exec();

        //覆盖已有航线
        if (ret == QMessageBox::Yes)
        {
            saveRes->Edit();
            if(is3D)
                saveRes->SetGeometry(*l3D);
            else
            {
                saveRes->SetGeometry(l);
                saveRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteHeight),UGVariant(routeHeight));
            }
            saveRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.IsClosedRoute),UGVariant(isClosedRoute));
            saveRes->Update();

            return 1;
        }
        else
        {
            return 0;
        }
    }
    else
    {//航线不存在，新增航线
        UGRecordsetPtr allRes = queryFeature(dv);
        if(allRes==NULL) return 0;
//        int routeID = allRes->GetRecordCount()+1;

        //添加航线
        if(isAddGeometry)
        {
            int ss;
            if(is3D)
                ss = allRes->AddNew(l3D);
            else
                ss = allRes->AddNew(&l);
            if(ss<0) return 0;
        }

        //添加航线信息
        allRes->MoveLast();
        allRes->Edit();
        if(isClosedRoute && !isAddGeometry)
        {
            if(is3D)
                allRes->SetGeometry(*l3D);
            else
                allRes->SetGeometry(l);
        }
//        UGVariant v;
//        allRes->GetFieldValue(_U("RouteID"),v);
//        qDebug()<<"**********************2:"<<v.ToInt();
        allRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteID),UGVariant(routeID));
        allRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteNumber),UGVariant(routeNumber));
        allRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteType),UGVariant(routeType));
        allRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteName),UGVariant(routeName));
        allRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.IsClosedRoute),UGVariant(isClosedRoute));
        if(!is3D)
            allRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteHeight),UGVariant(routeHeight));
        //提交记录修改
        allRes->Update();

        return 2;
    }

}

/*@获取几何对象所有节点坐标
 *@points 使用三维坐标存储航点
 *@altitude 用于兼容二维点，默认为0
 */
void GeoFeatureOperator::getNodePoints(UGGeometry* pGeometry, QVector<QVector3D>&points,double altitude)
{
    QVector3D point;
    int type = pGeometry->GetType();
    switch (type) {
    case UGGeometry::GeoLine:
    {
        UGGeoLine* line = (UGGeoLine*)pGeometry;
        const UGPoint2D* p = line->GetPoints(); //节点指针
        int nodeNum = line->GetPointCount(); //节点数
        if (line->GetStartNode() == line->GetEndNode())
        {//闭合航线，减去末尾重合航点
            nodeNum--;
        }
        for(int i = 0;i<nodeNum;i++) //遍历一个要素所有节点
        {
            point.setX(p->x);
            point.setY(p->y);
            point.setZ(altitude);
            points.append(point);
            p++;
        }
        line = NULL;
        p = NULL;
        break;
    }
    case UGGeometry::GeoRegion:
    {
        UGGeoRegion* polygon = (UGGeoRegion*)pGeometry;
        const UGPoint2D* p = polygon->GetPoints(); //节点指针
        int nodeNum = polygon->GetPointCount()-1; //节点数
        for(int i = 0;i<nodeNum;i++)
        {
            point.setX(p->x);
            point.setY(p->y);
            point.setZ(altitude);
            points.append(point);
            p++;
        }
        polygon = NULL;
        p = NULL;
        break;
    }
    case UGGeometry::GeoLine3D:
    {
        UGGeoLine3D* line3D = (UGGeoLine3D*)pGeometry;
        const UGPoint3D* p = line3D->GetPoints(); //节点指针
        int nodeNum = line3D->GetPointCount(); //节点数
        if (line3D->GetStartNode() == line3D->GetEndNode())
        {//闭合航线，减去末尾重合航点
            nodeNum--;
        }
        for(int i = 0;i<nodeNum;i++)
        {
            point.setX(p->x);
            point.setY(p->y);
            point.setZ(p->z);
            points.append(point);
            p++;
        }

        line3D = NULL;
        p = NULL;
        break;
    }
    }
}

//获取几何对象所有节点坐标(废弃)
/*
void GeoFeatureOperator::getNodePoints(UGRecordsetPtr res, UGint geometryType, QVector<QPointF> &points)
{
    res->MoveFirst(); //确保记录集指针是链表表头
    UGGeometry* pTempGeomtry = NULL;
    UGGeoLine line;
    UGGeoRegion polygon;
    QPointF point;
    const UGPoint2D* p = NULL;

    switch (geometryType) {
    case UGGeometry::GeoLine:
    {
        while(!res->IsEOF()) //遍历所有几何对象
        {
            res->GetGeometry(pTempGeomtry,0);
            pTempGeomtry->ConvertToRegion(polygon);
            p = polygon.GetPoints(); //节点指针
            for(int i = 0;i<polygon.GetPointCount();i++) //遍历一个要素所有节点
            {
                point.setX(p->x);
                point.setY(p->y);
                points.append(point);
                p++;
            }
            res->MoveNext();
        }
        break;
    }
    case UGGeometry::GeoRegion:
    {
        while(!res->IsEOF())
        {
            res->GetGeometry(pTempGeomtry,0);
            pTempGeomtry->ConvertToLine(line);
            p = line.GetPoints(); //节点指针
            for(int i = 0;i<line.GetPointCount();i++)
            {
                point.setX(p->x);
                point.setY(p->y);
                points.append(point);
                p++;
            }
        }
        break;
    }
    }
}
*/

//线要素绘制
void GeoFeatureOperator::drawLine(QMapControl *qMapControl, UGDataSource *pDataSource, UGString datasetName)
{
    UGMap* pMap = qMapControl->GetMap();
    UGLayer* lineLayer = NULL;
    UGString layerName = datasetName + _U("@") + pDataSource->GetAlias();  //图层名命名为：数据集名@数据源名
    if(!pMap->m_Layers.IsLayerExisted(layerName))
    {//图层不存在则新建图层
        //获取线数据集
        UGDatasetPtr lineSet = pDataSource->GetDataset(datasetName);
        lineSet->SetPrjCoordSys(UGPrjCoordSys(4326));//设置坐标系为WGS1984

        //将线数据集添加到地图
        lineLayer = pMap->m_Layers.AddDataset(lineSet,true, UGLayer::UG_Layer_Normal,layerName);
    }
    else
    {
        lineLayer = pMap->m_Layers.GetLayer(layerName);
    };

    LayerOperator layerOpt;
    layerOpt.setVectorLayerStyle(lineLayer,UGDataset::Line); //设置图层Style

    if (lineLayer != NULL)
    {
        lineLayer->SetSelectable(true); //设置图层可选择
        pMap->m_Layers.SetEditableLayer(lineLayer,true);//设置图层可编辑

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

    pMap = NULL;
    lineLayer = NULL;
}

//3D线要素绘制(废弃)
void GeoFeatureOperator::drawLine3D(SceneView* pSceneView, UGString datasourceName, UGString datasetName)
{
    SceneControl* pSceneControl = pSceneView->GetSceneControl();

    UGLayer3Ds* pLayer3Ds = pSceneControl->GetUGLayer3Ds();
    UGString layer3DName = datasetName + _U("@") + datasourceName;  //图层名命名为：数据集名@数据源名
//    qDebug()<<"***************:"<<Translator::UGStr2QStr(layer3DName);
    UGLayer3D* lineLayer3D = NULL;
    if(pLayer3Ds->FindNameInner(layer3DName)>=0)
    {//获取图层
        lineLayer3D = pLayer3Ds->GetLayerInner(layer3DName);
    }
    else
    {//图层不存在则新建
        lineLayer3D = pSceneControl->AddLayerFromDataset(datasourceName,datasetName);
    }

    if(lineLayer3D!=NULL)
    {
        //显示对话框
//        emit pSceneView->showSettingFlightPointDialg();

        lineLayer3D->SetSelectable(true);
        pLayer3Ds->SetEditableLayer(lineLayer3D,true); //设置图层可编辑
//        lineLayer3D->SetEditable(true);
//        pSceneControl->GetSceneEditWnd()->SetUserAction(UGSceneUserAction::suaEdit,UGEditType3D::ET3D_PolyLine); //
        pSceneControl->GetSceneEditWnd()->SetUserAction(UGSceneUserAction::suaCreatePolyline);
        pSceneView->isEditStateFlag = true;
        qDebug()<<"*************************EditCursorShape:"<<pSceneControl->GetSceneEditWnd()->Get3DCursorShape();
//        qDebug()<<"*************************:"<<pSceneControl->GetSceneEditWnd()->m_SceneWindow.Get3DCursorShape();
//        qDebug()<<"*************************Edit:"<<pSceneControl->GetSceneEditWnd()->GetSubAction();
//        qDebug()<<"*************************CursorShape:"<<pSceneControl->GetSceneEditWnd()->Get3DCursorShape();

    }

    pLayer3Ds = NULL;
    lineLayer3D = NULL;
    pSceneControl = NULL;

}
//3D线要素绘制
void GeoFeatureOperator::drawLine3D(SceneView *pSceneView, UGString dataName)
{
    SceneControl* pSceneControl = pSceneView->GetSceneControl();
    UGLayer3Ds* pLayer3Ds = pSceneControl->GetUGLayer3Ds();
    /*
    //创建临时数据集
    UGString datasetName = _U("Line3DTmp");
    UGString layer3DName = datasetName + _U("@") + ds->GetAlias();  //图层名命名为：数据集名@数据源名
    MapDataManeger mapDataMag;
    UGDatasetVector* dv = NULL;
    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;
        UGRecordsetPtr res = dv->Query(query);
        qDebug()<<"***************RecordCount:"<<res->GetRecordCount();
        res->DeleteAll();
        res->Update();
    }
    */

    UGLayer3D* lineLayer3D = NULL;
    int layerIndex = pLayer3Ds->FindNameInner(dataName);
    if(layerIndex>=0)
    {//图层存在则删除
        pLayer3Ds->TreeRemoveAt(layerIndex);
    }
    //添加图层
    lineLayer3D = pLayer3Ds->AddLayer(dataName);
//    lineLayer3D = pSceneControl->AddLayerFromDataset(ds->GetAlias(),datasetName);
    lineLayer3D->SetSelectable(true);
    pLayer3Ds->SetEditableLayer(lineLayer3D,true); //设置图层可编辑
//    qDebug()<<"*******************LayerEditable:"<<lineLayer3D->GetEditable();

//        pSceneControl->GetSceneEditWnd()->SetUserAction(UGSceneUserAction::suaEdit,UGEditType3D::ET3D_PolyLine); //
    pSceneControl->GetSceneEditWnd()->SetUserAction(UGSceneUserAction::suaCreatePolyline);
    pSceneView->isEditStateFlag = true;

    //显示对话框
    emit pSceneView->showSettingFlightPointDialg();

//    qDebug()<<"*******************Cursor:"<<pSceneControl->GetSceneEditWnd()->Get3DCursorShape();
//    qDebug()<<"*******************Cursor:"<<pSceneControl->GetSceneEditWnd()->m_SceneWindow.m_n3DCursorShape;

//    dv = NULL;
    lineLayer3D = NULL;
    pSceneControl = NULL;
    pLayer3Ds = NULL;
}

//添加三维航点注记
void GeoFeatureOperator::addNodeLabel3D(UGRecordsetPtr res, UGTrackingLayer3D *pTrackingLayer3D)
{
//    QMap<int, QVector3D> points;
//    getNodePoints(res,points);
    UGGeometry* pGeometry = NULL;
    UGGeoLine3D* line3D = NULL;
    UGPoint3D point;
    UGString nodeTag;
    UGVariant v;
    res->MoveFirst();
    while(!res->IsEOF())
    {
        res->GetGeometry(pGeometry);
        res->GetFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteType),v);
        int type = v.ToInt();
        res->GetFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteNumber),v);
        UGString number = v.ToString();

        line3D = (UGGeoLine3D*)pGeometry;
        int nodeCount = line3D->GetPointCount();
        const UGPoint3D* points3D = line3D->GetPoints();
        if(line3D->GetStartNode()==line3D->GetEndNode())
            nodeCount--;
        UGGeoText3D* geoText3D = new UGGeoText3D();
        UGStyle3D style;
        style.SetAltitudeMode(AltitudeMode::Absolute);
        geoText3D->SetStyle3D(&style);
        UGTextStyle textStyle = routeGVar.getLabelTextStyle(type);
        geoText3D->SetTextStyle(textStyle);
        for(int i = 0;i<nodeCount;i++)
        {
            nodeTag = number + _U("-") + Translator::QStr2UGStr(QString::number(i+1));
            point.x = points3D->x;
            point.y = points3D->y;
            point.z = points3D->z;
            geoText3D->AddSub(nodeTag,point);
            points3D++;
        }

        UGString geoTextTag = Translator::QStr2UGStr(QString::number(type)) + _U("_") + number;
        if(pTrackingLayer3D->Find(geoTextTag)>=0) pTrackingLayer3D->Remove(geoTextTag);
        pTrackingLayer3D->Add(geoText3D,geoTextTag);

        res->MoveNext();
        geoText3D = NULL;
    }
    pGeometry = NULL;
    line3D = NULL;
}

//移除三维航线注记
void GeoFeatureOperator::removeNodeLabel3D(UGRecordsetPtr res,UGTrackingLayer3D* pTrackingLayer3D)
{
    res->MoveFirst();
    UGVariant type;
    UGVariant number;
    UGString geoTextTag;
    while(!res->IsEOF())
    {
        res->GetFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteType),type);
        res->GetFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteNumber),number);
        geoTextTag = type.ToString() + _U("_") + number.ToString();
        if(pTrackingLayer3D->Find(geoTextTag)>=0)
            pTrackingLayer3D->Remove(geoTextTag);

        res->MoveNext();
    }
}

//添加三维几何对象到记录集
void GeoFeatureOperator::addGeometry3DToDataset(UGDatasetVector *dv, UGGeometry *pGeometry)
{
    if(!dv->Open()) dv->Open();
    UGGeoLine3D* line3D = (UGGeoLine3D*)pGeometry;
    if(dv!=NULL)
    {
        UGRecordsetPtr res = queryFeature(dv);
        if(res!=NULL)
        {
            int ss = res->AddNew(line3D);
            res->Update();
        }
        line3D = NULL;
    }
}

//导入三维航线信息
int GeoFeatureOperator::importGeometry3DAttribute(UGDatasetVector *dv, UGGeometry *pGeometry, QMap<QString, QString> fieldsValue)
{
    RouteGlobalVariant routeGVar;
    QMap<int,QString> typetext = routeGVar.getRouteType();

    //提取属性字段值
    int routeID = fieldsValue[routeGVar.routeFieldsName.RouteID].toInt();
    int  routeType = fieldsValue[routeGVar.routeFieldsName.RouteType].toInt();
    int routeNumber = fieldsValue[routeGVar.routeFieldsName.RouteNumber].toInt();
    int isClosedRoute = fieldsValue[routeGVar.routeFieldsName.IsClosedRoute].toInt();
    UGString routeName  = Translator::QStr2UGStr(typetext[routeType]+QString::number(routeNumber));
//    double routeHeight = fieldsValue[routeGVar.routeFieldsName.RouteHeight].toDouble();
//    UGArray<UGVariant*> aryValues;

    //查询航线是否已存在
    QString queryFilter = routeGVar.routeFieldsName.RouteType + "=" + QString::number(routeType) + " and " +
                           routeGVar.routeFieldsName.RouteNumber + "=" + QString::number(routeNumber);
    UGRecordsetPtr saveRes = queryFeature(dv,Translator::QStr2UGStr(queryFilter));

    UGGeoLine3D* line3D = (UGGeoLine3D*)pGeometry;
    if(isClosedRoute)
    {//自动闭合线段
        if(line3D->GetStartNode() != line3D->GetEndNode())
        {
            UGPoint3D addPoint = line3D->GetStartNode();
            line3D->InsertPoint(0,line3D->GetPointCount(),addPoint); //添加首节点
        }
    }

    if(!saveRes->IsEmpty())
    {//记录已存在，覆盖
        //航线覆盖提示框
        QMessageBox msgBox;
        msgBox.setWindowTitle("警告");
        msgBox.setText("航线已存在! ");
        msgBox.setInformativeText("是否覆盖?");
        msgBox.setStandardButtons(QMessageBox::Yes|QMessageBox::No);
        msgBox.setDefaultButton(QMessageBox::Yes);
        msgBox.setIcon(QMessageBox::Warning);
        int ret = msgBox.exec();

        //覆盖已有航线
        if (ret == QMessageBox::Yes)
        {
            saveRes->Edit();
            saveRes->SetGeometry(*line3D);
//            saveRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteHeight),UGVariant(routeHeight));
            saveRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.IsClosedRoute),UGVariant(isClosedRoute));
            saveRes->Update();

            return 1;
        }
        else
        {
            return 0;
        }
    }
    else
    {//航线不存在，新增航线
        UGRecordsetPtr allRes = queryFeature(dv);
        if(allRes==NULL) return 0;
//        int routeID = allRes->GetRecordCount()+1;

        //添加航线
        int ss = allRes->AddNew(line3D);
        if(ss<0) return 0;

        //添加航线信息
        allRes->MoveLast();
        allRes->Edit();
//        UGVariant v;
//        allRes->GetFieldValue(_U("RouteID"),v);
//        qDebug()<<"**********************2:"<<v.ToInt();
        allRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteID),UGVariant(routeID));
        allRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteNumber),UGVariant(routeNumber));
        allRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteType),UGVariant(routeType));
//        allRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteHeight),UGVariant(routeHeight));
        allRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.RouteName),UGVariant(routeName));
        allRes->ModifyFieldValue(Translator::QStr2UGStr(routeGVar.routeFieldsName.IsClosedRoute),UGVariant(isClosedRoute));
        //提交记录修改
        allRes->Update();

        return 2;
    }
}

//创建三维地标对象
UGGeoPlacemark *GeoFeatureOperator::createGeoPlacemark(QVector3D point, QString strName)
{
    UGGeoPlacemark* geoPlacemark = new UGGeoPlacemark();
    UGGeoPoint3D* point3D = new UGGeoPoint3D();
    geoPlacemark->SetGeometry(point3D);
    geoPlacemark->SetPosition(UGPoint3D(point.x(),point.y(),point.z()));
    geoPlacemark->SetName(Translator::QStr2UGStr(strName));

    return geoPlacemark;
}