change tool_siasun.

src/tool/tool_siasun/mainwindow.cpp

@@ -8,6 +8,8 @@
 #include "google/protobuf/io/zero_copy_stream_impl.h"
 #include "google/protobuf/text_format.h"
 
+#include <QFileDialog>
+
 
 
 #define VIEW_WIDTH 6000
@@ -39,6 +41,10 @@ MainWindow::MainWindow(QWidget *parent) :
     mpdkp = new DialogKickPoint(&msissunmap, this);
 
     connect(mmyview,SIGNAL(dbclickxy(double,double)),this,SLOT(ondbclick(double,double)));
+
+    ui->actionSelect_None->setChecked(true);
+    ui->actionSelect_Kick->setChecked(false);
+    ui->actionSelect_Point->setChecked(false);
 }
 
 MainWindow::~MainWindow()
@@ -102,9 +108,12 @@ void MainWindow::on_actionInsert_Kick_Point_triggered()
 
 void MainWindow::on_actionSave_triggered()
 {
+ //   QString strfilepath = "/home/yuchuli/testsia.txt";
 
+    QString str = QFileDialog::getSaveFileName(this,tr("Save Data"),".","*.txt");
+    if(str.isEmpty())return;
+    QString strfilepath = str;
 
-    QString strfilepath = "/home/yuchuli/testsia.txt";
     using google::protobuf::TextFormat;
     using google::protobuf::io::FileOutputStream;
     using google::protobuf::io::ZeroCopyOutputStream;
@@ -130,7 +139,11 @@ void MainWindow::on_actionSave_triggered()
 
 void MainWindow::on_actionLoad_triggered()
 {
-    QString strfilepath = "/home/yuchuli/testsia.txt";
+//    QString strfilepath = "/home/yuchuli/testsia.txt";
+
+    QString str = QFileDialog::getOpenFileName(this,tr("Load Data"),".","*.txt");
+    if(str.isEmpty())return;
+    QString strfilepath = str;
 
     QFile xFile;
     xFile.setFileName(strfilepath);
@@ -172,11 +185,40 @@ void MainWindow::on_actionLoad_triggered()
     }
 
     iv::siasun::kickpointarray * pkickarray = msissunmap.mutable_mkickarray();
+    iv::siasun::waypointarray * pwayarray = msissunmap.mutable_mwayarray();
 
     int i;
     mlon0 = pkickarray->mutable_mkick(0)->mflon();
     mlat0 = pkickarray->mutable_mkick(0)->mflat();
 
+    if(mpSelectMapPointItem != NULL)
+    {
+        mpscene->removeItem(mpSelectMapPointItem);
+        delete mpSelectMapPointItem;
+        mpSelectMapPointItem = NULL;
+    }
+
+    if(mpSelectPointItem != NULL)
+    {
+        mpscene->removeItem(mpSelectPointItem);
+        delete mpSelectPointItem;
+        mpSelectPointItem = NULL;
+    }
+
+    for(i=0;i<(int)mvectorPickPointItem.size();i++)
+    {
+        mpscene->removeItem(mvectorPickPointItem[i]);
+        delete mvectorPickPointItem[i];
+    }
+    mvectorPickPointItem.clear();
+
+    for(i=0;i<(int)mvectorMapPointItem.size();i++)
+    {
+        mpscene->removeItem(mvectorMapPointItem[i]);
+        delete mvectorMapPointItem[i];
+    }
+    mvectorMapPointItem.clear();
+
     for(i=0;i<pkickarray->mkick_size();i++)
     {
         iv::siasun::kickpoint * ppoint = pkickarray->mutable_mkick(i);
@@ -199,6 +241,29 @@ void MainWindow::on_actionLoad_triggered()
         mvectorPickPointItem.push_back(pmainitem);
     }
 
+    if(pwayarray == NULL)return;
+
+    for(i=0;i<pwayarray->mwaypoint_size();i++)
+    {
+        iv::siasun::waypoint * ppoint = pwayarray->mutable_mwaypoint(i);
+        double x0,y0;
+        double x,y;
+        GaussProjCal(ppoint->mflon(),ppoint->mflat(),&x,&y);
+        GaussProjCal(mlon0,mlat0,&x0,&y0);
+        x = x - x0;
+        y = y - y0;
+
+        double ratio = mmyview->getbeishu();
+        double fscale = 1.0/ratio;
+        QGraphicsEllipseItem * pmainitem;
+        pmainitem = new QGraphicsEllipseItem(0-mfPointSize/2.0,0*(-1)-mfPointSize/2.0,mfPointSize,mfPointSize);
+        pmainitem->setBrush(Qt::green);
+        pmainitem->setPen(Qt::NoPen);
+        pmainitem->setPos(VIEW_WIDTH/2 + x,VIEW_HEIGHT/2 -y);
+        pmainitem->setScale(fscale);
+        mpscene->addItem(pmainitem);
+        mvectorMapPointItem.push_back(pmainitem);
+    }
 
 }
 
