|
|
@@ -0,0 +1,944 @@
|
|
|
+#include "roadviewitem.h"
|
|
|
+
|
|
|
+#include <math.h>
|
|
|
+
|
|
|
+#include "geofit.h"
|
|
|
+
|
|
|
+#include <QtWidgets>
|
|
|
+
|
|
|
+#include <QFont>
|
|
|
+
|
|
|
+roadviewitem::roadviewitem(Road * pRoad)
|
|
|
+{
|
|
|
+ mpRoad = pRoad;
|
|
|
+ mbNeedCalc = true;
|
|
|
+}
|
|
|
+
|
|
|
+QRectF roadviewitem::boundingRect() const
|
|
|
+{
|
|
|
+// qDebug("ratio is %f",mfratio);
|
|
|
+// return QRectF((mfxmin - mfwidth - 15)*mfratio,(mfymin-mfwidth-15)*mfratio,(mfxmax - mfxmin + 2.0*mfwidth+30)*mfratio,
|
|
|
+// (mfymax - mfymin+2.0*mfwidth+30)*mfratio);
|
|
|
+ return QRectF( - 10000,-10000 ,20000,
|
|
|
+ 20000);
|
|
|
+ // return QRectF(-10000,-10000,20000,20000);
|
|
|
+// float fwidth = mfwidth * mfratio;
|
|
|
+// return QRectF(mfxmin - fwidth - 15,mfymin-fwidth-15,mfxmax - mfxmin + 2.0*fwidth+30,
|
|
|
+// mfymax - mfymin+2.0*fwidth+30);
|
|
|
+ return QRectF(mfxmin - 10000,mfymin-10000,mfxmax - mfxmin + 20000,
|
|
|
+ mfymax - mfymin+20000);
|
|
|
+
|
|
|
+
|
|
|
+ // return QRectF(mfxmin - fwidth - 15,mfymin-fwidth-15,mfxmax - mfxmin + 2.0*fwidth+30,mfymax - mfymin+2.0*fwidth+30);
|
|
|
+// return QRectF(-10000,-10000,20000,20000);
|
|
|
+}
|
|
|
+
|
|
|
+void roadviewitem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
|
|
|
+{
|
|
|
+ (void)option;
|
|
|
+
|
|
|
+ int i;
|
|
|
+
|
|
|
+// if((mfratio/mfoldcalratio>3.0)||(mfratio/mfoldcalratio<0.3))
|
|
|
+// {
|
|
|
+// mbNeedCalc = true;
|
|
|
+// }
|
|
|
+
|
|
|
+ if(mfratio != mfoldcalratio)mbNeedCalc = true;
|
|
|
+// qDebug("painter");
|
|
|
+ Q_UNUSED(option);
|
|
|
+ Q_UNUSED(widget);
|
|
|
+
|
|
|
+ if(mbNeedCalc)
|
|
|
+ {
|
|
|
+ CalcLine();
|
|
|
+ CalcLane();
|
|
|
+ }
|
|
|
+
|
|
|
+ painter->setPen(Qt::NoPen);
|
|
|
+// painter->setBrush(Qt::darkGray);
|
|
|
+// painter->drawRect(0,0,mnlen,mnwidth*mfratio);
|
|
|
+
|
|
|
+ if(mbShowLine)
|
|
|
+ {
|
|
|
+ if(mbMark)painter->setBrush(Qt::red);
|
|
|
+ else
|
|
|
+ painter->setBrush(Qt::white);
|
|
|
+
|
|
|
+
|
|
|
+ for(i=0;i<mvectorline.size();i++)
|
|
|
+ {
|
|
|
+ painter->drawPolygon(mvectorline[i].mPoints,4);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(mbShowLane)
|
|
|
+ {
|
|
|
+ painter->setBrush(Qt::darkGray);
|
|
|
+ int nsize = mvectorlaneview.size();
|
|
|
+ for(i=0;i<nsize;i++)
|
|
|
+ {
|
|
|
+ switch (mvectorlaneview[i].ntype) {
|
|
|
+ case 2:
|
|
|
+ painter->setBrush(Qt::darkGray);
|
|
|
+ break;
|
|
|
+ case 8:
|
|
|
+ painter->setBrush(Qt::red);
|
|
|
+ break;
|
|
|
+ case 9:
|
|
|
+ painter->setBrush(QColor(0xB2,0xB2,0xD6));
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ painter->setBrush(Qt::darkGreen);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ painter->drawPolygon(mvectorlaneview[i].mPoints,4);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ painter->setBrush(Qt::white);
|
|
|
+
|
|
|
+ int nsize = mvectorlanemark.size();
|
|
|
+ for(i=0;i<nsize;i++)
|
|
|
+ {
|
|
|
+ switch (mvectorlanemark[i].ncolor) {
|
|
|
+ case 0:
|
|
|
+ painter->setBrush(Qt::white);
|
|
|
+ break;
|
|
|
+ case 1:
|
|
|
+ painter->setBrush(Qt::blue);
|
|
|
+ break;
|
|
|
+ case 2:
|
|
|
+ painter->setBrush(Qt::green);
|
|
|
+ break;
|
|
|
+ case 3:
|
|
|
+ painter->setBrush(Qt::red);
|
|
|
+ break;
|
|
|
+ case 4:
|
|
|
+ painter->setBrush(Qt::white);
|
|
|
+ break;
|
|
|
+ case 5:
|
|
|
+ painter->setBrush(Qt::yellow);
|
|
|
+ break;
|
|
|
+ case 6:
|
|
|
+ painter->setBrush(Qt::yellow); //orange use yellow replace
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ painter->setBrush(Qt::white);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ painter->drawPolygon(mvectorlanemark[i].mPoints,4);
|
|
|
+ painter->setBrush(Qt::white);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ QPen pen;
|
|
|
+ pen.setWidth(1);
|
|
|
+ pen.setColor(Qt::white);
|
|
|
+ painter->setPen(pen);
|
|
|
+
|
|
|
+ QFont font = painter->font();
|
|
|
+ font.setPixelSize(3);
|
|
|
+ painter->setFont(font);
|
|
|
+
|
|
|
+ if(mbShowRoadID)
|
|
|
+ {
|
|
|
+ painter->drawText(mtextx,mtexty,mpRoad->GetRoadId().data());
|
|
|
+ }
|
|
|
+
|
|
|
+ painter->setBrush(Qt::NoBrush);
|
|
|
+ if(mbShowLine)
|
|
|
+ {
|
|
|
+ if(mbMark)
|
|
|
+ {
|
|
|
+ if(mvectorline.size()>0)
|
|
|
+ {
|
|
|
+ painter->drawEllipse(mvectorline[0].mstartx-1.5,mvectorline[0].mstarty-1.5,3,3);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+// QPen pen;
|
|
|
+// pen.setWidth(1);
|
|
|
+// pen.setColor(Qt::white);
|
|
|
+// painter->setPen(pen);
|
|
|
+// for(i=0;i<mvectorline.size();i++)
|
|
|
+// {
|
|
|
+// painter->drawLine(mvectorline[i].mstartx,mvectorline[i].mstarty,
|
|
|
+// mvectorline[i].mendx,mvectorline[i].mendy);
|
|
|
+// }
|
|
|
+ // painter->drawLine(1,0,mnlen-1,0);
|
|
|
+
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+bool roadviewitem::IsDrawMark(double s)
|
|
|
+{
|
|
|
+ const double dotdis = 10.0;
|
|
|
+ const double dotlen = 5.0;
|
|
|
+
|
|
|
+ double y = fmod(s,dotdis);
|
|
|
+ if(y>dotlen)return true;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void roadviewitem::CalcLane()
|
|
|
+{
|
|
|
+ if(mbShowLane == false)return;
|
|
|
+ int i,j;
|
|
|
+ int nsize = mvectorline.size();
|
|
|
+ mvectorlaneview.clear();
|
|
|
+ mvectorlanemark.clear();
|
|
|
+
|
|
|
+ double flmw = 0.15;
|
|
|
+
|
|
|
+
|
|
|
+ for(i=0;i<mvectorlaneline.size();i++)
|
|
|
+ {
|
|
|
+ for(j=0;j<(mvectorlaneline[i].mvectorlanelinese.size()-1);j++)
|
|
|
+ {
|
|
|
+ std::vector<iv::LanePoint> xvepre = mvectorlaneline[i].mvectorlanelinese[j].mvectorlanepoint;
|
|
|
+ std::vector<iv::LanePoint> xvenxt = mvectorlaneline[i].mvectorlanelinese[j+1].mvectorlanepoint;
|
|
|
+ if((xvepre.size()<2)||(xvenxt.size()<2)||(xvenxt.size() != xvepre.size()))
|
|
|
+ {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ int k;
|
|
|
+ for(k=0;k<(xvepre.size()-1);k++)
|
|
|
+ {
|
|
|
+
|
|
|
+ iv::laneviewdata lv;
|
|
|
+ lv.mPoints[0].setX(xvepre[k].mfX);
|
|
|
+ lv.mPoints[0].setY(xvepre[k].mfY*(-1.0));
|
|
|
+ lv.mPoints[1].setX(xvenxt[k].mfX);
|
|
|
+ lv.mPoints[1].setY(xvenxt[k].mfY*(-1.0));
|
|
|
+ lv.mPoints[2].setX(xvenxt[k+1].mfX);
|
|
|
+ lv.mPoints[2].setY(xvenxt[k+1].mfY*(-1.0));
|
|
|
+ lv.mPoints[3].setX(xvepre[k+1].mfX);
|
|
|
+ lv.mPoints[3].setY(xvepre[k+1].mfY*(-1.0));
|
|
|
+ if(xvepre[k].mnlane>0)lv.ntype = xvepre[k].mnlanetype;
|
|
|
+ else lv.ntype = xvepre[k+1].mnlanetype;
|
|
|
+ mvectorlaneview.push_back(lv);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ for(i=0;i<mvectorlaneline.size();i++)
|
|
|
+ {
|
|
|
+ for(j=0;j<(mvectorlaneline[i].mvectorlanelinese.size()-1);j++)
|
|
|
+ {
|
|
|
+ std::vector<iv::LanePoint> xvepre = mvectorlaneline[i].mvectorlanelinese[j].mvectorlanepoint;
|
|
|
+ std::vector<iv::LanePoint> xvenxt = mvectorlaneline[i].mvectorlanelinese[j+1].mvectorlanepoint;
|
|
|
+ if((xvepre.size()<2)||(xvenxt.size()<2)||(xvenxt.size() != xvepre.size()))
|
|
|
+ {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ int k;
|
|
|
+ for(k=0;k<(xvepre.size());k++)
|
|
|
+ {
|
|
|
+ iv::lanemark lv;
|
|
|
+ int nmarktype = xvepre[k].mnlanemarktype;
|
|
|
+ if(nmarktype >= 0)
|
|
|
+ {
|
|
|
+ if(nmarktype<2)
|
|
|
+ {
|
|
|
+ if((nmarktype == 0)||(IsDrawMark(xvepre[k].mS)))
|
|
|
+ {
|
|
|
+ lv.mPoints[0].setX(xvepre[k].mfX + 0.5*flmw * cos(xvenxt[k].mfhdg - M_PI/2.0));
|
|
|
+ lv.mPoints[0].setY((xvepre[k].mfY+0.5*flmw * sin(xvenxt[k].mfhdg - M_PI/2.0))*(-1.0));
|
|
|
+ lv.mPoints[1].setX(xvenxt[k].mfX+ 0.5*flmw * cos(xvepre[k].mfhdg - M_PI/2.0));
|
|
|
+ lv.mPoints[1].setY((xvenxt[k].mfY+0.5*flmw * sin(xvepre[k].mfhdg - M_PI/2.0))*(-1.0));
|
|
|
+
|
|
|
+ lv.mPoints[2].setX(xvenxt[k].mfX + 0.5*flmw * cos(xvenxt[k].mfhdg + M_PI/2.0));
|
|
|
+ lv.mPoints[2].setY((xvenxt[k].mfY+0.5*flmw * sin(xvenxt[k].mfhdg + M_PI/2.0))*(-1.0));
|
|
|
+ lv.mPoints[3].setX(xvepre[k].mfX+ 0.5*flmw * cos(xvepre[k].mfhdg + M_PI/2.0));
|
|
|
+ lv.mPoints[3].setY((xvepre[k].mfY+0.5*flmw * sin(xvepre[k].mfhdg + M_PI/2.0))*(-1.0));
|
|
|
+ lv.ncolor = xvepre[k].mnlanecolor;
|
|
|
+ mvectorlanemark.push_back(lv);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if((nmarktype == 2)||(nmarktype == 3)||(IsDrawMark(xvepre[k].mS)))
|
|
|
+ {
|
|
|
+ lv.mPoints[0].setX(xvepre[k].mfX + flmw * cos(xvenxt[k].mfhdg + M_PI/2.0));
|
|
|
+ lv.mPoints[0].setY((xvepre[k].mfY+flmw * sin(xvenxt[k].mfhdg + M_PI/2.0))*(-1.0));
|
|
|
+ lv.mPoints[1].setX(xvenxt[k].mfX+ flmw * cos(xvepre[k].mfhdg + M_PI/2.0));
|
|
|
+ lv.mPoints[1].setY((xvenxt[k].mfY+flmw * sin(xvepre[k].mfhdg + M_PI/2.0))*(-1.0));
|
|
|
+
|
|
|
+ lv.mPoints[2].setX(xvenxt[k].mfX + 2*flmw * cos(xvenxt[k].mfhdg + M_PI/2.0));
|
|
|
+ lv.mPoints[2].setY((xvenxt[k].mfY+2*flmw * sin(xvenxt[k].mfhdg + M_PI/2.0))*(-1.0));
|
|
|
+ lv.mPoints[3].setX(xvepre[k].mfX+ 2*flmw * cos(xvepre[k].mfhdg + M_PI/2.0));
|
|
|
+ lv.mPoints[3].setY((xvepre[k].mfY+2*flmw * sin(xvepre[k].mfhdg + M_PI/2.0))*(-1.0));
|
|
|
+ lv.ncolor = xvepre[k].mnlanecolor;
|
|
|
+ mvectorlanemark.push_back(lv);
|
|
|
+ }
|
|
|
+ if((nmarktype == 2)||(nmarktype == 4)||(IsDrawMark(xvepre[k].mS)))
|
|
|
+ {
|
|
|
+ lv.mPoints[0].setX(xvepre[k].mfX + flmw * cos(xvenxt[k].mfhdg - M_PI/2.0));
|
|
|
+ lv.mPoints[0].setY((xvepre[k].mfY+flmw * sin(xvenxt[k].mfhdg - M_PI/2.0))*(-1.0));
|
|
|
+ lv.mPoints[1].setX(xvenxt[k].mfX+ flmw * cos(xvepre[k].mfhdg - M_PI/2.0));
|
|
|
+ lv.mPoints[1].setY((xvenxt[k].mfY+flmw * sin(xvepre[k].mfhdg - M_PI/2.0))*(-1.0));
|
|
|
+
|
|
|
+ lv.mPoints[2].setX(xvenxt[k].mfX + 2*flmw * cos(xvenxt[k].mfhdg - M_PI/2.0));
|
|
|
+ lv.mPoints[2].setY((xvenxt[k].mfY+2*flmw * sin(xvenxt[k].mfhdg - M_PI/2.0))*(-1.0));
|
|
|
+ lv.mPoints[3].setX(xvepre[k].mfX+ 2*flmw * cos(xvepre[k].mfhdg - M_PI/2.0));
|
|
|
+ lv.mPoints[3].setY((xvepre[k].mfY+2*flmw * sin(xvepre[k].mfhdg - M_PI/2.0))*(-1.0));
|
|
|
+ lv.ncolor = xvepre[k].mnlanecolor;
|
|
|
+
|
|
|
+ mvectorlanemark.push_back(lv);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ // }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ return;
|
|
|
+
|
|
|
+// qDebug("size is %d ",nsize);
|
|
|
+ for(i=0;i<nsize;i++)
|
|
|
+ {
|
|
|
+// qDebug("i = %d",i);
|
|
|
+ double fdis = sqrt(pow(mvectorline[i].mendx - mvectorline[i].mstartx,2)+pow(mvectorline[i].mendy - mvectorline[i].mstarty,2));
|
|
|
+ if(fdis == 0)continue;
|
|
|
+ std::vector<iv::LanePoint> xvectorlp1 = xodrfunc::GetAllLanePoint(mpRoad,mvectorline[i].mE - fdis,
|
|
|
+ mvectorline[i].mstartx,mvectorline[i].mstarty *(-1),mvectorline[i].mfHdg);
|
|
|
+ std::vector<iv::LanePoint> xvectorlp2 = xodrfunc::GetAllLanePoint(mpRoad,mvectorline[i].mE,
|
|
|
+ mvectorline[i].mendx,mvectorline[i].mendy *(-1),mvectorline[i].mfHdg);
|
|
|
+
|
|
|
+
|
|
|
+ if(xvectorlp1.size() == xvectorlp2.size())
|
|
|
+ {
|
|
|
+ for(j=0;j<(xvectorlp1.size());j++)
|
|
|
+ {
|
|
|
+ iv::laneviewdata lv;
|
|
|
+ iv::LanePoint lpstart1,lpstart2,lpend1,lpend2;
|
|
|
+ int nlane1_index_start,nlane2_index_start;
|
|
|
+ int nlane1_index_end,nlane2_index_end;
|
|
|
+ nlane1_index_start = j;
|
|
|
+ lpstart1 = xvectorlp1[nlane1_index_start];
|
|
|
+ if(lpstart1.mnlane == 0)
|
|
|
+ {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ nlane1_index_end = 1000;
|
|
|
+ nlane2_index_end = 1000;
|
|
|
+
|
|
|
+ if(lpstart1.mnlane>0)nlane2_index_start = j+1;
|
|
|
+ else nlane2_index_start = j-1;
|
|
|
+ if((nlane2_index_start < 0)||(nlane2_index_start>= xvectorlp1.size()))
|
|
|
+ {
|
|
|
+ std::cout<<"nlane2_index_start error."<<std::endl;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ for(int k=0;k<xvectorlp2.size();k++)
|
|
|
+ {
|
|
|
+ if(xvectorlp2[k].mnlane == xvectorlp1[nlane1_index_start].mnlane)
|
|
|
+ {
|
|
|
+ nlane1_index_end = k;
|
|
|
+ }
|
|
|
+ if(xvectorlp2[k].mnlane == xvectorlp1[nlane2_index_start].mnlane)
|
|
|
+ {
|
|
|
+ nlane2_index_end = k;
|
|
|
+ }
|
|
|
+ if((nlane1_index_end != 1000)&&(nlane2_index_end != 1000))
|
|
|
+ {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if((nlane1_index_end == 1000)||(nlane2_index_end == 1000))
|
|
|
+ {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ lpstart1 = xvectorlp1[nlane1_index_start];
|
|
|
+ lpstart2 = xvectorlp1[nlane2_index_start];
|
|
|
+ lpend1 = xvectorlp2[nlane1_index_end];
|
|
|
+ lpend2 = xvectorlp2[nlane2_index_end];
|
|
|
+
|
|
|
+
|
|
|
+ lv.mPoints[0].setX(lpstart1.mfX);
|
|
|
+ lv.mPoints[0].setY(lpstart1.mfY*(-1));
|
|
|
+ lv.mPoints[1].setX(lpstart2.mfX);
|
|
|
+ lv.mPoints[1].setY(lpstart2.mfY*(-1));
|
|
|
+ lv.mPoints[2].setX(lpend2.mfX);
|
|
|
+ lv.mPoints[2].setY(lpend2.mfY*(-1));
|
|
|
+ lv.mPoints[3].setX(lpend1.mfX);
|
|
|
+ lv.mPoints[3].setY(lpend1.mfY*(-1));
|
|
|
+ mvectorlaneview.push_back(lv);
|
|
|
+ // qDebug("push size is %d ",mvectorlaneview.size());
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+void roadviewitem::CalcLine()
|
|
|
+{
|
|
|
+
|
|
|
+// Road * pRoad = mpRoad;
|
|
|
+ mvectorline.clear();
|
|
|
+
|
|
|
+ if(mbShowLane)
|
|
|
+ {
|
|
|
+ mvectorlaneline.clear();
|
|
|
+ }
|
|
|
+ int j;
|
|
|
+ double S = 0;
|
|
|
+ int nlanesec = 0;
|
|
|
+ double lanesection_s = 0;
|
|
|
+ double lane_s = 0;
|
|
|
+ if(mpRoad->GetLaneSectionCount()<1)
|
|
|
+ {
|
|
|
+ qDebug("no lane,return;");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ LaneSection * pLS = mpRoad->GetLaneSection(0);
|
|
|
+ lanesection_s = pLS->GetS();
|
|
|
+
|
|
|
+ iv::lanesectionlinese xlsl;
|
|
|
+ int nLastSection;
|
|
|
+ if(mbShowLane)
|
|
|
+ {
|
|
|
+ if(mpRoad->GetGeometryBlockCount() > 0)
|
|
|
+ {
|
|
|
+
|
|
|
+ double fx = mpRoad->GetGeometryBlock(0)->GetGeometryAt(0)->GetX();
|
|
|
+ double fy = mpRoad->GetGeometryBlock(0)->GetGeometryAt(0)->GetY();
|
|
|
+ double fhdg = mpRoad->GetGeometryBlock(0)->GetGeometryAt(0)->GetHdg();
|
|
|
+ std::vector<iv::LanePoint> xveclp = xodrfunc::GetAllLanePoint(mpRoad,0,fx,fy,fhdg);
|
|
|
+ iv::lanesectionpoint xvecsp;
|
|
|
+ xvecsp.mvectorlanepoint = xveclp;
|
|
|
+ xlsl.mnsec = 0;
|
|
|
+ nLastSection = 0;
|
|
|
+ xlsl.mvectorlanelinese.push_back(xvecsp);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ for(j=0;j<mpRoad->GetGeometryBlockCount();j++)
|
|
|
+ {
|
|
|
+ if(nlanesec < (mpRoad->GetLaneSectionCount() -1))
|
|
|
+ {
|
|
|
+ if(mpRoad->GetLaneSection(nlanesec+1)->GetS() <= S)
|
|
|
+ {
|
|
|
+ nlanesec++;
|
|
|
+ pLS = mpRoad->GetLaneSection(nlanesec);
|
|
|
+ lanesection_s = pLS->GetS();
|
|
|
+ lane_s = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ GeometryBlock * pgeob = mpRoad->GetGeometryBlock(j);
|
|
|
+ double x,y;
|
|
|
+ double x_center,y_center;
|
|
|
+ double R;
|
|
|
+ RoadGeometry * pg;
|
|
|
+ GeometryArc * parc;
|
|
|
+ GeometryParamPoly3 * ppp3;
|
|
|
+ GeometrySpiral *pSpiral;
|
|
|
+ double rel_x,rel_y,rel_hdg;
|
|
|
+ pg = pgeob->GetGeometryAt(0);
|
|
|
+
|
|
|
+ x = pg->GetX();
|
|
|
+ y = pg->GetY();
|
|
|
+ iv::lineviewdata xline;
|
|
|
+
|
|
|
+
|
|
|
+ switch (pg->GetGeomType()) {
|
|
|
+ case 0:
|
|
|
+ {
|
|
|
+ xline.mstartx = x;
|
|
|
+ xline.mstarty = y *(-1.0);
|
|
|
+ int ncount = pg->GetLength() * 10.0/mfratio;
|
|
|
+ double fstep;
|
|
|
+ if(ncount > 0)fstep = pg->GetLength()/ncount;
|
|
|
+ int i;
|
|
|
+ for(i=1;i<ncount;i++)
|
|
|
+ {
|
|
|
+ double xtem,ytem;
|
|
|
+ xtem = x + (i*fstep)*cos(pg->GetHdg());
|
|
|
+ ytem = y + (i*fstep)*sin(pg->GetHdg());
|
|
|
+ xline.mendx = xtem;
|
|
|
+ xline.mendy = ytem*(-1.0);
|
|
|
+ xline.mE = xline.mE + fstep;
|
|
|
+ xline.mfHdg = pg->GetHdg();
|
|
|
+ CalcPoints(&xline);
|
|
|
+ mvectorline.push_back(xline);
|
|
|
+ if(mbShowLane)
|
|
|
+ {
|
|
|
+ std::vector<iv::LanePoint> xveclp = xodrfunc::GetAllLanePoint(mpRoad,xline.mE,xline.mendx,xline.mendy*(-1.0),xline.mfHdg);
|
|
|
+ if(xveclp.size() > 0)
|
|
|
+ {
|
|
|
+ if(xveclp[0].mnLaneSection != nLastSection)
|
|
|
+ {
|
|
|
+ mvectorlaneline.push_back(xlsl);
|
|
|
+ iv::lanesectionpoint xvecsp;
|
|
|
+ xvecsp.mvectorlanepoint = xveclp;
|
|
|
+ xlsl.mnsec = xveclp[0].mnLaneSection;
|
|
|
+ nLastSection =xlsl.mnsec;
|
|
|
+ xlsl.mvectorlanelinese.push_back(xvecsp);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if(xlsl.mvectorlanelinese.size() > 0)
|
|
|
+ {
|
|
|
+ if((xlsl.mvectorlanelinese[0].mvectorlanepoint.size() > 0)&&(xlsl.mvectorlanelinese[0].mvectorlanepoint.size() == xveclp.size()))
|
|
|
+ {
|
|
|
+ iv::lanesectionpoint xvecsp;
|
|
|
+ xvecsp.mvectorlanepoint = xveclp;
|
|
|
+ xlsl.mnsec = xveclp[0].mnLaneSection;
|
|
|
+ nLastSection =xlsl.mnsec;
|
|
|
+ xlsl.mvectorlanelinese.push_back(xvecsp);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ mvectorlaneline.push_back(xlsl);
|
|
|
+ iv::lanesectionpoint xvecsp;
|
|
|
+ xvecsp.mvectorlanepoint = xveclp;
|
|
|
+ xlsl.mnsec = xveclp[0].mnLaneSection;
|
|
|
+ nLastSection =xlsl.mnsec;
|
|
|
+ xlsl.mvectorlanelinese.push_back(xvecsp);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ xline.mstartx = xtem;
|
|
|
+ xline.mstarty = ytem*(-1.0);
|
|
|
+ }
|
|
|
+ if(ncount > 1)xline.mE = xline.mE + (pg->GetLength() -(ncount -1)*fstep);
|
|
|
+ else xline.mE = xline.mE + pg->GetLength();
|
|
|
+ xline.mendx = x + pg->GetLength() * cos(pg->GetHdg());
|
|
|
+ xline.mendy = (y + pg->GetLength() * sin(pg->GetHdg()))*(-1.0);
|
|
|
+
|
|
|
+// painter->drawLine(QPoint(x*mnfac,y*mnfac*(-1)),
|
|
|
+// QPoint((x + pg->GetLength() * cos(pg->GetHdg()))*mnfac,(y + pg->GetLength() * sin(pg->GetHdg()))*mnfac*(-1)));
|
|
|
+ CalcPoints(&xline);
|
|
|
+ mvectorline.push_back(xline);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 1:
|
|
|
+ pSpiral = (GeometrySpiral * )pg;
|
|
|
+ {
|
|
|
+ int ncount = pSpiral->GetLength() * mfratio;
|
|
|
+ if(ncount < 2)ncount = 2;
|
|
|
+ double sstep = pSpiral->GetLength()/((double)ncount);
|
|
|
+ int k;
|
|
|
+ double x0,y0,hdg0,s0;
|
|
|
+ x0 = pSpiral->GetX();
|
|
|
+ y0 = pSpiral->GetY();
|
|
|
+ s0 = pSpiral->GetS();
|
|
|
+ hdg0 = pSpiral->GetHdg() ;
|
|
|
+ pSpiral->GetCoords(s0,rel_x,rel_y,rel_hdg);
|
|
|
+
|
|
|
+ x = rel_x;
|
|
|
+ y = rel_y;
|
|
|
+ xline.mstartx = x;
|
|
|
+ xline.mstarty = y *(-1.0);
|
|
|
+ for(k=1;k<=ncount;k++)
|
|
|
+ {
|
|
|
+ pSpiral->GetCoords(s0+sstep*k,rel_x,rel_y,rel_hdg);
|
|
|
+
|
|
|
+ x = rel_x;
|
|
|
+ y = rel_y;
|
|
|
+ xline.mendx = x;
|
|
|
+ xline.mendy = y*(-1.0);
|
|
|
+ xline.mE = xline.mE + sstep *k;
|
|
|
+ xline.mfHdg = xodrfunc::CalcHdg(QPointF(xline.mstartx,xline.mstarty*(-1)),QPointF(xline.mendx,xline.mendy*(-1)));
|
|
|
+ CalcPoints(&xline);
|
|
|
+ mvectorline.push_back(xline);
|
|
|
+ if(mbShowLane)
|
|
|
+ {
|
|
|
+ std::vector<iv::LanePoint> xveclp = xodrfunc::GetAllLanePoint(mpRoad,xline.mE,xline.mendx,xline.mendy*(-1.0),xline.mfHdg);
|
|
|
+ if(xveclp.size() > 0)
|
|
|
+ {
|
|
|
+ if(xveclp[0].mnLaneSection != nLastSection)
|
|
|
+ {
|
|
|
+ mvectorlaneline.push_back(xlsl);
|
|
|
+ iv::lanesectionpoint xvecsp;
|
|
|
+ xvecsp.mvectorlanepoint = xveclp;
|
|
|
+ xlsl.mnsec = xveclp[0].mnLaneSection;
|
|
|
+ nLastSection =xlsl.mnsec;
|
|
|
+ xlsl.mvectorlanelinese.push_back(xvecsp);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if(xlsl.mvectorlanelinese.size() > 0)
|
|
|
+ {
|
|
|
+ if((xlsl.mvectorlanelinese[0].mvectorlanepoint.size() > 0)&&(xlsl.mvectorlanelinese[0].mvectorlanepoint.size() == xveclp.size()))
|
|
|
+ {
|
|
|
+ iv::lanesectionpoint xvecsp;
|
|
|
+ xvecsp.mvectorlanepoint = xveclp;
|
|
|
+ xlsl.mnsec = xveclp[0].mnLaneSection;
|
|
|
+ nLastSection =xlsl.mnsec;
|
|
|
+ xlsl.mvectorlanelinese.push_back(xvecsp);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ mvectorlaneline.push_back(xlsl);
|
|
|
+ iv::lanesectionpoint xvecsp;
|
|
|
+ xvecsp.mvectorlanepoint = xveclp;
|
|
|
+ xlsl.mnsec = xveclp[0].mnLaneSection;
|
|
|
+ nLastSection =xlsl.mnsec;
|
|
|
+ xlsl.mvectorlanelinese.push_back(xvecsp);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ xline.mstartx = x;
|
|
|
+ xline.mstarty = y*(-1.0);
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+// qDebug("spi");
|
|
|
+ break;
|
|
|
+ case 2:
|
|
|
+ {
|
|
|
+ parc = (GeometryArc *)pg;
|
|
|
+ R = abs(1.0/parc->GetCurvature());
|
|
|
+ if(parc->GetCurvature() > 0)
|
|
|
+ {
|
|
|
+ x_center = pg->GetX() + R *cos(pg->GetHdg() + M_PI/2.0);
|
|
|
+ y_center = pg->GetY() + R * sin(pg->GetHdg() + M_PI/2.0);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ x_center = pg->GetX() + R *cos(pg->GetHdg() -M_PI/2.0);
|
|
|
+ y_center = pg->GetY() + R * sin(pg->GetHdg() - M_PI/2.0);
|
|
|
+ }
|
|
|
+
|
|
|
+ int k;
|
|
|
+ int ncount = parc->GetLength() * 3.0/mfratio;
|
|
|
+ if(ncount< 2)ncount = 2;
|
|
|
+ double curv = parc->GetCurvature();
|
|
|
+ double hdgstep;
|
|
|
+ double hdg0 = parc->GetHdg();
|
|
|
+ double hdgnow = parc->GetHdg();
|
|
|
+ if(ncount > 0) hdgstep= (parc->GetLength()/R)/ncount;
|
|
|
+
|
|
|
+ double x_draw,y_draw;
|
|
|
+
|
|
|
+ if(curv > 0)
|
|
|
+ {
|
|
|
+ hdgnow = hdg0 ;
|
|
|
+ x_draw = x_center + R *cos(hdgnow - M_PI/2.0);
|
|
|
+ y_draw = y_center + R * sin(hdgnow - M_PI/2.0);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ hdgnow = hdg0;
|
|
|
+ x_draw = x_center + R *cos(hdgnow + M_PI/2.0);
|
|
|
+ y_draw = y_center + R * sin(hdgnow + M_PI/2.0);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ xline.mstartx = x_draw;
|
|
|
+ xline.mstarty = y_draw *(-1.0);
|
|
|
+
|
|
|
+ for(k=1;k<=ncount;k++)
|
|
|
+ {
|
|
|
+
|
|
|
+
|
|
|
+ if(curv > 0)
|
|
|
+ {
|
|
|
+ hdgnow = hdg0 + k*hdgstep;
|
|
|
+ x_draw = x_center + R *cos(hdgnow - M_PI/2.0);
|
|
|
+ y_draw = y_center + R * sin(hdgnow - M_PI/2.0);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ hdgnow = hdg0 - k * hdgstep;
|
|
|
+ x_draw = x_center + R *cos(hdgnow + M_PI/2.0);
|
|
|
+ y_draw = y_center + R * sin(hdgnow + M_PI/2.0);
|
|
|
+ }
|
|
|
+ xline.mendx = x_draw;
|
|
|
+ xline.mendy = y_draw*(-1.0);
|
|
|
+ xline.mE = xline.mE + hdgstep * R;
|
|
|
+ CalcPoints(&xline);
|
|
|
+ xline.mfHdg = xodrfunc::CalcHdg(QPointF(xline.mstartx,xline.mstarty*(-1)),QPointF(xline.mendx,xline.mendy*(-1)));
|
|
|
+ mvectorline.push_back(xline);
|
|
|
+ if(mbShowLane)
|
|
|
+ {
|
|
|
+ std::vector<iv::LanePoint> xveclp = xodrfunc::GetAllLanePoint(mpRoad,xline.mE,xline.mendx,xline.mendy*(-1.0),xline.mfHdg);
|
|
|
+ if(xveclp.size() > 0)
|
|
|
+ {
|
|
|
+ if(xveclp[0].mnLaneSection != nLastSection)
|
|
|
+ {
|
|
|
+ mvectorlaneline.push_back(xlsl);
|
|
|
+ iv::lanesectionpoint xvecsp;
|
|
|
+ xvecsp.mvectorlanepoint = xveclp;
|
|
|
+ xlsl.mnsec = xveclp[0].mnLaneSection;
|
|
|
+ nLastSection =xlsl.mnsec;
|
|
|
+ xlsl.mvectorlanelinese.push_back(xvecsp);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if(xlsl.mvectorlanelinese.size() > 0)
|
|
|
+ {
|
|
|
+ if((xlsl.mvectorlanelinese[0].mvectorlanepoint.size() > 0)&&(xlsl.mvectorlanelinese[0].mvectorlanepoint.size() == xveclp.size()))
|
|
|
+ {
|
|
|
+ iv::lanesectionpoint xvecsp;
|
|
|
+ xvecsp.mvectorlanepoint = xveclp;
|
|
|
+ xlsl.mnsec = xveclp[0].mnLaneSection;
|
|
|
+ nLastSection =xlsl.mnsec;
|
|
|
+ xlsl.mvectorlanelinese.push_back(xvecsp);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ mvectorlaneline.push_back(xlsl);
|
|
|
+ iv::lanesectionpoint xvecsp;
|
|
|
+ xvecsp.mvectorlanepoint = xveclp;
|
|
|
+ xlsl.mnsec = xveclp[0].mnLaneSection;
|
|
|
+ nLastSection =xlsl.mnsec;
|
|
|
+ xlsl.mvectorlanelinese.push_back(xvecsp);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ xline.mstartx = x_draw;
|
|
|
+ xline.mstarty = y_draw*(-1.0);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case 4:
|
|
|
+ {
|
|
|
+ ppp3 = (GeometryParamPoly3 * )pg;
|
|
|
+ int ncount = ppp3->GetLength()* 3.0/ mfratio;
|
|
|
+ if(ncount < 2)ncount = 2;
|
|
|
+ double sstep;
|
|
|
+ if(ncount > 0)sstep = ppp3->GetLength()/ncount;
|
|
|
+ else sstep = 10000.0;
|
|
|
+ double s = 0;
|
|
|
+ double xtem,ytem;
|
|
|
+ xtem = ppp3->GetuA() + ppp3->GetuB() * s + ppp3->GetuC() * s*s + ppp3->GetuD() * s*s*s;
|
|
|
+ ytem = ppp3->GetvA() + ppp3->GetvB() * s + ppp3->GetvC() * s*s + ppp3->GetvD() * s*s*s;
|
|
|
+ x = xtem*cos(ppp3->GetHdg()) - ytem * sin(ppp3->GetHdg()) + ppp3->GetX();
|
|
|
+ y = xtem*sin(ppp3->GetHdg()) + ytem * cos(ppp3->GetHdg()) + ppp3->GetY();
|
|
|
+ s = s+ sstep;
|
|
|
+ xline.mstartx = x;
|
|
|
+ xline.mstarty = y *(-1.0);
|
|
|
+ while(s <= ppp3->GetLength())
|
|
|
+ {
|
|
|
+
|
|
|
+ xtem = ppp3->GetuA() + ppp3->GetuB() * s + ppp3->GetuC() * s*s + ppp3->GetuD() * s*s*s;
|
|
|
+ ytem = ppp3->GetvA() + ppp3->GetvB() * s + ppp3->GetvC() * s*s + ppp3->GetvD() * s*s*s;
|
|
|
+ x = xtem*cos(ppp3->GetHdg()) - ytem * sin(ppp3->GetHdg()) + ppp3->GetX();
|
|
|
+ y = xtem*sin(ppp3->GetHdg()) + ytem * cos(ppp3->GetHdg()) + ppp3->GetY();
|
|
|
+ xline.mendx = x;
|
|
|
+ xline.mendy = y*(-1.0);
|
|
|
+ xline.mE = xline.mE + sstep;
|
|
|
+ CalcPoints(&xline);
|
|
|
+ xline.mfHdg = xodrfunc::CalcHdg(QPointF(xline.mstartx,xline.mstarty*(-1)),QPointF(xline.mendx,xline.mendy*(-1)));
|
|
|
+ mvectorline.push_back(xline);
|
|
|
+ if(mbShowLane)
|
|
|
+ {
|
|
|
+ std::vector<iv::LanePoint> xveclp = xodrfunc::GetAllLanePoint(mpRoad,xline.mE,xline.mendx,xline.mendy*(-1.0),xline.mfHdg);
|
|
|
+ if(xveclp.size() > 0)
|
|
|
+ {
|
|
|
+ if(xveclp[0].mnLaneSection != nLastSection)
|
|
|
+ {
|
|
|
+ mvectorlaneline.push_back(xlsl);
|
|
|
+ iv::lanesectionpoint xvecsp;
|
|
|
+ xvecsp.mvectorlanepoint = xveclp;
|
|
|
+ xlsl.mnsec = xveclp[0].mnLaneSection;
|
|
|
+ nLastSection =xlsl.mnsec;
|
|
|
+ xlsl.mvectorlanelinese.push_back(xvecsp);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if(xlsl.mvectorlanelinese.size() > 0)
|
|
|
+ {
|
|
|
+ if((xlsl.mvectorlanelinese[0].mvectorlanepoint.size() > 0)&&(xlsl.mvectorlanelinese[0].mvectorlanepoint.size() == xveclp.size()))
|
|
|
+ {
|
|
|
+ iv::lanesectionpoint xvecsp;
|
|
|
+ xvecsp.mvectorlanepoint = xveclp;
|
|
|
+ xlsl.mnsec = xveclp[0].mnLaneSection;
|
|
|
+ nLastSection =xlsl.mnsec;
|
|
|
+ xlsl.mvectorlanelinese.push_back(xvecsp);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ mvectorlaneline.push_back(xlsl);
|
|
|
+ iv::lanesectionpoint xvecsp;
|
|
|
+ xvecsp.mvectorlanepoint = xveclp;
|
|
|
+ xlsl.mnsec = xveclp[0].mnLaneSection;
|
|
|
+ nLastSection =xlsl.mnsec;
|
|
|
+ xlsl.mvectorlanelinese.push_back(xvecsp);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ xline.mstartx = x;
|
|
|
+ xline.mstarty = y*(-1.0);
|
|
|
+ s = s+ sstep;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+// painter->drawPoint((int)(x*mnfac),(int)(y*(-1.0*mnfac)));
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ mvectorlaneline.push_back(xlsl);
|
|
|
+
|
|
|
+ CalcMaxMin();
|
|
|
+
|
|
|
+ mbNeedCalc = false;
|
|
|
+ mfoldcalratio = mfratio;
|
|
|
+
|
|
|
+ return;
|
|
|
+
|
|
|
+ if(mvectorline.size()<0)return;
|
|
|
+ if(mvectorline.size() <= 2)
|
|
|
+ {
|
|
|
+ mtextx = (mvectorline[0].mstartx + mvectorline[0].mendx)/2.0;
|
|
|
+ mtexty = (mvectorline[0].mstarty + mvectorline[0].mendy)/2.0;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ int i;
|
|
|
+ mtextx = mvectorline[0].mendx;
|
|
|
+ mtexty = mvectorline[0].mendy;
|
|
|
+ for(i=0;i<mvectorline.size();i++)
|
|
|
+ {
|
|
|
+ qDebug("run i is %d size is %d ",i,mvectorline.size());
|
|
|
+ if(mvectorline[i].mE >= (mpRoad->GetRoadLength()/2.0))
|
|
|
+ {
|
|
|
+ mtextx = mvectorline[i].mendx;
|
|
|
+ mtexty = mvectorline[i].mendy;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+void roadviewitem::setratio(float ratio)
|
|
|
+{
|
|
|
+ mfratio = ratio;
|
|
|
+}
|
|
|
+
|
|
|
+void roadviewitem::CalcPoints(iv::lineviewdata *plinedata)
|
|
|
+{
|
|
|
+ float fwidth = mfwidth * mfratio;
|
|
|
+ double fhdg = geofit::CalcHdg(plinedata->mstartx,plinedata->mstarty,plinedata->mendx,plinedata->mendy);
|
|
|
+ plinedata->mPoints[0].setX(plinedata->mstartx + fwidth * cos(fhdg -M_PI/2.0)/2.0 );
|
|
|
+ plinedata->mPoints[0].setY((plinedata->mstarty + fwidth * sin(fhdg -M_PI/2.0)/2.0 )*(1.0));
|
|
|
+ plinedata->mPoints[1].setX(plinedata->mendx + fwidth * cos(fhdg -M_PI/2.0)/2.0 );
|
|
|
+ plinedata->mPoints[1].setY((plinedata->mendy + fwidth * sin(fhdg -M_PI/2.0)/2.0 )*(1.0));
|
|
|
+ plinedata->mPoints[2].setX(plinedata->mendx + fwidth * cos(fhdg +M_PI/2.0)/2.0 );
|
|
|
+ plinedata->mPoints[2].setY((plinedata->mendy + fwidth * sin(fhdg +M_PI/2.0)/2.0 )*(1.0));
|
|
|
+ plinedata->mPoints[3].setX(plinedata->mstartx + fwidth * cos(fhdg +M_PI/2.0)/2.0 );
|
|
|
+ plinedata->mPoints[3].setY((plinedata->mstarty + fwidth * sin(fhdg +M_PI/2.0)/2.0 )*(1.0));
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+void roadviewitem::CalcMaxMin()
|
|
|
+{
|
|
|
+ if(mvectorline.size()<1)return;
|
|
|
+ mfxmax = mvectorline[0].mstartx;
|
|
|
+ mfxmin = mvectorline[0].mstartx;
|
|
|
+ mfymax = mvectorline[0].mstarty;
|
|
|
+ mfymin = mvectorline[0].mstarty;
|
|
|
+ int i;
|
|
|
+ int nsize = mvectorline.size();
|
|
|
+ if(nsize < 1)return;
|
|
|
+ mtextx = mvectorline[0].mendx;
|
|
|
+ mtexty = mvectorline[0].mendy;
|
|
|
+ bool bFindTextPos = false;
|
|
|
+ for(i=0;i<nsize;i++)
|
|
|
+ {
|
|
|
+ double x,y;
|
|
|
+ x = mvectorline[i].mstartx;
|
|
|
+ y = mvectorline[i].mstarty;
|
|
|
+ if(mfxmin> x)mfxmin = x;
|
|
|
+ if(mfymin > y)mfymin = y;
|
|
|
+ if(mfxmax < x)mfxmax = x;
|
|
|
+ if(mfymax < y)mfymax = y;
|
|
|
+ x = mvectorline[i].mendx;
|
|
|
+ y = mvectorline[i].mendy;
|
|
|
+ if(mfxmin> x)mfxmin = x;
|
|
|
+ if(mfymin > y)mfymin = y;
|
|
|
+ if(mfxmax < x)mfxmax = x;
|
|
|
+ if(mfymax < y)mfymax = y;
|
|
|
+
|
|
|
+ if(bFindTextPos == false)
|
|
|
+ {
|
|
|
+// double xE = mvectorline[i].mE;
|
|
|
+ if(mvectorline[i].mE >= (mpRoad->GetRoadLength()/2.0))
|
|
|
+ {
|
|
|
+ mtextx = mvectorline[i].mendx;
|
|
|
+ mtexty = mvectorline[i].mendy;
|
|
|
+ bFindTextPos = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void roadviewitem::setmark(bool bMark)
|
|
|
+{
|
|
|
+ mbMark = bMark;
|
|
|
+}
|
|
|
+
|
|
|
+Road * roadviewitem::GetRoad()
|
|
|
+{
|
|
|
+ return mpRoad;
|
|
|
+}
|
|
|
+
|
|
|
+void roadviewitem::setlaneshow(bool bShow)
|
|
|
+{
|
|
|
+ mbShowLane = bShow;
|
|
|
+ mbNeedCalc = true;
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+void roadviewitem::setroadidshow(bool bShow)
|
|
|
+{
|
|
|
+ mbShowRoadID = bShow;
|
|
|
+// mbNeedCalc = true;
|
|
|
+}
|
|
|
+
|
|
|
+void roadviewitem::setlineshow(bool bShow)
|
|
|
+{
|
|
|
+ mbShowLine = bShow;
|
|
|
+}
|
