decide_gps merge

src/decition/decition_brain_sf_changan_shenlan/decition/adc_tools/compute_00.cpp

@@ -233,7 +233,133 @@ int iv::decition::Compute00::getMapDelta(std::vector<GPSData> MapTrace){
         doubledata[j][3]=delta_sum/20;
     }
 }
+namespace iv {
+namespace decition {
+extern double gplanbrakeacc;
+extern double gplanacc;
+}
+}
+//extern double iv::decition::gplanbrakeacc;
+
+void iv::decition::Compute00::SmoothACC(std::vector<iv::GPSData> & MapTrace,std::vector<std::vector<double>> & vdoubledata)
+{
+    double acca = iv::decition::gplanacc;
+    int nsize = static_cast<int>(vdoubledata.size());
+    int i;
+    for(i=1;i<(nsize-1);i++)
+    {
+        if((vdoubledata[i+1][4] - vdoubledata[i][4])>1.0)
+        {
+            int j;
+            for(j=i;j<(nsize -1);j++)
+            {
+                double fdis = sqrt(pow(MapTrace[j]->gps_x - MapTrace[j+1]->gps_x,2)+pow(MapTrace[j]->gps_y - MapTrace[j+1]->gps_y,2));
+                double vpre = vdoubledata[j][4]/3.6;
+                double fspeed = sqrt((fdis + 0.5*vpre*vpre/acca)*acca/0.5) *3.6;
+                if(fspeed>vdoubledata[j+1][4])
+                {
+                    break;
+                }
+                vdoubledata[j+1][4] = fspeed;
+            }
+            i = j+1;
+        }
+    }
+
+}
+
+
+
+void iv::decition::Compute00::SmoothHighData(std::vector<iv::GPSData> & MapTrace,std::vector<std::vector<double>> & vdoubledata,unsigned int i)
+{
+    if(i==0)return;
+
+//    0.5*v1*v1/a - 0.5*v2*v2/a = dis;
+//    v1*v1 = (dis + 0.5*v2*v2/a)*a/0.5
+
+    int j;
+    double brakea = 3.0*iv::decition::gplanbrakeacc;//iv::decition::gplanbrakeacc;
+    if(brakea>5.0)brakea = 5.0;
+    int startvalue = static_cast<int>(i-1);
+
+    double fdispoint = sqrt(pow(MapTrace[i]->gps_x - MapTrace[i-1]->gps_x,2)+pow(MapTrace[i]->gps_y - MapTrace[i-1]->gps_y,2));
+    if(fdispoint < 0.1)fdispoint = 0.1;
+    int nprebrake = static_cast<int>(10.0/fdispoint);
+    if((MapTrace[i]->roadMode == 14) || (MapTrace[i]->roadMode == 15))
+    {
+        nprebrake = static_cast<int>(5.0/fdispoint);
+    }
+    else
+    {
+        nprebrake = static_cast<int>(3.0/fdispoint);
+    }
+    for(j=startvalue;j>=0;j--)
+    {
+        if(vdoubledata[j][4] < vdoubledata[j+1][4])
+        {
+            break;
+        }
+        if((startvalue - j) < nprebrake)
+        {
+            vdoubledata[j][4] = vdoubledata[j+1][4];
+            continue;
+        }
+        double fdis = sqrt(pow(MapTrace[j]->gps_x - MapTrace[j+1]->gps_x,2)+pow(MapTrace[j]->gps_y - MapTrace[j+1]->gps_y,2));
+        double vpre = vdoubledata[j+1][4]/3.6;
+        double fspeed = sqrt((fdis + 0.5*vpre*vpre/brakea)*brakea/0.5) *3.6;
+        if(fspeed>vdoubledata[j][4])
+        {
+            break;
+        }
+        vdoubledata[j][4] = fspeed;
+    }
+
+}
+
+void iv::decition::Compute00::SmoothData(std::vector<iv::GPSData> & MapTrace,std::vector<std::vector<double>> & vdoubledata,unsigned int i)
+{
+    if(i==0)return;
+
+//    0.5*v1*v1/a - 0.5*v2*v2/a = dis;
+//    v1*v1 = (dis + 0.5*v2*v2/a)*a/0.5
+
+    int j;
+    double brakea = iv::decition::gplanbrakeacc;//iv::decition::gplanbrakeacc;
+    int startvalue = static_cast<int>(i-1);
+
+    double fdispoint = sqrt(pow(MapTrace[i]->gps_x - MapTrace[i-1]->gps_x,2)+pow(MapTrace[i]->gps_y - MapTrace[i-1]->gps_y,2));
+    if(fdispoint < 0.1)fdispoint = 0.1;
+    int nprebrake = static_cast<int>(10.0/fdispoint);
+    if((MapTrace[i]->roadMode == 14) || (MapTrace[i]->roadMode == 15))
+    {
+        nprebrake = static_cast<int>(5.0/fdispoint);
+    }
+    else
+    {
+        nprebrake = static_cast<int>(3.0/fdispoint);
+    }
+    for(j=startvalue;j>=0;j--)
+    {
+        if(vdoubledata[j][4] < vdoubledata[j+1][4])
+        {
+            break;
+        }
+        if((startvalue - j) < nprebrake)
+        {
+            vdoubledata[j][4] = vdoubledata[j+1][4];
+            continue;
+        }
+        double fdis = sqrt(pow(MapTrace[j]->gps_x - MapTrace[j+1]->gps_x,2)+pow(MapTrace[j]->gps_y - MapTrace[j+1]->gps_y,2));
+        double vpre = vdoubledata[j+1][4]/3.6;
+        double fspeed = sqrt((fdis + 0.5*vpre*vpre/brakea)*brakea/0.5) *3.6;
+        if(fspeed>vdoubledata[j][4])
+        {
+            break;
+        }
+        vdoubledata[j][4] = fspeed;
+    }
 
+}
 
 /*int iv::decition::Compute00::getPlanSpeed(std::vector<GPSData> MapTrace)
 {
@@ -358,6 +484,7 @@ int iv::decition::Compute00::getMapDelta(std::vector<GPSData> MapTrace){
 }*/
 int iv::decition::Compute00::getPlanSpeed(std::vector<GPSData> MapTrace)
 {
+    int nSmoothMode = 1;
     int mode0to5count=0,mode0to18count=0,mode0to5countSum=0,mode0to18countSum=0,mode18count=0,mode18countSum=0,mode0to5flash=0,mode18flash=0;
     double straightSpeed=min(ServiceCarStatus.mroadmode_vel.mfmode0,60.0);
     double straightCurveSpeed=min(ServiceCarStatus.mroadmode_vel.mfmode5,40.0);
@@ -366,14 +493,156 @@ int iv::decition::Compute00::getPlanSpeed(std::vector<GPSData> MapTrace)
     getMapDelta(MapTrace);
     for(int i=0;i<doubledata.size();i++)
     {
-        if((MapTrace[i]->mfCurvature>-0.02)&&(MapTrace[i]->mfCurvature<0.02)){
-            MapTrace[i]->roadMode=5;
-        }else if(((MapTrace[i]->mfCurvature>=0.02)&&(MapTrace[i]->mfCurvature<=0.16))||((MapTrace[i]->mfCurvature>=-0.16)&&(MapTrace[i]->mfCurvature<=-0.02))){
-            MapTrace[i]->roadMode=18;
-        }else if(((MapTrace[i]->mfCurvature>0.16))||((MapTrace[i]->mfCurvature<-0.16))){
-            MapTrace[i]->roadMode=14;
+
+        if((MapTrace[i]->roadMode==14)||(MapTrace[i]->roadMode==15))
+        {
+           int  a = 1;
+        }
+        else
+        {
+            if((MapTrace[i]->mfCurvature>-0.02)&&(MapTrace[i]->mfCurvature<0.02)){
+                MapTrace[i]->roadMode=5;
+            }else if(((MapTrace[i]->mfCurvature>=0.02)&&(MapTrace[i]->mfCurvature<=0.16))||((MapTrace[i]->mfCurvature>=-0.16)&&(MapTrace[i]->mfCurvature<=-0.02))){
+                MapTrace[i]->roadMode=18;
+            }else if(((MapTrace[i]->mfCurvature>0.16))||((MapTrace[i]->mfCurvature<-0.16))){
+                MapTrace[i]->roadMode=14;
+            }
         }
     }
+
+    for(int i=1;i<MapTrace.size()-1;i++)
+    {
+         if((MapTrace[i-1]->roadMode==5)&&(MapTrace[i+1]->roadMode==5))
+         {
+          if(MapTrace[i]->roadMode!=5)
+           MapTrace[i]->roadMode=5;
+
+         }
+         else if ((MapTrace[i-1]->roadMode==18)&&(MapTrace[i+1]->roadMode==18))
+         {
+          if(MapTrace[i]->roadMode==5)
+           MapTrace[i]->roadMode=18;
+          if(MapTrace[i]->roadMode==14)
+           MapTrace[i]->roadMode=18;
+         }
+            else if ((MapTrace[i-1]->roadMode==14)&&(MapTrace[i+1]->roadMode==14))
+         {
+          if(MapTrace[i]->roadMode==5)
+           MapTrace[i]->roadMode=14;
+                 if(MapTrace[i]->roadMode==18)
+           MapTrace[i]->roadMode=14;
+         }
+         else
+         {
+
+         }
+    }
+    if(nSmoothMode == 0)
+        {
+
+                    for(int i=0;i<MapTrace.size();i++)
+                    {
+                        if(MapTrace[i]->roadMode==0){
+                            doubledata[i][4]=straightSpeed;
+                            if(MapTrace[i]->speed>0)
+                            {
+         //                       double fSpeed = MapTrace[i]->speed;
+                                doubledata[i][4] = MapTrace[i]->speed*3.6;
+                            }
+                            mode0to5count++;
+                            //mode0to18count++;
+                            mode18count=0;
+                            mode0to5flash=mode0to5count;
+                        }else if(MapTrace[i]->roadMode==5){
+                            doubledata[i][4]=straightCurveSpeed;
+                            if(MapTrace[i]->speed>0)
+                            {
+         //                       double fSpeed = MapTrace[i]->speed;
+                                doubledata[i][4] = MapTrace[i]->speed*3.6;
+                            }
+                            mode0to5count++;
+                            //mode0to18count++;
+                            mode18count=0;
+                            mode0to5flash=mode0to5count;
+                        }else if(MapTrace[i]->roadMode==18){
+                            mode0to5countSum=mode0to5count;
+                            doubledata[i][4]=Curve_SmallSpeed;
+
+                            double brake_distance_double=(pow((straightCurveSpeed/3.6),2)-pow((Curve_SmallSpeed/3.6),2))*5/0.6; //1228
+                            int brake_distance=(int)brake_distance_double;
+                            int step_count=0;
+                            if((i>brake_distance)&&(mode0to5countSum>brake_distance))
+                            {
+                                double step_speed=(straightCurveSpeed-Curve_SmallSpeed)/brake_distance;
+
+                                for(int j=i;j>i-brake_distance;j--){
+                                    doubledata[j][4]=min((Curve_SmallSpeed+step_count*step_speed),straightCurveSpeed);
+
+                                    step_count++;
+                                }
+                            }else if(mode0to5countSum>0){
+                                double step_speed=(straightCurveSpeed-Curve_SmallSpeed)/brake_distance;//1228
+                                for(int j=i;j>=i-mode0to5countSum;j--){
+                                    doubledata[j][4]=Curve_SmallSpeed;//min((Curve_SmallSpeed+step_count*step_speed),straightCurveSpeed);//1228Curve_SmallSpeed;
+                                    step_count++;
+                                }
+                            }else{
+                                doubledata[i][4]=Curve_SmallSpeed;
+                            }
+                            mode0to5count=0;
+                            //mode0to18count++;
+                            mode18count++;
+                            mode18flash=mode18count;
+                        }else if((MapTrace[i]->roadMode==14)||(MapTrace[i]->roadMode==15)){
+                            mode0to18countSum=mode0to5flash+mode18flash;
+                            mode18countSum=mode18count;
+                            double brake_distanceLarge_double=(pow((Curve_SmallSpeed/3.6),2)-pow((Curve_LargeSpeed/3.6),2))*5/0.6; //1228
+                            double brake_distance0to18_double=(pow((straightCurveSpeed/3.6),2)-pow((Curve_LargeSpeed/3.6),2))*5/0.6;
+                            int brake_distanceLarge=(int)brake_distanceLarge_double;
+                            int brake_distance0to18=(int)brake_distance0to18_double;
+                            int step_count=0;
+                            doubledata[i][4]=Curve_LargeSpeed;
+
+                            if(mode18countSum>brake_distanceLarge)
+                            {
+                                    double step_speed=(Curve_SmallSpeed-Curve_LargeSpeed)/brake_distanceLarge;
+
+                                    for(int j=i;j>i-brake_distanceLarge;j--){
+                                        doubledata[j][4]=min((Curve_LargeSpeed+step_count*step_speed),Curve_SmallSpeed);
+                                        step_count++;
+                                    }
+
+                            }else if(mode0to18countSum>brake_distance0to18){
+
+                                    double step_speed=(straightCurveSpeed-Curve_LargeSpeed)/brake_distance0to18;
+
+                                    for(int j=i;j>i-brake_distance0to18;j--){
+                                        if(MapTrace[j]->roadMode==18)//20230106,fangzhi 18moshi de sudu dayu yuzhi
+                                            continue;
+                                        doubledata[j][4]=min((Curve_LargeSpeed+step_count*step_speed),straightCurveSpeed);
+                                        step_count++;
+                                    }
+                            }else if(mode0to18countSum>0){
+                                double step_speed=(straightCurveSpeed-Curve_LargeSpeed)/brake_distance0to18;//1228
+                                for(int j=i;j>=i-mode0to18countSum;j--){
+                                    doubledata[j][4]=Curve_LargeSpeed;//min((Curve_LargeSpeed+step_count*step_speed),straightCurveSpeed);//1228Curve_LargeSpeed;
+                                    step_count++;
+                                }
+                            }else{
+                                    doubledata[i][4]=Curve_LargeSpeed;
+                            }
+
+                            mode0to5count=0;
+                            mode18count=0;
+                            mode0to5flash=0;
+                            mode18flash=0;
+                        }
+                    }
+
+
+        }
+    else
+    {
                 for(int i=0;i<MapTrace.size();i++)
                 {
                     if(MapTrace[i]->roadMode==0){
@@ -457,6 +726,7 @@ int iv::decition::Compute00::getPlanSpeed(std::vector<GPSData> MapTrace)
                         mode18flash=0;
                     }
                 }
+    }
 //
                 /*for(int i=0;i<MapTrace.size();i++){
                     //将数据写入文件开始

src/decition/decition_brain_sf_changan_shenlan/decition/adc_tools/compute_00.h

@@ -37,6 +37,10 @@ namespace iv {
             static int getDesiredSpeed(std::vector<GPSData> gpsMap);
             static int getMapDelta(std::vector<GPSData> MapTrace);
             static int getPlanSpeed(std::vector<GPSData> MapTrace);
+            static void SmoothACC(std::vector<iv::GPSData> & MapTrace,std::vector<std::vector<double>> & vdoubledata);
+            static void SmoothData(std::vector<iv::GPSData> & MapTrace,std::vector<std::vector<double>> & vdoubledata,unsigned int i);
+
+            static void SmoothHighData(std::vector<iv::GPSData> & MapTrace,std::vector<std::vector<double>> & vdoubledata,unsigned int i);
 
 
             static double getDecideAngle(std::vector<Point2D>  gpsTrace, double realSpeed);

src/decition/decition_brain_sf_changan_shenlan/decition/brain.cpp

@@ -28,6 +28,8 @@ extern std::string gstrmembraincarstate;
 namespace iv {
 namespace decition {
         iv::decition::BrainDecition * gbrain;
+        double gplanbrakeacc=0.3;
+        double gplanacc=1.0;
 
         void ListenTraceMap(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
         {

src/decition/decition_brain_sf_changan_shenlan/decition/decide_gps_00.cpp

@@ -28,7 +28,7 @@ extern iv::Ivlog * givlog;
 #define AVOID_NEW 1
 iv::decition::DecideGps00::DecideGps00()
 {
-
+    std::cout<<" init gps00"<<std::endl;
 }
 iv::decition::DecideGps00::~DecideGps00()
 {
@@ -347,6 +347,13 @@ iv::decition::Decition iv::decition::DecideGps00::getDecideFromGPS(GPS_INS now_g
     ServiceCarStatus.mavoidX=avoidXNew;
 
 
+
+    if(front_car_decide_avoid == false)    //geely logic yizhi
+    {
+        obstacle_avoid_flag =  0;
+    }
+
+
     if(ServiceCarStatus.msysparam.gpsOffset_y!=0 || ServiceCarStatus.msysparam.gpsOffset_x!=0){
         GPS_INS gpsOffset = Coordinate_UnTransfer(ServiceCarStatus.msysparam.gpsOffset_x, ServiceCarStatus.msysparam.gpsOffset_y, now_gps_ins);
         now_gps_ins.gps_x=gpsOffset.gps_x;
@@ -417,7 +424,7 @@ iv::decition::Decition iv::decition::DecideGps00::getDecideFromGPS(GPS_INS now_g
     secSpeed = realspeed / 3.6;
 
 
-    if(ServiceCarStatus.mnParkType==2)
+    if(ServiceCarStatus.mnParkType==2)//guosai pingtai yanzheng ceting
     {
         if(ServiceCarStatus.bocheMode &&(vehState != dReverTZD))
         {
@@ -557,7 +564,12 @@ iv::decition::Decition iv::decition::DecideGps00::getDecideFromGPS(GPS_INS now_g
     if (vehState == reversing)
     {
         double dis = GetDistance(now_gps_ins, Compute00().nearTpoint);
-        if (dis<2.0)//0.5
+        iv::Point2D pt = iv::decition::Coordinate_Transfer(now_gps_ins.gps_x,now_gps_ins.gps_y,aim_gps_ins);
+        iv::Point2D ptnear = iv::decition::Coordinate_Transfer(Compute00().nearTpoint.gps_x,Compute00().nearTpoint.gps_y,aim_gps_ins);
+
+         double fdistonear = fabs(pt.x - ptnear.x);
+         if(fdistonear<0.5)  //将吉利项目中的停车逻辑移植过来
+//        if (dis<2.0)//0.5
         {
             vehState = reverseCircle;
             qiedianCount = true;
@@ -1321,12 +1333,6 @@ iv::decition::Decition iv::decition::DecideGps00::getDecideFromGPS(GPS_INS now_g
                 gpsTraceNow.assign(gpsTraceOri.begin(), gpsTraceOri.end());
                 getGpsTraceNowLeftRight(gpsTraceNow);
             }
-//            else //if((vehState==preAvoid)||(vehState==normalRun)||(vehState))
-//            {
-//                gpsTraceNow.assign(gpsTraceOri.begin(), gpsTraceOri.end());
-//                gpsTraceNowLeft.assign(traceOriLeft.begin(),traceOriLeft.end());
-//                gpsTraceNowRight.assign(traceOriRight.begin(),traceOriRight.end());
-//            }
             else
             {
                 gpsTraceNow = getGpsTraceOffset(gpsTraceOri, avoidXNew);
@@ -4863,18 +4869,40 @@ float iv::decition::DecideGps00::ComputeV2XTrafficLightSpeed(iv::TrafficLight tr
         traffic_time = trafficLight.straightTime;
     }
 
-    passThrough = computeTrafficPass(nearTrafficDis,traffic_color,traffic_time,dSecSpeed);
-    if(passThrough)
-    {
+//    passThrough = computeTrafficPass(nearTrafficDis,traffic_color,traffic_time,dSecSpeed);
+//    if(passThrough)
+//    {
+//        return trafficSpeed;
+//    }
+//    else
+//    {
+//        trafficSpeed = computeTrafficSpeedLimt(nearTrafficDis);
+//        if(nearTrafficDis < 6)
+//        {
+//            float decelerate = 0 - ( secSpeed * secSpeed * 0.5 / nearTrafficDis);
+//            minDecelerate = min(minDecelerate,decelerate);
+//        }
+//        return trafficSpeed;
+//    }
+    double fTrafficBrake = 1.0;  //移植吉利项目的v2x
+    passThrough=computeTrafficPass(nearTrafficDis,traffic_color,traffic_time,secSpeed,dSecSpeed);
+    if(passThrough){
         return trafficSpeed;
-    }
-    else
-    {
-        trafficSpeed = computeTrafficSpeedLimt(nearTrafficDis);
-        if(nearTrafficDis < 6)
-        {
-            float decelerate = 0 - ( secSpeed * secSpeed * 0.5 / nearTrafficDis);
-            minDecelerate = min(minDecelerate,decelerate);
+    }else{
+        trafficSpeed=computeTrafficSpeedLimt(nearTrafficDis);
+        if(nearTrafficDis<(dSecSpeed*dSecSpeed/(2*fTrafficBrake))){
+            if(fabs(nearTrafficDis)<1.0)
+            {
+                minDecelerate = -1.0 * fTrafficBrake;
+            }
+            else
+            {
+                if((0.5*secSpeed*secSpeed/fTrafficBrake) > (nearTrafficDis*0.9))
+                {
+                    float decelerate =0-( secSpeed*secSpeed*0.5/(nearTrafficDis-0.5));
+                    minDecelerate=min(minDecelerate,decelerate);
+                }
+            }
         }
         return trafficSpeed;
     }
@@ -4882,9 +4910,12 @@ float iv::decition::DecideGps00::ComputeV2XTrafficLightSpeed(iv::TrafficLight tr
     return trafficSpeed;
 }
 
-bool iv::decition::DecideGps00::computeTrafficPass(float trafficDis,int trafficColor,float trafficTime,float dSecSpeed)
+//bool iv::decition::DecideGps00::computeTrafficPass(float trafficDis,int trafficColor,float trafficTime,float dSecSpeed)
+bool iv::decition::DecideGps00::computeTrafficPass(float trafficDis,int trafficColor,float trafficTime,float realSecSpeed,float dSecSpeed)
 {
     float passTime=0;
+    double fAcc = 0.6;
+    if(dSecSpeed == 0)return true;
     if (trafficColor == 2 || trafficColor == 3)
     {
         return false;
@@ -4898,6 +4929,16 @@ bool iv::decition::DecideGps00::computeTrafficPass(float trafficDis,int trafficC
         passTime=trafficDis/dSecSpeed;
         if(passTime+1< trafficTime)
         {
+            double passTime2= trafficTime - 0.1;
+            double disthru = realSecSpeed * passTime2 + 0.5 * fAcc * pow(passTime2,2);
+            if((disthru -1.0)< trafficDis )
+            {
+                if((realSecSpeed<3.0)&&(trafficDis>10))
+                {
+                    return true;
+                }
+                return false;
+            }
             return true;
         }
         else
@@ -4910,6 +4951,16 @@ bool iv::decition::DecideGps00::computeTrafficPass(float trafficDis,int trafficC
 float iv::decition::DecideGps00::computeTrafficSpeedLimt(float trafficDis)
 {
     float limit=200;
+    double fBrake = 1.0;
+    if(trafficDis < 1.0)
+    {
+        limit =0;
+    }
+    else
+    {
+        limit = 3.6*sqrt(2.0* fabs(fBrake) * (trafficDis-1.0) );
+    }
+    return limit;
     if(trafficDis<10)
     {
         limit = 0;

src/decition/decition_brain_sf_changan_shenlan/decition/decide_gps_00.h

@@ -241,7 +241,8 @@ public:
                                    int pathpoint,float secSpeed,float dSpeed,bool circleMode);
     float getTrafficLightSpeed(int traffic_light_color, int traffic_light_time, float dis);
 
-    bool computeTrafficPass(float trafficDis,int trafficColor,float trafficTime,float dSecSpeed);
+    //bool computeTrafficPass(float trafficDis,int trafficColor,float trafficTime,float dSecSpeed);
+    bool computeTrafficPass(float trafficDis,int trafficColor,float trafficTime,float realSecSpeed,float dSecSpeed);
     float computeTrafficSpeedLimt(float trafficDis);
     float ComputeTrafficLightSpeed(int traffic_light_color, int traffic_light_time,  const std::vector<GPSData> gpsMapLine,int traffic_light_pathpoint,
                                                                int pathpoint,float secSpeed,float dSpeed);

src/decition/decition_brain_sf_changan_shenlan_vedio/mainwindow.ui

@@ -1,24 +0,0 @@
-<ui version="4.0" >
- <author></author>
- <comment></comment>
- <exportmacro></exportmacro>
- <class>MainWindow</class>
- <widget class="QMainWindow" name="MainWindow" >
-  <property name="geometry" >
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>800</width>
-    <height>600</height>
-   </rect>
-  </property>
-  <property name="windowTitle" >
-   <string>MainWindow</string>
-  </property>
-  <widget class="QMenuBar" name="menubar" />
-  <widget class="QWidget" name="centralwidget" />
-  <widget class="QStatusBar" name="statusbar" />
- </widget>
- <pixmapfunction></pixmapfunction>
- <connections/>
-</ui>