@@ -255,7 +320,7 @@ void MainWindow::ondbclick(double x,double y)
         pmainitem->setScale(fscale);
 
         mpscene->addItem(pmainitem);
-        mvectorPickPointItem.push_back(pmainitem);
+        mvectorMapPointItem.push_back(pmainitem);
     }
     else
     {
@@ -314,6 +379,63 @@ void MainWindow::ondbclick(double x,double y)
                 }
             }
         }
+
+        if(mnSelectMode == 2)
+        {
+            double fx,fy;
+            fx = x - VIEW_WIDTH/2;
+            fy = VIEW_HEIGHT/2 - y;
+            double x0,y0;
+            GaussProjCal(mlon0,mlat0,&x0,&y0);
+            double flonx,flaty;
+            flonx = fx + x0;
+            flaty = fy + y0;
+            double fdismin = 1000000.0;
+            int index = -1;
+            int i;
+            double xv,yv;
+            iv::siasun::waypointarray * parray = msissunmap.mutable_mwayarray();
+            for(i=0;i<parray->mwaypoint_size();i++)
+            {
+                iv::siasun::waypoint * p = parray->mutable_mwaypoint(i);
+                double p1x,p1y;
+                GaussProjCal(p->mflon(),p->mflat(),&p1x,&p1y);
+                double fdis = sqrt(pow(p1x-flonx,2)+pow(p1y-flaty,2));
+                if(fdis<fdismin)
+                {
+                    fdismin = fdis;
+                    index = i;
+                    xv = p1x;
+                    yv = p1y;
+
+                }
+                std::cout<<" fdis: "<<fdismin<<std::endl;
+            }
+            if(fdismin < mfNearDisLimit)
+            {
+                mnIndexSelectWayPoint = index;
+                double ratio = mmyview->getbeishu();
+                double fscale = 1.0/ratio;
+                if(mpSelectMapPointItem == NULL)
+                {
+
+                    QGraphicsEllipseItem * pmainitem;
+                    pmainitem = new QGraphicsEllipseItem(0-mfPointSize*2.0/2.0,0*(-1)-mfPointSize*2.0/2.0,mfPointSize*2.0,mfPointSize*2.0);
+                    pmainitem->setBrush(Qt::red);
+                    pmainitem->setPen(Qt::NoPen);
+                    pmainitem->setPos(VIEW_WIDTH/2 + xv-x0,VIEW_HEIGHT/2 -(yv-y0));
+                    pmainitem->setScale(fscale);
+                    mpscene->addItem(pmainitem);
+                    mpSelectMapPointItem = pmainitem;
+                }
+                else
+                {
+                    mpSelectMapPointItem->setPos(VIEW_WIDTH/2 + xv-x0,VIEW_HEIGHT/2 -(yv-y0));
+                    mpSelectMapPointItem->setScale(fscale);
+                }
+            }
+        }
+
     }
 }
 
@@ -365,6 +487,9 @@ void MainWindow::on_actionCreate_Map_triggered()
 void MainWindow::on_actionSelect_None_triggered()
 {
     mnSelectMode = 0;
+    ui->actionSelect_None->setChecked(true);
+    ui->actionSelect_Kick->setChecked(false);
+    ui->actionSelect_Point->setChecked(false);
     if(mpSelectPointItem != NULL)
     {
         mpscene->removeItem(mpSelectPointItem);
@@ -374,10 +499,113 @@ void MainWindow::on_actionSelect_None_triggered()
 
 void MainWindow::on_actionSelect_Kick_triggered()
 {
+    ui->actionSelect_None->setChecked(false);
+    ui->actionSelect_Kick->setChecked(true);
+    ui->actionSelect_Point->setChecked(false);
    mnSelectMode = 1;
+   mbInsertMapPoint = false;
+   ui->actionInsert_Map_Point->setText(tr("Start Insert Map Point"));
 }
 
 void MainWindow::on_actionSelect_Point_triggered()
 {
+    ui->actionSelect_None->setChecked(false);
+    ui->actionSelect_Kick->setChecked(false);
+    ui->actionSelect_Point->setChecked(true);
     mnSelectMode = 2;
+    mbInsertMapPoint = false;
+    ui->actionInsert_Map_Point->setText(tr("Start Insert Map Point"));
+}
+
+void MainWindow::on_actionDelete_Map_Point_triggered()
+{
+    if(mnIndexSelectWayPoint == -1)
+    {
+        return;
+    }
+
+    iv::siasun::waypointarray xarray;
+//    xarray.CopyFrom(msissunmap.mwayarray());
+
+    int i;
+    for(i=0;i<msissunmap.mutable_mwayarray()->mwaypoint_size();i++)
+    {
+        if(i != mnIndexSelectWayPoint)
+        {
+            iv::siasun::waypoint * p = xarray.add_mwaypoint();
+            p->CopyFrom(msissunmap.mutable_mwayarray()->mwaypoint(i));
+        }
+    }
+    msissunmap.mutable_mwayarray()->clear_mwaypoint();
+    msissunmap.mutable_mwayarray()->CopyFrom(xarray);
+
+    mpscene->removeItem(mvectorMapPointItem[(unsigned int)mnIndexSelectWayPoint]);
+
+    mvectorMapPointItem.erase(mvectorMapPointItem.begin()+mnIndexSelectWayPoint);
+
+
+    mnIndexSelectWayPoint = -1;
+    mpscene->removeItem(mpSelectMapPointItem);
+    mpSelectMapPointItem = NULL;
+}
+
+void MainWindow::on_actionDistance_triggered()
+{
+    if(mvectorlinemap.size() == 0 )
+    {
+        QMessageBox::warning(this,tr("Warning"),tr("No Map"),QMessageBox::YesAll);
+        return;
+    }
+
+    if(mvectorPickPointItem.size() == 0)
+    {
+        QMessageBox::warning(this,tr("Warning"),tr("No Kick Point"),QMessageBox::YesAll);
+        return;
+    }
+
+    int nindexkick,nindexline;
+    sissunmap xsis;
+    double fdis = xsis.GetDisTance(mvectorlinemap,&msissunmap,nindexkick,nindexline);
+
+    if(nindexkick != -1)
+    {
+        QString strmsg = tr("Distance from kickpoint 2 line: ")+QString::number(fdis,'f',3);
+        QMessageBox::information(this,tr("Information"),strmsg,QMessageBox::YesAll);
+
+        iv::siasun::kickpoint * p = msissunmap.mutable_mkickarray()->mutable_mkick(nindexkick);
+        double p1x,p1y;
+        GaussProjCal(p->mflon(),p->mflat(),&p1x,&p1y);
+
+        double xv,yv;
+        double x0,y0;
+        GaussProjCal(mlon0,mlat0,&x0,&y0);
+        xv = p1x ;
+        yv = p1y ;
+
+        mnIndexSelectKick = nindexkick;
+        double ratio = mmyview->getbeishu();
+        double fscale = 1.0/ratio;
+        if(mpSelectPointItem == NULL)
+        {
+
+            QGraphicsEllipseItem * pmainitem;
+            pmainitem = new QGraphicsEllipseItem(0-mfPointSize*2.0/2.0,0*(-1)-mfPointSize*2.0/2.0,mfPointSize*2.0,mfPointSize*2.0);
+            pmainitem->setBrush(Qt::red);
+            pmainitem->setPen(Qt::NoPen);
+            pmainitem->setPos(VIEW_WIDTH/2 + xv-x0,VIEW_HEIGHT/2 -(yv-y0));
+            pmainitem->setScale(fscale);
+            mpscene->addItem(pmainitem);
+            mpSelectPointItem = pmainitem;
+        }
+        else
+        {
+            mpSelectPointItem->setPos(VIEW_WIDTH/2 + xv-x0,VIEW_HEIGHT/2 -(yv-y0));
+            mpSelectPointItem->setScale(fscale);
+        }
+    }
+    else
+    {
+        QMessageBox::warning(this,tr("Warning"),tr("Get Distance Fail."),QMessageBox::YesAll);
+    }
+
 }

src/tool/tool_siasun/mainwindow.h

@@ -54,6 +54,10 @@ private slots:
 
      void on_actionSelect_Point_triggered();
 
+     void on_actionDelete_Map_Point_triggered();
+
+     void on_actionDistance_triggered();
+
 private:
     Ui::MainWindow *ui;
 
@@ -72,6 +76,7 @@ private:
     std::vector<QGraphicsEllipseItem * > mvectorMapPointItem;
 
     QGraphicsEllipseItem * mpSelectPointItem = NULL;
+    QGraphicsEllipseItem * mpSelectMapPointItem = NULL;
 
 
 //    QGraphicsEllipseItem * mpNowPosItem;
@@ -89,6 +94,7 @@ private:
     int mnSelectMode = 0;
 
     int mnIndexSelectKick = -1;
+    int mnIndexSelectWayPoint = -1;
 
 };
 

src/tool/tool_siasun/mainwindow.ui

@@ -62,6 +62,7 @@
     <addaction name="actionInsert_Kick_Point"/>
     <addaction name="actionInsert_Map_Point"/>
     <addaction name="actionCreate_Map"/>
+    <addaction name="actionDelete_Map_Point"/>
    </widget>
    <widget class="QMenu" name="menuView">
     <property name="title">
@@ -77,9 +78,16 @@
     </widget>
     <addaction name="menuSelect"/>
    </widget>
+   <widget class="QMenu" name="menuTool">
+    <property name="title">
+     <string>Tool</string>
+    </property>
+    <addaction name="actionDistance"/>
+   </widget>
    <addaction name="menuFile"/>
    <addaction name="menuView"/>
    <addaction name="menuMap"/>
+   <addaction name="menuTool"/>
   </widget>
   <widget class="QToolBar" name="mainToolBar">
    <attribute name="toolBarArea">
@@ -116,20 +124,39 @@
    </property>
   </action>
   <action name="actionSelect_None">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
    <property name="text">
     <string>Select None</string>
    </property>
   </action>
   <action name="actionSelect_Kick">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
    <property name="text">
     <string>Select Kick</string>
    </property>
   </action>
   <action name="actionSelect_Point">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
    <property name="text">
     <string>Select Point</string>
    </property>
   </action>
+  <action name="actionDelete_Map_Point">
+   <property name="text">
+    <string>Delete Map Point</string>
+   </property>
+  </action>
+  <action name="actionDistance">
+   <property name="text">
+    <string>Distance</string>
+   </property>
+  </action>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <resources/>

src/tool/tool_siasun/sissunmap.cpp

@@ -321,3 +321,60 @@ std::vector<iv::mapline> sissunmap::GetMapLine(iv::siasun::map *psiamap)
 
 
 }
+
+double sissunmap::GetDisTance(std::vector<iv::mapline> & xvectormapline,iv::siasun::map * psiamap,int & nindexkick,int & nindexline)
+{
+    double fdismin = 1000000.0;
+    nindexline = -1;
+    nindexkick = -1;
+
+    iv::siasun::kickpointarray * parray = psiamap->mutable_mkickarray();
+
+    int i;
+    for(i=0;i<parray->mkick_size();i++)
+    {
+        double x,y;
+        iv::siasun::kickpoint * p = parray->mutable_mkick(i);
+        GaussProjCal(p->mflon(),p->mflat(),&x,&y);
+        int j;
+        for(j=0;j<(int)xvectormapline.size();j++)
+        {
+
+            double x1,y1;
+            double x2,y2;
+
+            GaussProjCal(xvectormapline[j].mfLon1,xvectormapline[j].mfLat1,&x1,&y1);
+            GaussProjCal(xvectormapline[j].mfLon2,xvectormapline[j].mfLat2,&x2,&y2);
+
+            double spos;
+            int near;
+            bool bright;
+            double fcrossdis = GetPoint2LineCrossDis(QPointF(x,y),QPointF(x1,y1),QPointF(x2,y2),spos,near,bright);
+            double fdis;
+            if(near == 0)
+            {
+                fdis = fcrossdis;
+            }
+            else
+            {
+                if(near == 1)
+                {
+                    fdis = sqrt(pow(x1-x,2)+pow(y1-y,2));
+                }
+                else
+                {
+                    fdis = sqrt(pow(x2-x,2)+pow(y2-y,2));
+                }
+            }
+            if(fdis<fdismin)
+            {
+                nindexkick = i;
+                nindexline = j;
+                fdismin = fdis;
+            }
+        }
+    }
+
+    return fdismin;
+
+}

src/tool/tool_siasun/sissunmap.h

@@ -35,6 +35,8 @@ public:
 
     std::vector<iv::mapline> GetMapLine(iv::siasun::map * psiamap);
 
+    double GetDisTance(std::vector<iv::mapline> & xvectormapline,iv::siasun::map * psiamap,int & nindexkick,int & nindexline);
+
     const double mfDisMin = 0.1; //2 point distance must bigger than 0.1m
 
 private: