along/secondo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
secondo/Algebras/Network2/Network2Algebra.cpp
along dfd1e74548 firs commit
2026-01-23 17:03:45 +08:00

11227 lines
353 KiB
C++
Raw Permalink Blame History

/*
This file is part of SECONDO.
Copyright (C) 2004, University in Hagen, Department of Computer Science,
Database Systems for New Applications.
SECONDO is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
SECONDO is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with SECONDO; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//paragraph [1] Title: [{\Large \bf \begin{center}] [\end{center}}]
//paragraph [10] Footnote: [{\footnote{] [}}]
1 Implementation of Algebra Network
March 2004 Victor Almeida
Mai-Oktober 2007 Martin Scheppokat
February 2008 - Simone Jandt
October 2008 - Jianqiu Xu
April-Mai 2011 - Nina Wrede
1.1 Defines, includes, and constants
*/
#include <sstream>
#include <time.h>
#include <map>
#include <iterator>
#include "Algebras/TupleIdentifier/TupleIdentifier.h"
#include "Algebras/Relation-C++/RelationAlgebra.h"
#include "Algebras/BTree/BTreeAlgebra.h"
#include "Algebras/RTree/RTreeAlgebra.h"
#include "Tools/Flob/DbArray.h"
#include "Tools/Flob/Flob.h"
#include "Algebras/Spatial/SpatialAlgebra.h"
#include "Network2Algebra.h"
#include "Algebras/Rectangle/RectangleAlgebra.h"
#include "StandardTypes.h"
#include "Algebra.h"
#include "Messages.h"
#include "Network2Manager.h"
#include "NestedList.h"
#include "NList.h"
#include "QueryProcessor.h"
#include "AlgebraManager.h"
#include "ListUtils.h"
#include "TypeMapUtils.h"
using namespace network2;
using namespace std;
extern NestedList* nl;
extern QueryProcessor* qp;
static map<int,string> *netList;
/*
2 Helping structs, methods and classes
Sending a message via the message-center
*/
void sendMessage ( string in_strMessage )
{
// Get message-center and initialize message-list
static MessageCenter* xMessageCenter= MessageCenter::GetInstance();
NList xMessage;
xMessage.append ( NList ( "error" ) );
xMessage.append ( NList().textAtom ( in_strMessage ) );
xMessageCenter->Send (nl, xMessage.listExpr() );
}
/*
Computes a spatial BoundingBox of a RouteInterval
*/
Rectangle<2> RouteInterval::BoundingBox ( Network* pNetwork,
const Geoid* geoid /*=0*/ ) const
{
if(geoid){
cerr << __PRETTY_FUNCTION__ << ": Spherical geometry not implemented."
<< endl;
assert( !geoid ); // TODO: implement spherical geometry case
}
if ( AlmostEqual ( m_dStart , m_dEnd ) )
{
Point *p = ( GPoint ( true, pNetwork->GetId(), m_iRouteId,
m_dStart ) ).ToPoint ( pNetwork );
double minMax[] = {p->GetX(), p->GetX(), p->GetY(), p->GetY()};
Rectangle<2> bbox = Rectangle<2> ( true,minMax);
p->DeleteIfAllowed();
return bbox;
}
else
{
SimpleLine *line = new SimpleLine ( 0 );
pNetwork->GetLineValueOfRouteInterval ( this, line );
if ( !line->IsEmpty() )
{
Rectangle<2> res = line->BoundingBox();
line->DeleteIfAllowed();
return res;
}
else
{
line->DeleteIfAllowed();
Point *p1 = ( GPoint ( true, pNetwork->GetId(), m_iRouteId,
m_dStart ) ).ToPoint ( pNetwork );
Point *p2 = ( GPoint ( true, pNetwork->GetId(), m_iRouteId,
m_dEnd ) ).ToPoint ( pNetwork );
double minMax[] = {min ( p1->GetX(), p2->GetX() ),
max ( p1->GetX(), p2->GetX() ),
min ( p1->GetY(), p2->GetY() ),
max ( p1->GetY(), p2->GetY() ) };
Rectangle<2> bbox = Rectangle<2> ( true,minMax);
p1->DeleteIfAllowed();
p2->DeleteIfAllowed();
return bbox;
}
}
}
/*
~searchRouteInterval~
Method for binary search after a route interval in a sorted ~GLine~. O(log n).
Used for example by operator ~inside~.
*/
bool searchRouteInterval ( GPoint *pGPoint, GLine *&pGLine, size_t low,
size_t high )
{
RouteInterval rI;
if ( low <= high )
{
size_t mid = ( high + low ) / 2;
int imid = mid;
if ( ( imid < 0 ) || ( imid >= pGLine->NoOfComponents() ) )
{
return false;
}
else
{
pGLine->Get ( mid, rI );
if ( rI.GetRouteId() < pGPoint->GetRouteId() )
{
return searchRouteInterval ( pGPoint, pGLine, mid+1, high );
}
else
{
if ( rI.GetRouteId() > pGPoint->GetRouteId() )
{
return searchRouteInterval ( pGPoint, pGLine, low, mid-1 );
}
else
{
if ( fabs ( pGPoint->GetPosition() - rI.GetStartPos() ) < 0.01 ||
fabs ( pGPoint->GetPosition() - rI.GetEndPos() ) < 0.01 )
{
return true;
}
else
{
if ( rI.GetStartPos() > pGPoint->GetPosition() )
{
return searchRouteInterval ( pGPoint, pGLine, low, mid-1 );
}
else
{
if ( rI.GetEndPos() < pGPoint->GetPosition() )
{
return searchRouteInterval ( pGPoint, pGLine, mid+1, high );
}
else
{
return true;
}
}
}
}
}
}
}
return false;
}
/*
Helper struct to store sections which have been visited before. Used in
shortest path implementation of Dijkstras Algorithm.
*/
struct SectTree
{
SectTree() {};
SectTree ( SectTreeEntry *nEntry, SectTree *l = 0, SectTree *r = 0 )
{
value = *nEntry;
left = l;
right = r;
};
~SectTree() {};
/*
Inserts a section into the tree. If the section is already in the insert is
ignored.
*/
void Insert ( SectTreeEntry *nEntry )
{
if ( nEntry->secttid < value.secttid )
{
if ( right != 0 ) right->Insert ( nEntry );
else right = new SectTree ( nEntry,0,0 );
}
else
{
if ( nEntry->secttid > value.secttid )
{
if ( left != 0 ) left->Insert ( nEntry );
else left = new SectTree ( nEntry,0,0 );
}
}
};
/*
Returns a pointer to the node with the given id or 0 if not found.
*/
void Find ( TupleId n, SectTree *result, bool &found )
{
if ( n < value.secttid )
{
if ( right != 0 ) right->Find ( n, result, found );
else
{
found = false;
result = 0;
}
}
else
{
if ( n > value.secttid )
{
if ( left != 0 ) left->Find ( n, result, found );
else
{
found = false;
result = 0;
}
}
else
{
found = true;
result = this;
}
}
};
void CheckSection ( Network *pNetwork, SectTreeEntry n, GPoints &result )
{
vector<DirectedSection> sectList;
sectList.clear();
SectTree *pSectTree = 0;
if ( n.startbool || n.endbool )
{
if ( n.startbool )
{
pNetwork->GetAdjacentSections ( n.secttid, false, sectList );
size_t j = 0;
bool found = true;
while ( j < sectList.size() && found )
{
DirectedSection actSection = sectList[j];
Find ( actSection.GetSectionTid(), pSectTree, found );
}
if ( !found )
result += GPoint ( true, pNetwork->GetId(), n.rid, n.start, None );
}
sectList.clear();
if ( n.endbool )
{
pNetwork->GetAdjacentSections ( n.secttid, true, sectList );
size_t j = 0;
bool found = true;
while ( j < sectList.size() && found )
{
DirectedSection actSection = sectList[j];
Find ( actSection.GetSectionTid(), pSectTree, found );
}
if ( !found ) result+= GPoint ( true, pNetwork->GetId(), n.rid, n.end,
None );
}
sectList.clear();
}
else result += GPoint ( true, pNetwork->GetId(), n.rid, n.end, None );
}
void WriteResult ( Network* pNetwork, GPoints &result, SectTree &secTr )
{
if ( left != 0 ) left->WriteResult ( pNetwork, result, secTr );
if ( right != 0 ) right ->WriteResult ( pNetwork, result, secTr );
secTr.CheckSection ( pNetwork, value, result );
//TODO: Remove duplicate GPoint from Result, which are caused by junction
//problematic
};
void Remove()
{
if ( left != 0 ) left->Remove();
if ( right != 0 ) right->Remove();
delete this;
};
SectTreeEntry value;
SectTree *left, *right;
};
/*
Almost similar to operator ~checkPoint~ but additional returning a difference
value if the point is not exactly on the ~sline~.
Used by operator ~point2gpoint~
*/
bool chkPoint ( SimpleLine *&route, Point point, bool startSmaller, double &pos,
double &difference )
{
bool result = false;
HalfSegment hs;
double k1, k2;
Point left, right;
for ( int i = 0; i < route->Size()-1; i++ )
{
route->Get ( i, hs );
left = hs.GetLeftPoint();
right = hs.GetRightPoint();
Coord xl = left.GetX(),
yl = left.GetY(),
xr = right.GetX(),
yr = right.GetY(),
x = point.GetX(),
y = point.GetY();
if ( ( fabs ( x-xr ) < 0.01 && fabs ( y-yr ) < 0.01 ) ||
( fabs ( x-xl ) < 0.01 && fabs ( y-yl ) < 0.01 ) )
{
difference = 0.0;
result = true;
}
else
{
if ( xl != xr && xl != x )
{
k1 = ( y - yl ) / ( x - xl );
k2 = ( yr - yl ) / ( xr - xl );
if ( ( fabs ( k1-k2 ) < 0.004 ) &&
( ( xl < xr &&
( x > xl || fabs ( x-xl ) < 0.01 ) &&
( x < xr || fabs ( x-xr ) < 0.01 ) ) ||
( xl > xr &&
( x < xl || fabs ( x-xl ) <0.01 ) &&
( x > xr || fabs ( x-xr ) < 0.01 ) ) ) &&
((( yl <= yr &&
( y > yl || fabs ( y-yl ) <0.01 ) &&
( y < yr || fabs ( y-yr ) <0.01 ) ) ||
( yl > yr &&
( y < yl || fabs ( y-yl ) <0.01 ) &&
( y > yr || fabs ( y-yr ) <0.01 ) ) ) ))
{
difference = fabs ( k1-k2 );
result = true;
}
else {result = false;}
}
else
{
if ( ( fabs ( xl - xr ) < 0.01 && fabs ( xl -x ) < 0.01 ) &&
( ( ( yl <= yr &&
( yl < y || fabs (yl-y ) < 0.01 ) &&
( y < yr ||fabs ( y-yr ) <0.01 ) ) ||
( yl > yr &&
( yl > y || fabs ( yl-y ) < 0.01) &&
( y > yr ||fabs ( y-yr ) <0.01 ) ) ) ))
{
difference = 0.0;
result = true;
}
else {result = false;}
}
}
if ( result )
{
LRS lrs;
route->Get ( hs.attr.edgeno, lrs );
route->Get ( lrs.hsPos, hs );
pos = lrs.lrsPos + point.Distance ( hs.GetDomPoint() );
if ( startSmaller != route->GetStartSmaller() )
pos = route->Length() - pos;
if ( fabs ( pos-0.0 ) < 0.01 )
pos = 0.0;
else if ( fabs ( pos-route->Length() ) <0.01 )
pos = route->Length();
return result;
}
}
return result;
}
/*
Almost similar to operator ~chkPoint~ but allowing a greater difference if the
point is not exactly on the ~sline~.
Used by operator ~point2gpoint~
*/
bool chkPoint03 ( SimpleLine *&route, Point point, bool startSmaller,
double &pos, double &difference )
{
bool result = false;
HalfSegment hs;
double k1, k2;
Point left, right;
for ( int i = 0; i < route->Size()-1; i++ )
{
route->Get ( i, hs );
left = hs.GetLeftPoint();
right = hs.GetRightPoint();
Coord xl = left.GetX(),
yl = left.GetY(),
xr = right.GetX(),
yr = right.GetY(),
x = point.GetX(),
y = point.GetY();
if ( ( fabs ( x-xl ) < 0.01 && fabs ( y-yl ) < 0.01 ) ||
( fabs ( x-xr ) < 0.01 && fabs ( y-yr ) < 0.01 ) )
{
difference = 0.0;
result = true;
}
else
{
if ( xl != xr && xl != x )
{
k1 = ( y - yl ) / ( x - xl );
k2 = ( yr - yl ) / ( xr - xl );
if ( ( fabs ( k1-k2 ) < 1.2 ) &&
( ( xl < xr &&
( x > xl || fabs ( x-xl ) < 0.01 ) &&
( x < xr || fabs ( x-xr ) < 0.01 ) ) ||
( xl > xr &&
( x < xl || fabs ( x-xl ) < 0.01 ) &&
( x > xr || fabs ( x-xr ) < 0.01 ) ) ) &&
( ( ( yl < yr || fabs ( yl-yr ) < 0.01 ) &&
( y > yl || fabs (y-yl ) <0.01 ) &&
( y < yr || fabs ( y-yr ) <0.01 ) ) ||
( yl > yr &&
( y < yl || fabs ( y-yl ) <0.01 ) &&
( y > yr || fabs ( y-yr ) <0.01 ) ) ) )
{
difference = fabs ( k1-k2 );
result = true;
}
else {result = false;}
}
else
{
if ( ( fabs ( xl - xr ) < 0.01 && fabs ( xl -x ) < 0.01 ) &&
( ( ( yl < yr|| fabs ( yl-yr ) <0.01 ) &&
( yl < y || fabs (yl-y ) <0.01 ) &&
( y < yr ||fabs ( y-yr ) <0.01 ) ) ||
( yl > yr &&
( yl > y || fabs ( yl-y ) < 0.01) &&
( y > yr ||fabs ( y-yr ) <0.01 ) ) ) )
{
difference = 0.0;
result = true;
}
else {result = false;}
}
}
if ( result )
{
LRS lrs;
route->Get ( hs.attr.edgeno, lrs );
route->Get ( lrs.hsPos, hs );
pos = lrs.lrsPos + point.Distance ( hs.GetDomPoint() );
if ( startSmaller != route->GetStartSmaller() )
pos = route->Length() - pos;
if ( fabs ( pos-0.0 ) < 0.01 )
pos = 0.0;
else if ( fabs ( pos-route->Length() ) <0.01 )
pos = route->Length();
return result;
}
}
return result;
}
bool lastchkPoint03 ( SimpleLine *&route, Point point, bool startSmaller,
double &pos, double &difference )
{
bool result = false;
HalfSegment hs;
double k1, k2;
Point left, right;
for ( int i = 0; i < route->Size()-1; i++ )
{
route->Get ( i, hs );
left = hs.GetLeftPoint();
right = hs.GetRightPoint();
Coord xl = left.GetX(),
yl = left.GetY(),
xr = right.GetX(),
yr = right.GetY(),
x = point.GetX(),
y = point.GetY();
if ( ( fabs ( x-xl ) < 0.01 && fabs ( y-yl ) < 0.01 ) ||
( fabs ( x-xr ) < 0.01 && fabs ( y-yr ) < 0.01 ) )
{
difference = 0.0;
result = true;
}
else
{
if ( xl != xr && xl != x )
{
k1 = ( y - yl ) / ( x - xl );
k2 = ( yr - yl ) / ( xr - xl );
if ( ( ( xl < xr &&
( x > xl || fabs ( x-xl ) < 0.1 ) &&
( x < xr || fabs ( x-xr ) < 0.01 ) ) ||
( xl > xr &&
( x < xl || fabs ( x-xl ) <0.01 ) &&
( x > xr || fabs ( x-xr ) < 0.01) ) ) &&
( ( ( yl < yr || fabs ( yl-yr ) < 0.01 ) &&
( y > yl || fabs (y-yl ) < 0.01 ) &&
( y < yr || fabs ( y-yr ) < 0.01 ) ) ||
( yl > yr &&
( y < yl || fabs ( y-yl ) <0.01 ) &&
( y > yr || fabs ( y-yr ) <0.01 ) ) ) )
{
difference = fabs ( k1-k2 );
result = true;
}
else {result = false;}
}
else
{
if ( ( fabs ( xl - xr ) < 0.01 && fabs ( xl -x ) < 0.01 ) &&
( ( ( yl < yr|| fabs ( yl-yr ) <0.01 ) &&
( yl < y || fabs ( yl-y ) <0.01 ) &&
( y < yr ||fabs ( y-yr ) <0.01 ) ) ||
( yl > yr &&
( yl > y || fabs ( yl-y ) < 0.01 ) &&
( y > yr ||fabs ( y-yr ) <0.01 ) ) ) )
{
difference = 0.0;
result = true;
}
else {result = false;}
}
}
if ( result )
{
LRS lrs;
route->Get ( hs.attr.edgeno, lrs );
route->Get ( lrs.hsPos, hs );
pos = lrs.lrsPos + point.Distance ( hs.GetDomPoint() );
if ( startSmaller != route->GetStartSmaller() )
pos = route->Length() - pos;
if ( pos < 0.0 || fabs ( pos - 0.0 ) < 0.01 )
pos = 0.0;
else if ( pos > route->Length() || fabs ( pos - route->Length() ) < 0.01 )
pos = route->Length();
return result;
}
}
return result;
}
/*
Returns true if a ~point~ is part of a ~sline~, false elsewhere. If the point
is part of the sline his distance from the start is computed also. Used by
operator ~line2gline~.
*/
bool checkPoint ( SimpleLine *&route, Point point, bool startSmaller,
double &pos )
{
bool result = false;
HalfSegment hs;
double k1, k2;
Point left, right;
for ( int i = 0; i < route->Size()-1; i++ )
{
route->Get ( i, hs );
left = hs.GetLeftPoint();
right = hs.GetRightPoint();
Coord xl = left.GetX(),
yl = left.GetY(),
xr = right.GetX(),
yr = right.GetY(),
x = point.GetX(),
y = point.GetY();
if ( ( fabs ( x-xr ) < 0.01 && fabs ( y-yr ) < 0.01 ) ||
( fabs ( x-xl ) < 0.01 && fabs ( y-yl ) < 0.01 ) )
{
result = true;
}
else
{
if ( xl != xr && xl != x )
{
k1 = ( y - yl ) / ( x - xl );
k2 = ( yr - yl ) / ( xr - xl );
if ( ( fabs ( k1-k2 ) < 0.004 ) &&
( ( xl < xr &&
( x > xl || fabs ( x-xl ) < 0.01 ) &&
( x < xr || fabs ( x-xr ) < 0.01 ) ) ||
( xl > xr &&
( x < xl || fabs ( x-xl ) < 0.01 ) &&
( x > xr || fabs ( x-xr ) < 0.01 ) ) ) &&
( ( ( yl < yr || fabs ( yl-yr ) < 0.01 ) &&
( y > yl || fabs ( y-yl ) < 0.01 ) &&
( y < yr || fabs ( y-yr ) < 0.01 ) ) ||
( yl > yr &&
( y < yl || fabs ( y-yl ) < 0.01 ) &&
( y > yr || fabs ( y-yr ) < 0.01 ) ) ) )
{
result = true;
}
else {result = false;}
}
else
{
if ( ( fabs ( xl - xr ) < 0.01 && fabs ( xl -x ) < 0.01 ) &&
( ( ( yl < yr|| fabs ( yl-yr ) < 0.01 ) &&
( yl < y || fabs ( yl-y ) <0.01 ) &&
( y < yr ||fabs ( y-yr ) <0.01 ) ) ||
( yl > yr &&
( yl > y || fabs ( yl-y ) < 0.01) &&
( y > yr ||fabs ( y-yr ) <0.01 ) ) ) )
{
result = true;
}
else {result = false;}
}
}
if ( result )
{
LRS lrs;
route->Get ( hs.attr.edgeno, lrs );
route->Get ( lrs.hsPos, hs );
pos = lrs.lrsPos + point.Distance ( hs.GetDomPoint() );
if ( startSmaller != route->GetStartSmaller() )
pos = route->Length() - pos;
if ( fabs ( pos-0.0 ) < 0.01 )
pos = 0.0;
else if ( fabs ( pos-route->Length() ) <0.01 )
pos = route->Length();
return result;
}
}
return result;
};
/*
Precondition: ~GLine~ is sorted.
Returns true if there is a ~RouteInterval~ in the sorted ~GLine~ which
intersects with the given ~RouteInterval~ false elsewhere.
Used by operator ~intersects~
*/
bool searchUnit ( GLine *pGLine, size_t low, size_t high,
RouteInterval pRi )
{
assert ( pGLine->IsSorted() );
RouteInterval rI;
if ( low <= high )
{
size_t mid = ( high + low ) / 2;
int imid = mid;
if ( ( mid < 0 ) || ( imid >= pGLine->NoOfComponents() ) )
{
return false;
}
else
{
pGLine->Get ( mid, rI );
if ( rI.GetRouteId() < pRi.GetRouteId() )
{
return searchUnit ( pGLine, mid+1, high, pRi );
}
else
{
if ( rI.GetRouteId() > pRi.GetRouteId() )
{
return searchUnit ( pGLine, low, mid-1, pRi );
}
else
{
if ( rI.GetStartPos() > pRi.GetEndPos() )
{
return searchUnit ( pGLine, low, mid-1, pRi );
}
else
{
if ( rI.GetEndPos() < pRi.GetStartPos() )
{
return searchUnit ( pGLine, mid+1, high, pRi );
}
else
{
return true;
}
}
}
}
}
}
else
{
return false;
}
return false;
}
/*
class ~GPointList~
Used by the operator ~polygpoint~. Computes and stores the resulting ~GPoints~
for the resulting ~stream~ of ~GPoint~.
*/
class GPointList
{
public:
/*
The constructor creates a GPointList from a given gpoint.
*/
GPointList ( GPoint *gp, Network *pNetwork ) :
aliasGP ( 0 )
{
lastPos = 0;
aliasGP.clean();
aliasGP.Append ( *gp );
vector<JunctionSortEntry> xJunctions;
xJunctions.clear();
if ( pNetwork != 0 )
{
CcInt iRouteId ( true, gp->GetRouteId() );
pNetwork->GetJunctionsOnRoute ( &iRouteId, xJunctions );
bool found = false;
JunctionSortEntry pCurrJunction;
size_t i = 0;
while ( !found && i < xJunctions.size() )
{
pCurrJunction = xJunctions[i];
if ( fabs ( pCurrJunction.GetRouteMeas() - gp->GetPosition() ) < 0.01
)
{
found = true;
GPoint test ( true, gp->GetNetworkId(),
pCurrJunction.GetOtherRouteId(),
pCurrJunction.GetOtherRouteMeas(),
None );
aliasGP.Append ( test );
}
i++;
}
while ( found && i < xJunctions.size() )
{
pCurrJunction = xJunctions[i];
if ( fabs ( pCurrJunction.GetRouteMeas() - gp->GetPosition() ) <0.01 )
{
GPoint test ( true, gp->GetNetworkId(),
pCurrJunction.GetOtherRouteId(),
pCurrJunction.GetOtherRouteMeas(),
None );
aliasGP.Append ( test );
}
else
{
found = false;
}
i++;
}
for ( unsigned int i=0;i<xJunctions.size();i++ )
{
xJunctions[i].m_pJunction->DeleteIfAllowed();
}
xJunctions.clear();
}
}
~GPointList() {}
/*
~NextGPoint~
This function returns the next GPoint from the GPointList.
If there is no more GPoint in the List the result will be
0. This function creates a new GPoint instance via the new
operator. The caller of this function has to ensure the
deletion of this object.
*/
const GPoint NextGPoint()
{
GPoint pAktGPoint;
if ( lastPos >= aliasGP.Size() || lastPos < 0 )
{
pAktGPoint.SetDefined ( false );
}
else
{
aliasGP.Get ( lastPos, pAktGPoint );
lastPos++;
}
return pAktGPoint;
}
private:
DbArray<GPoint> aliasGP;
int lastPos;
};
/*
class ~RectangleList~
Almost similar to ~GPointList~. But storing rectangles representing route
intervals of a ~gline~. Used by operator ~routeintervals~ to create a ~stream~
of ~rectangles~.
*/
class RectangleList
{
public:
/*
~Constructor~
Creates a RectangleList from a given gline.
*/
RectangleList ( GLine *gl ) :
aliasRectangleList ( 0 )
{
RouteInterval ri;
lastPos = 0;
aliasRectangleList.clean();
for ( int i = 0 ; i < gl->NoOfComponents(); i++ )
{
gl->Get ( i, ri );
double minMax[] = {( double ) ri.GetRouteId(),
( double ) ri.GetRouteId(),
min ( ri.GetStartPos(),ri.GetEndPos() ),
max ( ri.GetStartPos(), ri.GetEndPos() ) };
Rectangle<2> elem ( true, minMax);
aliasRectangleList.Append ( elem );
}
}
~RectangleList() {}
/*
~NextRectangle~
This function returns the next rectangle from the RectangleList.
If there is no more route interval in the List the result will be
0. This function creates a new Rectangle instance via the new
operator. The caller of this function has to ensure the
deletion of this object.
*/
const Rectangle<2> NextRectangle()
{
Rectangle<2> pAktRectangle;
if ( lastPos >= aliasRectangleList.Size() || lastPos < 0 )
{
pAktRectangle.SetDefined ( false );
}
else
{
aliasRectangleList.Get ( lastPos, pAktRectangle );
lastPos++;
}
return pAktRectangle;
}
private:
DbArray<Rectangle<2> > aliasRectangleList;
int lastPos;
};
/*
~struct RIStack~
Used to build compressed shortestpath ~gline~ values.
The ~RouteIntervals~ of the shortest path computation are pushed to a stack to
first the end section. Last the first section of the path. So they can be
returned in the sequence they are needed in the path.
When the stack is returned to the resulting ~gline~ it is checked if the
~RouteInterval~s on the stack can be connected to bigger parts. This is always
possible if the shortest path follows the same route for more than one section.
*/
struct RIStack
{
RIStack() {};
RIStack ( int ri,double pos1, double pos2, RIStack* next = 0 )
{
m_iRouteId = ri;
m_dStart = pos1;
m_dEnd = pos2;
m_next = next;
};
~RIStack() {};
void Push ( int rid, double pos1, double pos2, RIStack *&first )
{
RIStack *actElem = new RIStack ( rid, pos1, pos2, this );
first = actElem;
};
void StackToGLine ( GLine *gline )
{
int actRId = m_iRouteId;
double actStartPos = m_dStart;
double actEndPos = m_dEnd;
RIStack *actElem = this->m_next;
while ( actElem != 0 )
{
if ( actRId == actElem->m_iRouteId &&
AlmostEqual ( actEndPos,actElem->m_dStart ) )
{
actEndPos = actElem->m_dEnd;
}
else
{
gline->AddRouteInterval ( actRId, actStartPos, actEndPos );
actRId = actElem->m_iRouteId;
actStartPos = actElem->m_dStart;
actEndPos = actElem->m_dEnd;
}
actElem = actElem->m_next;
}
gline->AddRouteInterval ( actRId, actStartPos, actEndPos );
};
void RemoveStack()
{
if ( m_next != 0 ) m_next->RemoveStack();
delete this;
};
int m_iRouteId;
double m_dStart, m_dEnd;
RIStack *m_next;
};
/*
Class PQEntry used for priority Queue in Dijkstras Algorithm for shortest path
computing between two gpoint.
*/
class PQEntry
{
public:
PQEntry() {}
PQEntry ( TupleId aktID, double distance, bool upDown,
TupleId beforeID )
{
sectID = aktID;
distFromStart = distance;
upDownFlag = upDown;
beforeSectID = beforeID;
meas1 =0;
meas2 =0;
rid = 0;
costFromStart = 0.0;
}
PQEntry(TupleId in_aktID, double in_distance, bool in_upDown,
TupleId in_beforeID, double in_meas1, double in_meas2,
int in_rid, double in_costs=0.0 ):
sectID(in_aktID),
distFromStart(in_distance),
upDownFlag(in_upDown),
beforeSectID(in_beforeID),
meas1(in_meas1),
meas2(in_meas2),
rid(in_rid),
costFromStart(in_costs)
{
}
PQEntry ( PQEntry &e )
{
sectID = e.sectID;
distFromStart = e.distFromStart;
upDownFlag = e.upDownFlag;
beforeSectID = e.beforeSectID;
meas1 = e.meas1;
meas2 = e.meas2;
rid = e.rid;
costFromStart = e.costFromStart;
}
PQEntry ( const PQEntry &e )
{
sectID = e.sectID;
distFromStart = e.distFromStart;
upDownFlag = e.upDownFlag;
beforeSectID = e.beforeSectID;
meas1 = e.meas1;
meas2 = e.meas2;
rid = e.rid;
costFromStart = e.costFromStart;
}
~PQEntry() {}
TupleId sectID;
double distFromStart;
bool upDownFlag;
TupleId beforeSectID;
double meas1;
double meas2;
int rid;
double costFromStart;
};
/*
struct sectIDTree stores the PQEntrys by section ID with identification flag
for the PrioQueue-Array.
An arrayIndex from max integer means not longer in PrioQ and already visited.
*/
struct SectIDTree
{
SectIDTree() {};
SectIDTree ( TupleId sectIdent, TupleId beforeSectIdent, bool upDown,
int arrayIndex,
SectIDTree *l = 0,SectIDTree *r = 0 )
{
sectID = sectIdent;
beforeSectId = beforeSectIdent;
upDownFlag = upDown;
index = arrayIndex;
left = l;
right = r;
};
~SectIDTree() {};
SectIDTree* Find ( TupleId sectIdent )
{
if ( sectID > sectIdent )
{
if ( left != 0 ) return left->Find ( sectIdent );
else
{
return this;
}
}
else
{
if ( sectID < sectIdent )
{
if ( right != 0 ) return right->Find ( sectIdent );
else
{
return this;
}
}
else
{
return this;
}
}
};
void Remove()
{
if ( left != 0 ) left->Remove();
if ( right != 0 ) right->Remove();
delete this;
};
bool Insert ( TupleId sectIdent, TupleId beforeSectIdent, bool upDownFlag,
int arrayIndex,SectIDTree *&pointer )
{
pointer = Find ( sectIdent );
if ( pointer->sectID != sectIdent )
{
if ( pointer->sectID > sectIdent )
{
pointer->left = new SectIDTree ( sectIdent, beforeSectIdent, upDownFlag,
arrayIndex );
pointer = pointer->left;
return true;
}
else
{
if ( pointer->sectID < sectIdent )
{
pointer->right = new SectIDTree ( sectIdent, beforeSectIdent,
upDownFlag, arrayIndex );
pointer = pointer->right;
return true;
}
else
{
//should never be reached
return false;
}
}
}
else
{
return false;
}
};
void SetIndex ( TupleId sectIdent, int arrayIndex )
{
Find ( sectIdent )->index = arrayIndex;
};
void SetIndex ( int arrayIndex )
{
index = arrayIndex;
};
int GetIndex ( TupleId sectIdent )
{
return Find ( sectIdent )->index;
};
void SetBeforeSectId ( TupleId sectIdent, TupleId before )
{
Find ( sectIdent )->beforeSectId = before;
};
void SetBeforeSectId ( TupleId before )
{
beforeSectId = before;
};
TupleId sectID;
TupleId beforeSectId;
bool upDownFlag;
int index;
SectIDTree *left, *right;
};
/*
struct Priority Queue for Dijkstras Algorithm of shortest path computing between
two gpoint.
*/
struct PrioQueue
{
PrioQueue() {};
PrioQueue ( int n ) : prioQ ( 0 ) {firstFree = 0;};
~PrioQueue() {};
/*
If a point is reached second time and the distance of the second way is
smaller than on the path he has been found before. Its distance value and its
position in the priority queue must be corrected.
*/
void CorrectPosition ( int checkX, const PQEntry nElem, SectIDTree *pSection,
SectIDTree *sectTree, bool calcCost=false )
{
int act = checkX;
PQEntry test;
bool found = false;
while ( checkX >= 0 && !found )
{
if ( ( act % 2 ) == 0 ) checkX = ( act-2 ) / 2;
else checkX = ( act -1 ) / 2;
if ( checkX >= 0 )
{
prioQ.Get ( checkX, test );
if(calcCost){
if ( test.costFromStart > nElem.costFromStart )
{
PQEntry help = test;
prioQ.Put ( checkX, nElem );
pSection->SetIndex ( checkX );
prioQ.Put ( act, help );
SectIDTree *thelp = sectTree->Find ( help.sectID );
thelp->SetIndex ( act );
act = checkX;
}
else
{
found = true;
}
}
else {
if ( test.distFromStart > nElem.distFromStart )
{
PQEntry help = test;
prioQ.Put ( checkX, nElem );
pSection->SetIndex ( checkX );
prioQ.Put ( act, help );
SectIDTree *thelp = sectTree->Find ( help.sectID );
thelp->SetIndex ( act );
act = checkX;
}
else
{
found = true;
}
}
}
else
{
found = true;
}
}
};
void Insert ( PQEntry nElem, SectIDTree *sectTree, bool calcCost=false )
{
SectIDTree *pSection = sectTree->Find ( nElem.sectID );
PQEntry old;
if ( pSection->sectID == nElem.sectID )
{
if ( pSection->index != numeric_limits<int>::max() )
{
prioQ.Get ( pSection->index, old );
if(calcCost)
{
if ( nElem.costFromStart < old.costFromStart )
{
prioQ.Put ( pSection->index, nElem );
pSection->SetBeforeSectId ( nElem.beforeSectID );
CorrectPosition( pSection->index, nElem, pSection, sectTree,true);
}
}
else
{
if ( nElem.distFromStart < old.distFromStart )
{
prioQ.Put ( pSection->index, nElem );
pSection->SetBeforeSectId ( nElem.beforeSectID );
CorrectPosition(pSection->index, nElem, pSection, sectTree,false);
}
}
}
}
else
{
prioQ.Put ( firstFree, nElem );
sectTree->Insert ( nElem.sectID, nElem.beforeSectID, nElem.upDownFlag,
firstFree, pSection );
CorrectPosition ( firstFree, nElem, pSection ,sectTree,calcCost );
firstFree++;
}
}
PQEntry* GetAndDeleteMin ( SectIDTree *sectTree, bool calcCost=false)
{
if ( firstFree > 0 )
{
PQEntry result, last, test1, test2;
prioQ.Get ( 0,result );
PQEntry *retValue = new PQEntry ( result.sectID,
result.distFromStart,
result.upDownFlag,
result.beforeSectID,
result.meas1,
result.meas2,
result.rid,
result.costFromStart);
SectIDTree *tRet = sectTree->Find ( result.sectID );
tRet->SetIndex ( numeric_limits<int>::max() );
prioQ.Get ( firstFree-1, last );
prioQ.Put ( 0, last );
firstFree--;
SectIDTree *pSection = sectTree->Find ( last.sectID );
pSection->SetIndex ( 0 );
int act = 0;
int checkX = 0;
bool found = false;
while ( checkX < firstFree && !found )
{
checkX = 2*act + 1;
if ( checkX < firstFree-1 )
{
prioQ.Get ( checkX, test1 );
prioQ.Get ( checkX+1, test2 );
if(calcCost)
{
if ( test1.costFromStart < last.costFromStart ||
test2.costFromStart < last.costFromStart )
{
if ( test1.costFromStart <= test2.costFromStart )
{
PQEntry help = test1;
prioQ.Put ( checkX, last );
pSection->SetIndex ( checkX );
prioQ.Put ( act, help );
SectIDTree *thelp = sectTree->Find ( help.sectID );
thelp->SetIndex ( act );
act = checkX;
}
else
{
PQEntry help = test2;
prioQ.Put ( checkX+1, last );
pSection->SetIndex ( checkX+1 );
prioQ.Put ( act, help );
SectIDTree *thelp = sectTree->Find ( help.sectID );
thelp->SetIndex ( act );
act = checkX+1;
}
}
else
{
found = true;
}
}
else
{
if ( test1.distFromStart < last.distFromStart ||
test2.distFromStart < last.distFromStart )
{
if ( test1.distFromStart <= test2.distFromStart )
{
PQEntry help = test1;
prioQ.Put ( checkX, last );
pSection->SetIndex ( checkX );
prioQ.Put ( act, help );
SectIDTree *thelp = sectTree->Find ( help.sectID );
thelp->SetIndex ( act );
act = checkX;
}
else
{
PQEntry help = test2;
prioQ.Put ( checkX+1, last );
pSection->SetIndex ( checkX+1 );
prioQ.Put ( act, help );
SectIDTree *thelp = sectTree->Find ( help.sectID );
thelp->SetIndex ( act );
act = checkX+1;
}
}
else
{
found = true;
}
}
}
else
{
if ( checkX != 0 && checkX == firstFree-1 )
{
prioQ.Get ( checkX, test1 );
if(calcCost){
if ( test1.costFromStart < last.costFromStart )
{
PQEntry help = test1;
prioQ.Put ( checkX, last );
pSection->SetIndex ( checkX );
prioQ.Put ( act, help );
SectIDTree *thelp = sectTree->Find ( help.sectID );
thelp->SetIndex ( act );
act = checkX;
}
else
{
found = true;
}
}
else
{
if ( test1.distFromStart < last.distFromStart )
{
PQEntry help = test1;
prioQ.Put ( checkX, last );
pSection->SetIndex ( checkX );
prioQ.Put ( act, help );
SectIDTree *thelp = sectTree->Find ( help.sectID );
thelp->SetIndex ( act );
act = checkX;
}
else
{
found = true;
}
}
}
}
}
return retValue;
}
else
{
return 0;
}
}
void Clear()
{
prioQ.clean();
firstFree = 0;
}
bool IsEmpty()
{
if ( firstFree == 0 ) return true;
else return false;
}
void Destroy()
{
prioQ.Destroy();
}
DbArray<PQEntry> prioQ;
int firstFree;
};
/*
3 Class Definitions
3.1 class ~Network~
3.1.1 Network relations
*/
string Network::routesTypeInfo =
"(rel (tuple ((Id int) (Length real) (Curve sline) "
"(Dual bool) (StartsSmaller bool))))";
string Network::routesInternalTypeInfo =
"(rel (tuple ((Id int) (Length real) (Curve sline) "
"(Dual bool) (StartsSmaller bool) (Startposid int))))";
string Network::routesBTreeTypeInfo =
"(btree (tuple ((Id int) (Length real) (Curve sline) "
"(Dual bool) (StartsSmaller bool) (Startposid int) )) int)";
string Network::routesRTreeTypeInfo =
"(rtree (tuple((Id int)(Length real)(Curve sline)(Dual bool)"
"(StartsSmaller bool) (Startposid int) )) sline FALSE)";
string Network::junctionsTypeInfo =
"(rel (tuple ((R1id int) (Meas1 real) (R2id int) "
"(Meas2 real) (Cc int))))";
/*string Network::junctionsInternalTypeInfo =
"(rel (tuple ((r1id int) (meas1 real) (r2id int) "
"(meas2 real) (cc int) (pos point) (r1rc tid) (r2rc tid) "
"(sauprc tid) (sadownrc tid)(sbuprc tid) (sbdownrc tid))))";*/
string Network::junctionsInternalTypeInfo =
"(rel (tuple ((R1id int) (Meas1 real) (R2id int) "
"(Meas2 real) (Cc int) (Loc point) (R1rc tid) (R2rc tid) "
"(Sauprc tid) (Sadownrc tid)(Sbuprc tid) (Sbdownrc tid))))";
string Network::junctionsBTreeTypeInfo =
"(btree (tuple ((R1id int) (Meas1 real) (R2id int) "
"(Meas2 real) (Cc int) (Loc point) (R1rc tid) (R2rc tid) "
"(Sauprc tid) (Sadownrc tid)(Sbuprc tid) (Sbdownrc tid))) int)";
string Network::sectionsInternalTypeInfo =
"(rel (tuple ((Rid int) (Meas1 real) (Meas2 real) (Dual bool)"
"(Curve sline)(CurveStartsSmaller bool) (Rrc tid) (Sid int) "
"(Pnoup int) (Pnodown int) (Slotup int) (Slotdown int) "
"(Cost real) (Time real))))";
string Network::sectionsBTreeTypeInfo =
"(btree (tuple ((Rid int) (Meas1 real) (Meas2 real) (Dual bool)"
"(Curve sline)(CurveStartsSmaller bool) (Rrc tid) (Sid int) "
"(Pnoup int) (Pnodown int) (Slotup int) (Slotdown int) "
"(Cost real) (Time real) )) int)";
string Network::distancestorageTypeInfo =
"(rel (tuple((J1 tid)(J2 tid)(Dist real)(Sp gline))))";
/*
2.1.2 Constructors and destructors class ~Network~
*/
Network::Network() :
m_iId ( 0 ),
m_bDefined ( false ),
m_pRoutes ( 0 ),
m_pJunctions ( 0 ),
m_pSections ( 0 ),
m_pBTreeRoutes ( 0 ),
m_pBTreeRoutesByStartposId( 0 ),
m_pRTreeRoutes ( 0 ),
m_pBTreeJunctionsByRoute1 ( 0 ),
m_pBTreeJunctionsByRoute2 ( 0 ),
m_xAdjacencyList ( 0 ),
m_xSubAdjacencyList ( 0 ),
m_pBTreeSectionsByRoute ( 0 ),
m_pBTreeSections (0)
/*alldistance(0)*/ //only for experimental use with network distances
{
}
Network::Network ( SmiRecord& in_xValueRecord,
size_t& inout_iOffset,
const ListExpr in_xTypeInfo ):
m_xAdjacencyList(0),
m_xSubAdjacencyList(0)
{
// Read network id
in_xValueRecord.Read ( &m_iId, sizeof ( int ), inout_iOffset );
inout_iOffset += sizeof ( int );
// Open routes
ListExpr xType;
nl->ReadFromString ( routesInternalTypeInfo, xType );
ListExpr xNumericType = SecondoSystem::GetCatalog()->NumericType ( xType );
m_pRoutes = Relation::Open ( in_xValueRecord,
inout_iOffset,
xNumericType );
if ( !m_pRoutes )
{
return;
}
// Open junctions
nl->ReadFromString ( junctionsInternalTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
m_pJunctions = Relation::Open ( in_xValueRecord,
inout_iOffset,
xNumericType );
if ( !m_pJunctions )
{
m_pRoutes->Delete();
return;
}
// Open sections
nl->ReadFromString ( sectionsInternalTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
m_pSections = Relation::Open ( in_xValueRecord,
inout_iOffset,
xNumericType );
if ( !m_pSections )
{
m_pRoutes->Delete();
m_pJunctions->Delete();
return;
}
// Open btree for routes
nl->ReadFromString ( routesBTreeTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
m_pBTreeRoutes = BTree::Open ( in_xValueRecord,
inout_iOffset,
xNumericType );
if ( !m_pBTreeRoutes )
{
m_pRoutes->Delete();
m_pJunctions->Delete();
m_pSections->Delete();
return;
}
// Open btree for routesByStartposId
nl->ReadFromString ( routesBTreeTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
m_pBTreeRoutesByStartposId = BTree::Open ( in_xValueRecord,
inout_iOffset,
xNumericType );
if ( !m_pBTreeRoutesByStartposId )
{
m_pRoutes->Delete();
m_pJunctions->Delete();
m_pSections->Delete();
delete m_pBTreeRoutes;
return;
}
//Open rtree for routes
Word xValue;
if ( ! ( m_pRTreeRoutes->Open ( in_xValueRecord,
inout_iOffset,
routesRTreeTypeInfo,
xValue ) ) )
{
m_pRoutes->Delete();
m_pJunctions->Delete();
m_pSections->Delete();
delete m_pBTreeRoutes;
delete m_pBTreeRoutesByStartposId;
return;
}
m_pRTreeRoutes = ( R_Tree<2,TupleId>* ) xValue.addr;
// Open first btree for junctions
nl->ReadFromString ( junctionsBTreeTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
m_pBTreeJunctionsByRoute1 = BTree::Open ( in_xValueRecord,
inout_iOffset,
xNumericType );
if ( !m_pBTreeJunctionsByRoute1 )
{
m_pRoutes->Delete();
m_pJunctions->Delete();
m_pSections->Delete();
delete m_pBTreeRoutes;
delete m_pBTreeRoutesByStartposId;
delete m_pRTreeRoutes;
return;
}
// Open second btree for junctions
nl->ReadFromString ( junctionsBTreeTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
m_pBTreeJunctionsByRoute2 = BTree::Open ( in_xValueRecord,
inout_iOffset,
xNumericType );
if ( !m_pBTreeJunctionsByRoute2 )
{
m_pRoutes->Delete();
m_pJunctions->Delete();
m_pSections->Delete();
delete m_pBTreeRoutes;
delete m_pBTreeRoutesByStartposId;
delete m_pRTreeRoutes;
delete m_pBTreeJunctionsByRoute1;
return;
}
// m_xAdjacencyList.OpenFromRecord(in_xValueRecord, inout_iOffset);
// m_xSubAdjacencyList.OpenFromRecord(in_xValueRecord,inout_iOffset);
size_t bufsize = sizeof(FlobId) + sizeof(SmiSize) + 2*sizeof(int);
SmiSize offset = 0;
char* buf = (char*) malloc(bufsize);
in_xValueRecord.Read(buf, bufsize, inout_iOffset);
inout_iOffset += bufsize;
assert(buf != NULL);
m_xAdjacencyList.restoreHeader(buf,offset);
free(buf);
offset = 0;
buf = (char*) malloc(bufsize);
in_xValueRecord.Read(buf, bufsize, inout_iOffset);
assert(buf != NULL);
m_xSubAdjacencyList.restoreHeader(buf,offset);
inout_iOffset += bufsize;
free(buf);
// Open btree for sections by Routes
nl->ReadFromString ( sectionsBTreeTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
m_pBTreeSectionsByRoute = BTree::Open ( in_xValueRecord,
inout_iOffset,
xNumericType );
if ( !m_pBTreeSectionsByRoute )
{
m_pRoutes->Delete();
m_pJunctions->Delete();
m_pSections->Delete();
delete m_pBTreeRoutes;
delete m_pBTreeRoutesByStartposId;
delete m_pRTreeRoutes;
delete m_pBTreeJunctionsByRoute1;
delete m_pBTreeJunctionsByRoute2;
return;
}
// Open btree for sections
nl->ReadFromString ( sectionsBTreeTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
m_pBTreeSections = BTree::Open ( in_xValueRecord,
inout_iOffset,
xNumericType );
if ( !m_pBTreeSections )
{
m_pRoutes->Delete();
m_pJunctions->Delete();
m_pSections->Delete();
delete m_pBTreeRoutes;
delete m_pBTreeRoutesByStartposId;
delete m_pRTreeRoutes;
delete m_pBTreeJunctionsByRoute1;
delete m_pBTreeJunctionsByRoute2;
delete m_pBTreeSectionsByRoute;
return;
}
//Open distance storage
/*
nl->ReadFromString(distancestorageTypeInfo,xType);
xNumericType = SecondoSystem::GetCatalog()->NumericType(xType);
alldistance = Relation::Open(in_xValueRecord,inout_iOffset,xNumericType);
if(!alldistance){
m_pRoutes->Delete();
m_pJunctions->Delete();
m_pSections->Delete();
delete m_pBTreeRoutes;
delete m_pRTreeRoutes;
delete m_pBTreeJunctionsByRoute1;
delete m_pBTreeJunctionsByRoute2;
return;
}
*/
m_bDefined = true;
}
Network::Network ( ListExpr in_xValue,
int in_iErrorPos,
ListExpr& inout_xErrorInfo,
bool& inout_bCorrect ) :
m_iId ( 0 ),
m_bDefined ( false ),
m_pRoutes ( 0 ),
m_pJunctions ( 0 ),
m_pSections ( 0 ),
m_pBTreeRoutes ( 0 ),
m_pBTreeRoutesByStartposId ( 0 ),
m_pRTreeRoutes ( 0 ),
m_pBTreeJunctionsByRoute1 ( 0 ),
m_pBTreeJunctionsByRoute2 ( 0 ),
m_xAdjacencyList ( 0 ),
m_xSubAdjacencyList ( 0 ),
m_pBTreeSectionsByRoute ( 0 ),
m_pBTreeSections (0)
/*alldistance(0)*/
{
// Check the list
if ( ! ( nl->ListLength ( in_xValue ) == 3 ) )
{
string strErrorMessage = "Network(): List length must be 3.";
inout_xErrorInfo =
nl->Append ( inout_xErrorInfo, nl->StringAtom ( strErrorMessage ) );
inout_bCorrect = false;
return;
}
// Get type-info for temporary table
ListExpr xType;
nl->ReadFromString ( routesTypeInfo, xType );
ListExpr xRoutesNumType = SecondoSystem::GetCatalog()->NumericType ( xType );
nl->ReadFromString ( junctionsTypeInfo, xType );
ListExpr xJunctionsNumType = SecondoSystem::GetCatalog()->NumericType ( xType
);
// Split into the three parts
ListExpr xIdList = nl->First ( in_xValue );
ListExpr xRouteList = nl->Second ( in_xValue );
ListExpr xJunctionList = nl->Third ( in_xValue );
// Sections will be calculated in the load-method
// Read Id
if ( !nl->IsAtom ( xIdList ) ||
nl->AtomType ( xIdList ) != IntType )
{
string strErrorMessage = "Network(): Id is missing.";
inout_xErrorInfo = nl->Append ( inout_xErrorInfo,
nl->StringAtom ( strErrorMessage ) );
inout_bCorrect = false;
return;
}
m_iId = nl->IntValue ( xIdList );
// Create new temporary relations.
Relation* pRoutes = new Relation ( xRoutesNumType, false );
Relation* pJunctions = new Relation ( xJunctionsNumType, false );
// Iterate over all routes
while ( !nl->IsEmpty ( xRouteList ) )
{
ListExpr xCurrentRoute = nl->First ( xRouteList );
xRouteList = nl->Rest ( xRouteList );
// Create tuple for internal table
Tuple* pNewRoute = new Tuple ( nl->Second ( xRoutesNumType ) );
// Check this part of the list
if ( nl->ListLength ( xCurrentRoute ) != 5 ||
( !nl->IsAtom ( nl->First ( xCurrentRoute ) ) ) ||
nl->AtomType ( nl->First ( xCurrentRoute ) ) != IntType ||
( !nl->IsAtom ( nl->Second ( xCurrentRoute ) ) ) ||
nl->AtomType ( nl->Second ( xCurrentRoute ) ) != RealType ||
( nl->IsAtom ( nl->Third ( xCurrentRoute ) ) ) ||
( !nl->IsAtom ( nl->Fourth ( xCurrentRoute ) ) ) ||
nl->AtomType ( nl->Fourth ( xCurrentRoute ) ) != BoolType ||
( !nl->IsAtom ( nl->Fifth ( xCurrentRoute ) ) ) ||
nl->AtomType ( nl->Fifth ( xCurrentRoute ) ) != BoolType )
{
delete pRoutes;
delete pRoutes;
string strErrorMessage = "Network(): Error while reading out routes.";
inout_xErrorInfo = nl->Append ( inout_xErrorInfo,
nl->StringAtom ( strErrorMessage ) );
inout_bCorrect = false;
return;
}
// Read attributes from list
// Read values from table
int iRouteId = nl->IntValue ( nl->First ( xCurrentRoute ) );
double dLength = nl->RealValue ( nl->Second ( xCurrentRoute ) );
Word xLineWord = InSimpleLine ( nl->TheEmptyList(),
nl->Third ( xCurrentRoute ),
in_iErrorPos,
inout_xErrorInfo,
inout_bCorrect );
SimpleLine* pLine = ( SimpleLine* ) ( xLineWord.addr );
bool bDual= nl->BoolValue ( nl->Fourth ( xCurrentRoute ) );
bool bStartsSmaller = nl->BoolValue ( nl->Fifth ( xCurrentRoute ) );
// Set all necessary attributes
pNewRoute->PutAttribute ( ROUTE_ID, new CcInt ( true, iRouteId ) );
pNewRoute->PutAttribute ( ROUTE_LENGTH, new CcReal ( true, dLength ) );
pNewRoute->PutAttribute ( ROUTE_CURVE, pLine );
pNewRoute->PutAttribute ( ROUTE_DUAL, new CcBool ( true, bDual ) );
pNewRoute->PutAttribute ( ROUTE_STARTSSMALLER, new CcBool ( true,
bStartsSmaller ) );
// Append new junction
pRoutes->AppendTuple ( pNewRoute );
if ( pNewRoute )
{
pNewRoute->DeleteIfAllowed();
pNewRoute=0;
}
}
// Iterate over all junctions
while ( !nl->IsEmpty ( xJunctionList ) )
{
ListExpr xCurrentJunction = nl->First ( xJunctionList );
xJunctionList = nl->Rest ( xJunctionList );
// Create tuple for internal table
Tuple* pNewJunction = new Tuple ( nl->Second ( xJunctionsNumType ) );
// Check this part of the list
if ( nl->ListLength ( xCurrentJunction ) != 6 ||
( !nl->IsAtom ( nl->First ( xCurrentJunction ) ) ) ||
nl->AtomType ( nl->First ( xCurrentJunction ) ) != IntType ||
( !nl->IsAtom ( nl->Second ( xCurrentJunction ) ) ) ||
nl->AtomType ( nl->Second ( xCurrentJunction ) ) != RealType ||
( !nl->IsAtom ( nl->Third ( xCurrentJunction ) ) ) ||
nl->AtomType ( nl->Third ( xCurrentJunction ) ) != IntType ||
( !nl->IsAtom ( nl->Fourth ( xCurrentJunction ) ) ) ||
nl->AtomType ( nl->Fourth ( xCurrentJunction ) ) != RealType ||
( !nl->IsAtom ( nl->Fifth ( xCurrentJunction ) ) ) ||
nl->AtomType ( nl->Fifth ( xCurrentJunction ) ) != IntType )
{
delete pRoutes;
delete pJunctions;
string strErrorMessage = "Network(): Error while reading out junctions.";
inout_xErrorInfo = nl->Append ( inout_xErrorInfo,
nl->StringAtom ( strErrorMessage ) );
inout_bCorrect = false;
return;
}
// Read attributes from list
int iRoute1Id = nl->IntValue ( nl->First ( xCurrentJunction ) );
double dMeas1 = nl->RealValue ( nl->Second ( xCurrentJunction ) );
int iRoute2Id = nl->IntValue ( nl->Third ( xCurrentJunction ) );
double dMeas2 = nl->RealValue ( nl->Fourth ( xCurrentJunction ) );
int iConnectivityCode= nl->IntValue ( nl->Fifth ( xCurrentJunction ) );
// The location of the junction "Point" is calculated in the load-method
// Set all necessary attributes
pNewJunction->PutAttribute ( JUNCTION_ROUTE1_ID,
new CcInt ( true, iRoute1Id ) );
pNewJunction->PutAttribute ( JUNCTION_ROUTE1_MEAS,
new CcReal ( true, dMeas1 ) );
pNewJunction->PutAttribute ( JUNCTION_ROUTE2_ID,
new CcInt ( true, iRoute2Id ) );
pNewJunction->PutAttribute ( JUNCTION_ROUTE2_MEAS,
new CcReal ( true, dMeas2 ) );
pNewJunction->PutAttribute ( JUNCTION_CC,
new CcInt ( true, iConnectivityCode ) );
// Append new junction
pJunctions->AppendTuple ( pNewJunction );
if ( pNewJunction )
{
pNewJunction->DeleteIfAllowed();
pNewJunction=0;
}
}
Load ( m_iId,
pRoutes,
pJunctions );
delete pRoutes;
delete pJunctions;
m_bDefined = true;
}
/*
Destructor
*/
Network::~Network()
{
delete m_pRoutes;
delete m_pJunctions;
delete m_pSections;
delete m_pBTreeRoutes;
delete m_pBTreeRoutesByStartposId;
delete m_pRTreeRoutes;
delete m_pBTreeJunctionsByRoute1;
delete m_pBTreeJunctionsByRoute2;
delete m_pBTreeSectionsByRoute;
delete m_pBTreeSections;
// delete alldistance;
}
/*
2.1.3 Methods of class ~network~
Method ~Destroy~
Removing a network from the database
*/
void Network::Destroy()
{
assert ( m_pRoutes != 0 );
m_pRoutes->Delete(); m_pRoutes = 0;
assert ( m_pJunctions != 0 );
m_pJunctions->Delete(); m_pJunctions = 0;
assert ( m_pSections != 0 );
m_pSections->Delete(); m_pSections = 0;
assert ( m_pBTreeRoutes != 0 );
m_pBTreeRoutes->DeleteFile();
delete m_pBTreeRoutes; m_pBTreeRoutes = 0;
assert ( m_pBTreeRoutesByStartposId != 0 );
m_pBTreeRoutesByStartposId->DeleteFile();
delete m_pBTreeRoutesByStartposId; m_pBTreeRoutesByStartposId = 0;
assert ( m_pRTreeRoutes != 0 );
//m_pRTreeRoutes->DeleteFile();
delete m_pRTreeRoutes; m_pRTreeRoutes = 0;
m_pBTreeJunctionsByRoute1->DeleteFile();
delete m_pBTreeJunctionsByRoute1; m_pBTreeJunctionsByRoute1 = 0;
m_pBTreeJunctionsByRoute2->DeleteFile();
delete m_pBTreeJunctionsByRoute2; m_pBTreeJunctionsByRoute2 = 0;
// m_xAdjacencyList.Destroy();
// m_xSubAdjacencyList.Destroy();
assert ( m_pBTreeSectionsByRoute != 0 );
m_pBTreeSectionsByRoute->DeleteFile();
delete m_pBTreeSectionsByRoute;
m_pBTreeSectionsByRoute = 0;
assert ( m_pBTreeSections != 0 );
m_pBTreeSections->DeleteFile();
delete m_pBTreeSections;
m_pBTreeSections = 0;
/*
assert(alldistance != 0);
delete alldistance;
*/
}
/*
Method ~Load~
Create a network from two external relations
*/
void Network::Load ( int in_iId,
const Relation* in_pRoutes,
const Relation* in_pJunctions )
{
m_iId = in_iId;
FillRoutes ( in_pRoutes );
FillJunctions ( in_pJunctions );
FillSections();
FillAdjacencyLists();
//FillDistanceStorage();//store distance
m_bDefined = true;
}
/*
Method ~OptimizeNetwork~
optimizes the order of the ~routes~, after that all ~sections~ are generated new
and all structures based on these ~sections~ are adjusted
*/
bool Network::OptimizeNetwork(){
//sort routes
OptimizationRoutes();
//DEBUG
//cout << "output of all routes"<< endl;
//for (int i =1; i<=m_pRoutes->GetNoTuples();i++)
//{
//Tuple *n = m_pRoutes->GetTuple(i,false);
//cout <<"("<< ((CcInt*)n->GetAttribute(ROUTE_ID))->GetIntval() << ","
// << ((CcInt*)n->GetAttribute(ROUTE_STARTPOS_ID))->GetIntval()
// << ")"<<endl;
//n->DeleteIfAllowed();
//}
//update the BTree for routes by startPos_id
delete m_pBTreeRoutesByStartposId;
m_pBTreeRoutesByStartposId=0;
ostringstream xThisRoutesPtrStream2;
xThisRoutesPtrStream2 << ( long ) m_pRoutes;
string strQuery = "(createbtree (" + routesInternalTypeInfo +
" (ptr " + xThisRoutesPtrStream2.str() + "))" + " Startposid)";
Word xResult;
int QueryExecuted = QueryProcessor::ExecuteQuery ( strQuery, xResult );
assert ( QueryExecuted ); // no query with side effects, please!
m_pBTreeRoutesByStartposId = ( BTree* ) xResult.addr;
//Fillsections new
delete m_pBTreeSections;
delete m_pBTreeSectionsByRoute;
int anz = m_pSections->GetNoTuples();
for(int z=1;z <= anz ;z++){
m_pSections->DeleteTuple(m_pSections->GetTuple(z,false));
}
m_pSections->Clear();
delete m_pSections;
m_pSections = 0;
FillSections();
//Update the Adjacencylist
//DEBUG cout << "update AdjacencList mit "<< m_xAdjacencyList.Size()<< endl;
m_xAdjacencyList.clean();
m_xAdjacencyList = 0;
FillAdjacencyLists();
return true;
}
/*
Mehtod ~OptimizationRoutes~
determined for all ~routes~ their lexicographic start point, stores them in an
array and calls the sort method ~QuicksortRoutes~
*/
bool Network::OptimizationRoutes(){
Tuple *route;
GPoint *gp;
Point *p = new Point();
int anzElemente = m_pRoutes->GetNoTuples();
int testarray[anzElemente][2];
bool opt= false;
for (int i =1; i<=m_pRoutes->GetNoTuples();i++)
{
route = m_pRoutes->GetTuple(i,false);
int id = ((CcInt*) route->GetAttribute(ROUTE_ID))->GetIntval();
//bool smaller=
// ((CcBool*) route->GetAttribute(ROUTE_STARTSSMALLER))->GetBoolval();
// dermine points
gp = new GPoint(true, GetId(),id, 0.0);
gp->ToPoint(p);
if (p->IsDefined()) opt = true; else return false;
testarray[i-1][0] = id;
testarray[i-1][1] = p->GetX();
}
if(opt)
{
//DEBUG for testing
//cout << "vor dem Sortieren" << endl;
//for (int k =0; k< anzElemente; k++)
//{
//cout << testarray[k][0] <<"," <<testarray[k][1]<< endl;
//}
QuicksortRoutes(testarray,0,anzElemente-1);
//DEBUG for testing
//cout << "nach dem Sortieren" << endl;
//for (int k =0; k< anzElemente; k++)
//{
//cout << testarray[k][0] <<"," <<testarray[k][1]<< endl;
//}
// update startposId in m_pRoutes
for (int k =0; k< anzElemente; k++)
{
route = m_pRoutes->GetTuple(testarray[k][0],false);
vector<int> xIndices;
vector<Attribute*> xAttrs;
xIndices.push_back ( ROUTE_STARTPOS_ID );
xAttrs.push_back ( new CcInt ( true, k+1 ) );
m_pRoutes->UpdateTuple(route, xIndices, xAttrs);
}
}
p->DeleteIfAllowed();
gp->DeleteIfAllowed();
route->DeleteIfAllowed();
return true;
}
/*
Method ~QuicksortRoutes~
calculates the pivot-element-index with the method
~QuicksortRoutesPartition~. After that ~QuicksortRoutes~ is recursively called
for the upper and lower part of the array
*/
void Network::QuicksortRoutes(int arr[][2], int low, int high)
{
int pivotIndex;
if(low < high)
{ //split the array and calculate the pivot-element
pivotIndex = QuicksortRoutesPartition(arr, low, high);
//sort the bottom part
QuicksortRoutes(arr, low, pivotIndex-1);
//sort the top part
QuicksortRoutes(arr, pivotIndex+1,high);
}
}
/*
Method ~QuicksortRoutesPartition~
split the given array and sorts the array so that all elements before the
pivot-element are smaller and all elements that are above the pivot element
are larger.
*/
int Network::QuicksortRoutesPartition(int arr[][2], int low, int high)
{
//DEBUG cout << "QuicksortPartiton: mit lowindex: " << low
// << " und highindex: " << high << endl;
int high_vac[2]={0},low_vac[2]={0},pivot[2]={0};
pivot[0] = arr[low][0];
pivot[1] = arr[low][1];
// while the lowindex is less than the highIndex
while(high > low)
{ //DEBUG cout << "while high: "<< high
// << " ist groesser als low: " << low << endl;
high_vac[0] = arr[high][0];
high_vac[1] = arr[high][1];
//DEBUG cout << "highWert " << high_vac[1] << endl;
//while the value of the high-element is greater than
//or equal the pivot-element
while(pivot[1] <= high_vac[1])
{ //DEBUG cout << "while pivot : "<< pivot[1]
// << " ist kleiner als hight_vac: " << high_vac[1]<< endl;
// if hightindex less then or equal with
// the lowindex BREAK the while-loop
if(high <= low) break;
high--;
high_vac[0] = arr[high][0];
high_vac[1] = arr[high][1];
}
arr[low][0] = high_vac[0];
arr[low][1] = high_vac[1];
low_vac[0] = arr[low][0];
low_vac[1] = arr[low][1];
//while the value of the pivot-element is greater than the low-element
while(pivot[1] > low_vac[1])
{ //cout << "while pivot : "<< pivot[1]
// << " ist groesser als low_vac: " << low_vac[1]<< endl;
// if hightindex less then or equal with
// the lowindex BREAK the while-loop
if(high<=low) break;
low++;
low_vac[0] = arr[low][0];
low_vac[1] = arr[low][1];
}
arr[high][0] = low_vac[0];
arr[high][1] = low_vac[1];
}
arr[low][0] = pivot[0];
arr[low][1] = pivot[1];
//return the lowindex value
return low;
}
/*
Method ~FillRoutes~
Fill routes relation of network
*/
void Network::FillRoutes ( const Relation *routes )
{
//Create new table for the routes
ListExpr xTypeInfo;
nl->ReadFromString ( routesInternalTypeInfo, xTypeInfo );
ListExpr xNumType = SecondoSystem::GetCatalog()->NumericType ( xTypeInfo );
Relation *pIntRoutes = new Relation ( xNumType, true );
// Iterator for the input-table with routes
GenericRelationIterator* pRoutesIter = routes->MakeScan();
Tuple* pCurrentRoute;
int routeCounter =1;
while ( ( pCurrentRoute = pRoutesIter->GetNextTuple() ) != 0 )
{
// Create tuple for internal table and copy all attributes from input
Tuple* pNewRoute = new Tuple ( nl->Second ( xNumType ) );
for ( int i = 0; i < pCurrentRoute->GetNoAttributes(); i++ )
{
pNewRoute->CopyAttribute ( i, pCurrentRoute, i );
}
// Fill other fields of the table
pNewRoute->PutAttribute(ROUTE_STARTPOS_ID,new CcInt(true,routeCounter));
// Append new route
pIntRoutes->AppendTuple ( pNewRoute );
//clean up
pCurrentRoute->DeleteIfAllowed();
pNewRoute->DeleteIfAllowed();
// increment routeCounter for next route
routeCounter++;
}
delete pRoutesIter;
ostringstream xRoutesPtrStream;
xRoutesPtrStream << ( long ) pIntRoutes;
string strQuery = "(consume (sort (feed (" + routesInternalTypeInfo +
" (ptr " + xRoutesPtrStream.str() + ")))))";
Word xResult;
int QueryExecuted = QueryProcessor::ExecuteQuery ( strQuery, xResult );
assert ( QueryExecuted );
m_pRoutes = ( Relation * ) xResult.addr;
delete pIntRoutes;
// Create B-Tree for the routes
ostringstream xThisRoutesPtrStream;
xThisRoutesPtrStream << ( long ) m_pRoutes;
strQuery = "(createbtree (" + routesInternalTypeInfo +
" (ptr " + xThisRoutesPtrStream.str() + "))" + " Id)";
QueryExecuted = QueryProcessor::ExecuteQuery ( strQuery, xResult );
assert ( QueryExecuted ); // no query with side effects, please!
m_pBTreeRoutes = ( BTree* ) xResult.addr;
// Create B-Tree for the routes by startPos_id
ostringstream xThisRoutesPtrStream2;
xThisRoutesPtrStream2 << ( long ) m_pRoutes;
strQuery = "(createbtree (" + routesInternalTypeInfo +
" (ptr " + xThisRoutesPtrStream2.str() + "))" + " Startposid)";
QueryExecuted = QueryProcessor::ExecuteQuery ( strQuery, xResult );
assert ( QueryExecuted ); // no query with side effects, please!
m_pBTreeRoutesByStartposId = ( BTree* ) xResult.addr;
//Create R-Tree for the routes
ostringstream xNetRoutes;
xNetRoutes << ( long ) m_pRoutes;
strQuery = "(bulkloadrtree(sortby(addid(feed (" + routesInternalTypeInfo +
" (ptr " + xThisRoutesPtrStream.str() + "))))((Curve asc))) Curve)";
QueryExecuted = QueryProcessor::ExecuteQuery ( strQuery, xResult );
assert ( QueryExecuted );
m_pRTreeRoutes = ( R_Tree<2,TupleId>* ) xResult.addr;
}
/*
Method ~FillJunctions~
Fill junctions relation of network
*/
void Network::FillJunctions ( const Relation *in_pJunctions )
{
/////////////////////////////////////////////////////////////////////
//
// Create new table for the junctions
//
ListExpr xTypeInfo;
nl->ReadFromString ( junctionsInternalTypeInfo, xTypeInfo );
ListExpr xNumType = SecondoSystem::GetCatalog()->NumericType ( xTypeInfo );
Relation *pIntJunctions = new Relation ( xNumType, true );
/////////////////////////////////////////////////////////////////////
//
// Iterator for the input-table with junctions
//
GenericRelationIterator* pJunctionsIter = in_pJunctions->MakeScan();
Tuple* pCurrentJunction;
while ( ( pCurrentJunction = pJunctionsIter->GetNextTuple() ) != 0 )
{
/////////////////////////////////////////////////////////////////////
//
// Create tuple for internal table and copy all attributes from input
//
Tuple* pNewJunction = new Tuple ( nl->Second ( xNumType ) );
for ( int i = 0; i < pCurrentJunction->GetNoAttributes(); i++ )
{
pNewJunction->CopyAttribute ( i, pCurrentJunction, i );
}
/////////////////////////////////////////////////////////////////////
//
// Fill other fields of the table
//
// Store Pointer to the first route in the new relation.
CcInt* pR1Id = ( CcInt* ) pCurrentJunction->GetAttribute (
JUNCTION_ROUTE1_ID );
BTreeIterator* pRoutesIter = m_pBTreeRoutes->ExactMatch ( pR1Id );
int NextIter = pRoutesIter->Next();
assert ( NextIter );
TupleIdentifier *pR1RC = new TupleIdentifier ( true, pRoutesIter->GetId() );
pNewJunction->PutAttribute ( JUNCTION_ROUTE1_RC, pR1RC );
// Calculate and store the exakt location of the junction.
Tuple* pRoute = m_pRoutes->GetTuple ( pRoutesIter->GetId(), false );
assert ( pRoute != 0 );
SimpleLine* pLine = ( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
assert ( pLine != 0 );
CcReal* pMeas = ( CcReal* ) pNewJunction->GetAttribute (
JUNCTION_ROUTE1_MEAS );
Point* pPoint = new Point ( false );
pLine->AtPosition ( pMeas->GetRealval(), true, *pPoint );
pNewJunction->PutAttribute ( JUNCTION_POS, pPoint );
pRoute->DeleteIfAllowed();
delete pRoutesIter;
// Store Pointer to the second route in the new relation.
CcInt* pR2Id = ( CcInt* ) pCurrentJunction->GetAttribute (
JUNCTION_ROUTE2_ID );
pRoutesIter = m_pBTreeRoutes->ExactMatch ( pR2Id );
NextIter = pRoutesIter->Next();
assert ( NextIter ); // no query with side effects, please!
TupleIdentifier *pR2RC = new TupleIdentifier ( true, pRoutesIter->GetId() );
pNewJunction->PutAttribute ( JUNCTION_ROUTE2_RC, pR2RC );
delete pRoutesIter;
// Pointers to sections are filled in FillSections
pNewJunction->PutAttribute ( JUNCTION_SECTION_AUP_RC,
new TupleIdentifier ( false ) );
pNewJunction->PutAttribute ( JUNCTION_SECTION_ADOWN_RC,
new TupleIdentifier ( false ) );
pNewJunction->PutAttribute ( JUNCTION_SECTION_BUP_RC,
new TupleIdentifier ( false ) );
pNewJunction->PutAttribute ( JUNCTION_SECTION_BDOWN_RC,
new TupleIdentifier ( false ) );
/////////////////////////////////////////////////////////////////////
//
// Append new junction
//
pIntJunctions->AppendTuple ( pNewJunction );
pCurrentJunction->DeleteIfAllowed();
pNewJunction->DeleteIfAllowed();
}
delete pJunctionsIter;
/////////////////////////////////////////////////////////////////////
//
// Sort the table which is now containing all junctions
//
ostringstream xJunctionsStream;
xJunctionsStream << ( long ) pIntJunctions;
string strQuery = "(consume (sortby (feed (" + junctionsInternalTypeInfo +
" (ptr " + xJunctionsStream.str() +
"))) ((R1id asc)(Meas1 asc))))";
Word xResult;
int QueryExecuted = QueryProcessor::ExecuteQuery ( strQuery, xResult );
assert ( QueryExecuted );
m_pJunctions = ( Relation * ) xResult.addr;
// Delete internal table
pIntJunctions->Delete();
/////////////////////////////////////////////////////////////////////
//
// Create two b-trees for the junctions sorted by first and second id
//
ostringstream xThisJunctionsPtrStream;
xThisJunctionsPtrStream << ( long ) m_pJunctions;
strQuery = "(createbtree (" + junctionsInternalTypeInfo +
" (ptr " + xThisJunctionsPtrStream.str() + "))" + " R1id)";
QueryExecuted = QueryProcessor::ExecuteQuery ( strQuery, xResult );
assert ( QueryExecuted ); // no query with side effects, please!
m_pBTreeJunctionsByRoute1 = ( BTree* ) xResult.addr;
ostringstream xThisJunctionsPtrStream2;
xThisJunctionsPtrStream2 << ( long ) m_pJunctions;
strQuery = "(createbtree (" + junctionsInternalTypeInfo +
" (ptr " + xThisJunctionsPtrStream2.str() + "))" + " R2id)";
QueryExecuted = QueryProcessor::ExecuteQuery ( strQuery, xResult );
assert ( QueryExecuted ); // no query with side effects, please!
m_pBTreeJunctionsByRoute2 = ( BTree* ) xResult.addr;
}
/*
Method ~FillSections~
Fill section relation of network
*/
void Network::FillSections()
{
// The method will iterate over routes by StartposIndex
BTreeIterator* pRoutesIt = m_pBTreeRoutesByStartposId->SelectAll();
// Create relation for sections
ListExpr xType;
nl->ReadFromString ( sectionsInternalTypeInfo, xType );
ListExpr xNumType = SecondoSystem::GetCatalog()->NumericType ( xType );
m_pSections = new Relation ( xNumType );
/////////////////////////////////////////////////////////////////////
//
// Iterate over all Routes
//
Tuple* pRoute;
TupleId iSectionTid = 0;
while ( pRoutesIt->Next() )
{
pRoute = m_pRoutes->GetTuple(pRoutesIt->GetId(),false);
//DEBUG cout << "Rid "
// <<((CcInt*)pRoute->GetAttribute(ROUTE_ID))->GetIntval()<<endl;
// Current position on route - starting at the beginning of the route
double dCurrentPosOnRoute = 0;
SimpleLine* pRouteCurve = ( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE
);
TupleId iTupleId = pRoute->GetTupleId();
CcInt* xRouteId = ( CcInt* ) pRoute->GetAttribute ( ROUTE_ID );
int iRouteId = xRouteId->GetIntval();
bool bDual = ( ( CcBool* ) pRoute->GetAttribute ( ROUTE_DUAL )
)->GetBoolval();
/////////////////////////////////////////////////////////////////////
//
// We need to find all junctions belonging to this route
//
vector<JunctionSortEntry> xJunctions;
GetJunctionsOnRoute ( xRouteId,
xJunctions );
/////////////////////////////////////////////////////////////////////
//
// Now that we found all relevant junctions we can iterate over them.
//
JunctionSortEntry xCurrentEntry;
xCurrentEntry.m_pJunction = 0;
xCurrentEntry.m_bFirstRoute = false;
for ( size_t i = 0; i < xJunctions.size(); i++ )
{
// Get next junction
xCurrentEntry = xJunctions[i];
// Find values for the new section
double dStartPos = dCurrentPosOnRoute;
double dEndPos = xCurrentEntry.GetRouteMeas();
// If the first junction is at the very start of the route, no
// section will be added
if ( xCurrentEntry.GetRouteMeas() == 0 )
{
vector<int> xIndices;
vector<Attribute*> xAttrs;
if ( xCurrentEntry.m_bFirstRoute )
{
xIndices.push_back ( JUNCTION_SECTION_ADOWN_RC );
xAttrs.push_back ( new TupleIdentifier ( true, 0 ) );
}
else
{
xIndices.push_back ( JUNCTION_SECTION_BDOWN_RC );
xAttrs.push_back ( new TupleIdentifier ( true, 0 ) );
}
m_pJunctions->UpdateTuple ( xCurrentEntry.m_pJunction,
xIndices,
xAttrs );
continue;
}
/////////////////////////////////////////////////////////////////////
//
// Create a new section
//
// Section will only be created if the length is > 0. Otherwise the
// one before remains valid.
if ( dEndPos - dStartPos > 0.01 )
{
// A sline for the section
SimpleLine* pLine = new SimpleLine ( 0 );
// Take start from the route
bool bStartSmaller = ( ( CcBool* ) pRoute->GetAttribute (
ROUTE_STARTSSMALLER ) )->GetBoolval();
pRouteCurve->SubLine ( dStartPos,
dEndPos,
bStartSmaller,
*pLine );
// Find out, if the orientation of the subline differs from the position
// of the line. If so, the direction has to be changed.
bool bLineStartsSmaller;
Point pStartPoint ( false );
pRouteCurve->AtPosition ( dStartPos, bStartSmaller, pStartPoint );
Point pEndPoint ( false );
pRouteCurve->AtPosition ( dEndPos, bStartSmaller, pEndPoint );
if ( pStartPoint.GetX() < pEndPoint.GetX() ||
(
pStartPoint.GetX() == pEndPoint.GetX() &&
pStartPoint.GetY() < pEndPoint.GetY()
)
)
{
// Normal orientation
bLineStartsSmaller = true;
}
else
{
// Opposite orientation
bLineStartsSmaller = false;
}
// The new section
Tuple* pNewSection = new Tuple ( nl->Second ( xNumType ) );
pNewSection->PutAttribute ( SECTION_RID, new CcInt ( true, iRouteId ) );
pNewSection->PutAttribute ( SECTION_DUAL, new CcBool ( true, bDual ) );
pNewSection->PutAttribute ( SECTION_MEAS1, new CcReal ( true, dStartPos
) );
pNewSection->PutAttribute ( SECTION_MEAS2, new CcReal ( true, dEndPos )
);
pNewSection->PutAttribute ( SECTION_RRC, new TupleIdentifier ( true,
iTupleId ) );
pNewSection->PutAttribute ( SECTION_CURVE, pLine );
pNewSection->PutAttribute ( SECTION_CURVE_STARTS_SMALLER,
new CcBool ( true, bLineStartsSmaller ) );
pNewSection->PutAttribute ( SECTION_SID,
new CcInt ( true, m_pSections->GetNoTuples()
+1 ) );
//new Attributes inserted
pNewSection->PutAttribute (SECTION_PNO_UP, new CcInt(true,0));
pNewSection->PutAttribute (SECTION_PNO_DOWN, new CcInt(true,0));
pNewSection->PutAttribute (SECTION_SLOT_UP, new CcInt(true,0));
pNewSection->PutAttribute (SECTION_SLOT_DOWN, new CcInt(true,0));
pNewSection->PutAttribute (SECTION_COST, new CcReal(true,1.0));
pNewSection->PutAttribute (SECTION_DURATION, new CcReal(true,1.0));
m_pSections->AppendTuple ( pNewSection );
iSectionTid++;
pNewSection->DeleteIfAllowed();
// Update position for next loop
dCurrentPosOnRoute = dEndPos;
}
/////////////////////////////////////////////////////////////////////
//
// Store ID of new section in junction behind that section.
//
vector<int> xIndices;
vector<Attribute*> xAttrs;
if ( xCurrentEntry.m_bFirstRoute )
{
xIndices.push_back ( JUNCTION_SECTION_ADOWN_RC );
xAttrs.push_back ( new TupleIdentifier ( true, iSectionTid ) );
}
else
{
xIndices.push_back ( JUNCTION_SECTION_BDOWN_RC );
xAttrs.push_back ( new TupleIdentifier ( true, iSectionTid ) );
}
m_pJunctions->UpdateTuple ( xCurrentEntry.m_pJunction,
xIndices,
xAttrs );
if ( pRouteCurve->Length() - xCurrentEntry.GetRouteMeas() < 0.01 )
{
vector<int> xIndices;
vector<Attribute*> xAttrs;
if ( xCurrentEntry.m_bFirstRoute )
{
xIndices.push_back ( JUNCTION_SECTION_AUP_RC );
xAttrs.push_back ( new TupleIdentifier ( true, 0 ) );
}
else
{
xIndices.push_back ( JUNCTION_SECTION_BUP_RC );
xAttrs.push_back ( new TupleIdentifier ( true, 0 ) );
}
m_pJunctions->UpdateTuple ( xCurrentEntry.m_pJunction,
xIndices,
xAttrs );
}
} // End junctions-loop
/////////////////////////////////////////////////////////////////////
//
// The last section of the route is still missing, if the last
// junction is not at the end of the route.
//
if ( pRouteCurve->Length() - dCurrentPosOnRoute > 0.01 ||
dCurrentPosOnRoute == 0.0 )
{
// Find values for the new section
int iRouteId = ( ( CcInt* ) pRoute->GetAttribute ( ROUTE_ID )
)->GetIntval();
bool bDual = ( ( CcBool* ) pRoute->GetAttribute ( ROUTE_DUAL )
)->GetBoolval();
double dStartPos = dCurrentPosOnRoute;
double dEndPos = pRouteCurve->Length();
TupleId iTupleId = pRoute->GetTupleId();
// Calculate line
SimpleLine* pLine = new SimpleLine ( 0 );
bool bStartSmaller = ( ( CcBool* ) pRoute->GetAttribute (
ROUTE_STARTSSMALLER ) )->GetBoolval();
pRouteCurve->SubLine ( dStartPos,
dEndPos,
bStartSmaller,
*pLine );
// Find out, if the orientation of the subline differs from the position
// of the sline. If so, the direction has to be changed.
bool bLineStartsSmaller;
Point pStartPoint ( false );
pRouteCurve->AtPosition ( dStartPos, bStartSmaller, pStartPoint );
Point pEndPoint ( false );
pRouteCurve->AtPosition ( dEndPos, bStartSmaller, pEndPoint );
if ( pStartPoint.GetX() < pEndPoint.GetX() ||
(
pStartPoint.GetX() == pEndPoint.GetX() &&
pStartPoint.GetY() < pEndPoint.GetY()
)
)
{
// Normal orientation
bLineStartsSmaller = true;
}
else
{
// Opposite orientation
bLineStartsSmaller = false;
}
// Create a new Section
Tuple* pNewSection = new Tuple ( nl->Second ( xNumType ) );
pNewSection->PutAttribute ( SECTION_RID, new CcInt ( true, iRouteId ) );
pNewSection->PutAttribute ( SECTION_DUAL, new CcBool ( true, bDual ) );
pNewSection->PutAttribute ( SECTION_MEAS1, new CcReal ( true, dStartPos )
);
pNewSection->PutAttribute ( SECTION_MEAS2, new CcReal ( true, dEndPos ) );
pNewSection->PutAttribute ( SECTION_RRC,
new TupleIdentifier ( true, iTupleId ) );
pNewSection->PutAttribute ( SECTION_CURVE, pLine );
pNewSection->PutAttribute ( SECTION_CURVE_STARTS_SMALLER,
new CcBool ( true, bLineStartsSmaller ) );
pNewSection->PutAttribute ( SECTION_SID,
new CcInt ( true, m_pSections->GetNoTuples()
+1 ) );
//new Attributes inserted
pNewSection->PutAttribute (SECTION_PNO_UP, new CcInt(true,0));
pNewSection->PutAttribute (SECTION_PNO_DOWN, new CcInt(true,0));
pNewSection->PutAttribute (SECTION_SLOT_UP, new CcInt(true,0));
pNewSection->PutAttribute (SECTION_SLOT_DOWN, new CcInt(true,0));
pNewSection->PutAttribute (SECTION_COST, new CcReal(true,1.0));
pNewSection->PutAttribute (SECTION_DURATION, new CcReal(true,1.0));
m_pSections->AppendTuple ( pNewSection );
iSectionTid++;
pNewSection->DeleteIfAllowed();
// Store ID of new section in Junction
if ( xCurrentEntry.m_pJunction != 0 )
{
vector<int> xIndicesLast;
vector<Attribute*> xAttrsLast;
if ( xCurrentEntry.m_bFirstRoute )
{
xIndicesLast.push_back ( JUNCTION_SECTION_AUP_RC );
xAttrsLast.push_back ( new TupleIdentifier ( true,
iSectionTid ) );
}
else
{
xIndicesLast.push_back ( JUNCTION_SECTION_BUP_RC );
xAttrsLast.push_back ( new TupleIdentifier ( true,
iSectionTid ) );
}
m_pJunctions->UpdateTuple ( xCurrentEntry.m_pJunction,
xIndicesLast,
xAttrsLast );
}
} // end if
////////////////////////////////////////////////////////////////////
//
// Fill Up-Pointers of all sections but the last
//
vector<JunctionSortEntry> yJunctions;
GetJunctionsOnRoute ( xRouteId,
yJunctions );
if ( yJunctions.size() > 2 )
{
for ( int i = yJunctions.size()-2; i >= 0; i-- )
{
// Get next junction
JunctionSortEntry xEntry = yJunctions[i];
JunctionSortEntry xEntryBehind = yJunctions[i + 1];
vector<int> xIndices;
if ( xEntry.m_bFirstRoute )
{
xIndices.push_back ( JUNCTION_SECTION_AUP_RC );
}
else
{
xIndices.push_back ( JUNCTION_SECTION_BUP_RC );
}
vector<Attribute*> xAttrs;
if ( xEntryBehind.GetRouteMeas() - xEntry.GetRouteMeas() < 0.01 )
{
// Two junctions at the same place. In this case they do have
// the same up-pointers
if ( xEntryBehind.m_bFirstRoute )
{
TupleId iTid = xEntryBehind.GetUpSectionId();
xAttrs.push_back ( new TupleIdentifier ( true, iTid ) );
}
else
{
TupleId iTid = xEntryBehind.GetUpSectionId();
xAttrs.push_back ( new TupleIdentifier ( true, iTid ) );
}
}
else
{
// Junctions not on the same place. The down-pointer of the second is
// the up-pointer of the first.
if ( xEntryBehind.m_bFirstRoute )
{
TupleId iTid = xEntryBehind.GetDownSectionId();
xAttrs.push_back ( new TupleIdentifier ( true, iTid ) );
}
else
{
TupleId iTid = xEntryBehind.GetDownSectionId();
xAttrs.push_back ( new TupleIdentifier ( true, iTid ) );
}
}
m_pJunctions->UpdateTuple ( xEntry.m_pJunction,
xIndices,
xAttrs );
}
}
else
{
if ( yJunctions.size() == 2 )
{
JunctionSortEntry xEntry = yJunctions[0];
JunctionSortEntry xEntryBehind = yJunctions[1];
vector<int> xIndices;
if ( xEntry.m_bFirstRoute )
{
xIndices.push_back ( JUNCTION_SECTION_AUP_RC );
}
else
{
xIndices.push_back ( JUNCTION_SECTION_BUP_RC );
}
vector<Attribute*> xAttrs;
if ( fabs ( xEntry.GetRouteMeas() - xEntryBehind.GetRouteMeas() ) < 0.01
)
{
if ( xEntryBehind.m_bFirstRoute )
{
TupleId iTid = xEntryBehind.GetUpSectionId();
xAttrs.push_back ( new TupleIdentifier ( true, iTid ) );
}
else
{
TupleId iTid = xEntryBehind.GetUpSectionId();
xAttrs.push_back ( new TupleIdentifier ( true, iTid ) );
}
m_pJunctions->UpdateTuple ( xEntry.m_pJunction,
xIndices,
xAttrs );
}
else
{
if ( xEntryBehind.m_bFirstRoute )
{
TupleId iTid = xEntryBehind.GetDownSectionId();
xAttrs.push_back ( new TupleIdentifier ( true, iTid ) );
}
else
{
TupleId iTid = xEntryBehind.GetDownSectionId();
xAttrs.push_back ( new TupleIdentifier ( true, iTid ) );
}
m_pJunctions->UpdateTuple ( xEntry.m_pJunction,
xIndices,
xAttrs );
}
}
}
pRoute->DeleteIfAllowed();
// delete Tuples from xJunctions
for ( unsigned int i=0;i<xJunctions.size();i++ )
{
if ( xJunctions[i].m_pJunction )
{
xJunctions[i].m_pJunction->DeleteIfAllowed();
}
}
xJunctions.clear();
// delete Tuples from yJunctions
for ( unsigned int i=0;i<yJunctions.size();i++ )
{
if ( yJunctions[i].m_pJunction )
{
yJunctions[i].m_pJunction->DeleteIfAllowed();
}
}
yJunctions.clear();
} // End while Routes
delete pRoutesIt;
// Create B-Tree for the sections by Routes
Word xResult;
ostringstream xThisSectionsPtrStream;
xThisSectionsPtrStream << ( long ) m_pSections;
string strQuery = "(createbtree (" + sectionsInternalTypeInfo +
" (ptr " + xThisSectionsPtrStream.str() + "))" + " Rid)";
int QueryExecuted = QueryProcessor::ExecuteQuery ( strQuery, xResult );
assert ( QueryExecuted ); // no query with side effects, please!
m_pBTreeSectionsByRoute = ( BTree* ) xResult.addr;
//Create B-Tree for the sections
Word xResultNewBtree;
ostringstream xStream2;
xStream2 << (long) m_pSections;
string query = "(createbtree (" + sectionsInternalTypeInfo +
" (ptr " + xStream2.str() + "))" + " Sid)";
int QueryEx = QueryProcessor::ExecuteQuery ( query, xResultNewBtree );
assert ( QueryEx ); // no query with side effects, please!
m_pBTreeSections = ( BTree* ) xResultNewBtree.addr;
}
/*
Method ~FillAdjacencyLists~
Fill adjacency list of network
*/
void Network::FillAdjacencyLists()
{
////////////////////////////////////////////////////////////////////
//In a first step all pairs of adjacent sections will be collected
GenericRelationIterator* pJunctionsIt = m_pJunctions->MakeScan();
Tuple* pCurrentJunction;
vector<DirectedSectionPair> xList;
while ( ( pCurrentJunction = pJunctionsIt->GetNextTuple() ) != 0 )
{
// Retrieve the connectivity code
int iCc =
(( CcInt* ) pCurrentJunction->GetAttribute ( JUNCTION_CC ))->GetIntval();
ConnectivityCode xCc ( iCc );
// Retrieve the four sections - if they exist
TupleId tidpAUp, tidpADown, tidpBUp, tidpBDown;
tidpAUp = (( TupleIdentifier* )pCurrentJunction
->GetAttribute ( JUNCTION_SECTION_AUP_RC ))->GetTid();
tidpADown =(( TupleIdentifier* )pCurrentJunction
->GetAttribute ( JUNCTION_SECTION_ADOWN_RC ))->GetTid();
tidpBUp = ( ( TupleIdentifier* )pCurrentJunction
->GetAttribute ( JUNCTION_SECTION_BUP_RC ))->GetTid();
tidpBDown = ( ( TupleIdentifier* )pCurrentJunction
->GetAttribute ( JUNCTION_SECTION_BDOWN_RC ))->GetTid();
// If a section is existing and the transition is possible
// it will be added to the list.
FillAdjacencyPair ( tidpAUp, false, tidpAUp, true,
xCc, AUP_AUP, xList );
FillAdjacencyPair ( tidpAUp, false, tidpADown, false,
xCc, AUP_ADOWN, xList);
FillAdjacencyPair ( tidpAUp, false, tidpBUp, true,
xCc, AUP_BUP, xList );
FillAdjacencyPair ( tidpAUp, false, tidpBDown, false,
xCc, AUP_BDOWN, xList);
FillAdjacencyPair ( tidpADown, true, tidpAUp, true,
xCc, ADOWN_AUP, xList );
FillAdjacencyPair ( tidpADown, true, tidpADown, false,
xCc,ADOWN_ADOWN,xList);
FillAdjacencyPair ( tidpADown, true, tidpBUp, true,
xCc, ADOWN_BUP, xList );
FillAdjacencyPair ( tidpADown, true, tidpBDown, false,
xCc,ADOWN_BDOWN,xList);
FillAdjacencyPair ( tidpBUp, false, tidpAUp, true,
xCc, BUP_AUP, xList );
FillAdjacencyPair ( tidpBUp, false, tidpADown, false,
xCc, BUP_ADOWN, xList);
FillAdjacencyPair ( tidpBUp, false, tidpBUp, true,
xCc, BUP_BUP, xList );
FillAdjacencyPair ( tidpBUp, false, tidpBDown, false,
xCc, BUP_BDOWN, xList);
FillAdjacencyPair ( tidpBDown, true, tidpAUp, true,
xCc, BDOWN_AUP, xList );
FillAdjacencyPair ( tidpBDown, true, tidpADown, false,
xCc,BDOWN_ADOWN,xList);
FillAdjacencyPair ( tidpBDown, true, tidpBUp, true,
xCc,BDOWN_BUP, xList );
FillAdjacencyPair ( tidpBDown, true, tidpBDown, false,
xCc,BDOWN_BDOWN,xList);
pCurrentJunction->DeleteIfAllowed();
}
delete pJunctionsIt;
////////////////////////////////////////////////////////////////////
// Now - as the second step the adjacency lists are filled.
// Sort the list by the first directed section
sort ( xList.begin(), xList.end() );
//m_pSections contains a sorted List of all sections
//xList contains all neightbours of one section, if a section has no
//neighbours, there is no Entry in xList for this section
//search all neighbours of a section
DirectedSectionPair xLastPair; //stored the last Entry
TupleId actTid = 1; //actual TupleId of the section to be processed
int counterN = 0; //counts the neighbours of one section
bool flag = true; //toggelt after a pageEntry for section without neighbours
DirectedSection actDS = DirectedSection (actTid, flag);
DirectedSection lastDS = DirectedSection(m_pSections->GetNoTuples(),false);
PageRecord actPage = PageRecord(0);
int actPageNum = 1;
int actSlotNum = 1;
m_xAdjacencyList.clean();
//*****************************************************************
// First step to fill the adjacencylist is to identify the number of
// neighbours to calculate the necessery space for a section.
for ( size_t i = 0; i < xList.size(); i++ ){
// Get next entry
DirectedSectionPair xPair = xList[i];
//Special treatment for the first Entry
if(i==0){
//set last Element
xLastPair = xPair;
//collect all Sections without neighbours,
//there are listed befor the first Entry
while(xPair.m_iFirstSectionTid != actDS.GetSectionTid()
|| xPair.m_bFirstUpDown != actDS.GetUpDownFlag()){
// if there is a section without neighbours put it in pageRecord
if(xPair.m_iFirstSectionTid != actDS.GetSectionTid()
|| xPair.m_bFirstUpDown != actDS.GetUpDownFlag()){
//get sid, meas1, meas2 and rid
Tuple *pSect =
m_pSections->GetTuple (actDS.GetSectionTid(),false );
double actMeas1 =
((CcReal*)pSect->GetAttribute(SECTION_MEAS1))->GetRealval();
double actMeas2 =
((CcReal*)pSect->GetAttribute(SECTION_MEAS2))->GetRealval();
int actRid =
(( CcInt* )pSect->GetAttribute(SECTION_RID))->GetIntval();
double actCost =
(( CcReal* )pSect->GetAttribute(SECTION_COST))->GetRealval();
double actDuration =
((CcReal*)pSect->GetAttribute(SECTION_DURATION))->GetRealval();
int actSid =
((CcInt* )pSect->GetAttribute(SECTION_SID))->GetIntval();
// stored Section-Information in page
bool success = actPage.SetSectionContent(
actDS.GetSectionTid(),actSid, actDS.GetUpDownFlag(),
actMeas1,actMeas2,actRid,actCost, actDuration, 0,
actSlotNum);
if(!success){
// page was full, store the pagerecord in adjacencylist
m_xAdjacencyList.Append(actPage);
// reset actSlotNum to 1 and increment actPageNum
actSlotNum = 1;
actPageNum++;
//create a new Page and stored section information there
actPage = PageRecord(0);
actPage.SetSectionContent(
actDS.GetSectionTid(),actSid, actDS.GetUpDownFlag(),
actMeas1,actMeas2, actRid, actCost, actDuration , 0,
actSlotNum);
}
//stored PageNum and SlotNum in Section
vector<int> xIndices;
vector<Attribute*> xAttrs;
if(actDS.GetUpDownFlag()){
xIndices.push_back (SECTION_PNO_UP);
xIndices.push_back (SECTION_SLOT_UP);
}else{
xIndices.push_back (SECTION_PNO_DOWN);
xIndices.push_back (SECTION_SLOT_DOWN);
}
xAttrs.push_back ( new CcInt(true,actPageNum) );
xAttrs.push_back ( new CcInt(true,actSlotNum) );
m_pSections->UpdateTuple(pSect, xIndices, xAttrs);
pSect->DeleteIfAllowed();
//increment actSlotNum
actSlotNum++;
}
//set next actDirectedSection to be processed
if(flag){
flag = false;
} else {
flag= true;
actTid++;
}
actDS = DirectedSection(actTid,flag);
}
}
// Entry in adjacency list if all sections adjacent to one section have
// been found. This is the case every time the first section changes.
// Never at the first entry and always at the last.
if (i == xList.size() -1 ||
(i != 0 &&
(xLastPair.m_iFirstSectionTid != xPair.m_iFirstSectionTid
|| xLastPair.m_bFirstUpDown != xPair.m_bFirstUpDown))){
if(i==xList.size() -1){
counterN++; //last entry, the counter must increment
}
//all neighbours of a section are found,
//so put the section on the pageRecord
//get sid, meas1, meas2 and rid
Tuple *pSect =
m_pSections->GetTuple (xLastPair.m_iFirstSectionTid,false );
double actMeas1 =
((CcReal*) pSect->GetAttribute (SECTION_MEAS1))->GetRealval();;
double actMeas2 =
((CcReal*) pSect->GetAttribute (SECTION_MEAS2))->GetRealval();
int actRid =
(( CcInt* )pSect->GetAttribute(SECTION_RID))->GetIntval();
double actCost =
(( CcReal* )pSect->GetAttribute(SECTION_COST))->GetRealval();
double actDuration =
(( CcReal* )pSect->GetAttribute(SECTION_DURATION))->GetRealval();
int actSid =
((CcInt*)pSect->GetAttribute(SECTION_SID))->GetIntval();
// stored Section-Information in page
bool success = actPage.SetSectionContent(
xLastPair.m_iFirstSectionTid,actSid, xLastPair.m_bFirstUpDown,
actMeas1,actMeas2,actRid,actCost, actDuration, counterN,
actSlotNum);
if(!success){
// page was full, store the pagerecord in adjacencylist
m_xAdjacencyList.Append(actPage);
// reset actSlotNum to 1 and increment actPageNum
actSlotNum = 1;
actPageNum++;
//create a new Page and stored the section information there
actPage = PageRecord(0);
actPage.SetSectionContent(
xLastPair.m_iFirstSectionTid,actSid,
xLastPair.m_bFirstUpDown,actMeas1, actMeas2, actRid,
actCost, actDuration , counterN, actSlotNum);
}
//stored PageNum and SlotNum in Section
vector<int> xIndices;
vector<Attribute*> xAttrs;
if(xLastPair.m_bFirstUpDown){
xIndices.push_back (SECTION_PNO_UP);
xIndices.push_back (SECTION_SLOT_UP);
}else{
xIndices.push_back (SECTION_PNO_DOWN);
xIndices.push_back (SECTION_SLOT_DOWN);
}
xAttrs.push_back ( new CcInt(true,actPageNum) );
xAttrs.push_back ( new CcInt(true,actSlotNum) );
m_pSections->UpdateTuple(pSect, xIndices, xAttrs);
pSect->DeleteIfAllowed();
//increment actSlotNum
actSlotNum++;
//check, if sections are between the last and the actual Entry
//exist, which have no neighbours
while(xPair.m_iFirstSectionTid != actDS.GetSectionTid()
|| xPair.m_bFirstUpDown != actDS.GetUpDownFlag()){
//set next actDirectedSection to be processed
if(flag){
flag = false;
} else {
flag= true;
actTid++;
}
actDS = DirectedSection(actTid,flag);
//if there is a section without neighbours put it in pageRecord
if(xPair.m_iFirstSectionTid != actDS.GetSectionTid()
|| xPair.m_bFirstUpDown != actDS.GetUpDownFlag()){
//get sid, meas1, meas2 and rid
Tuple *pSect =
m_pSections->GetTuple (actDS.GetSectionTid(),false );
double actMeas1 =
((CcReal*)pSect->GetAttribute(SECTION_MEAS1))->GetRealval();
double actMeas2 =
((CcReal*)pSect->GetAttribute(SECTION_MEAS2))->GetRealval();
int actRid =
(( CcInt* )pSect->GetAttribute(SECTION_RID))->GetIntval();
double actCost =
((CcReal* )pSect->GetAttribute(SECTION_COST))->GetRealval();
double actDuration =
((CcReal*)pSect->GetAttribute(SECTION_DURATION))->GetRealval();
int actSid =
((CcInt*)pSect->GetAttribute(SECTION_SID))->GetIntval();
// stored Section-Information in page
bool success = actPage.SetSectionContent(
actDS.GetSectionTid(),actSid, actDS.GetUpDownFlag(),
actMeas1, actMeas2,actRid, actCost,actDuration , 0,
actSlotNum);
if(!success){
// page was full, store the pagerecord in adjacencylist
m_xAdjacencyList.Append(actPage);
// reset actSlotNum to 1 and increment actPageNum
actSlotNum = 1;
actPageNum++;
//create a new Page and stored section information there
actPage = PageRecord(0);
actPage.SetSectionContent(
actDS.GetSectionTid(),actSid, actDS.GetUpDownFlag(),
actMeas1, actMeas2,actRid, actCost, actDuration , 0,
actSlotNum);
}
//stored PageNum and SlotNum in Section
vector<int> xIndices;
vector<Attribute*> xAttrs;
if(actDS.GetUpDownFlag()){
xIndices.push_back (SECTION_PNO_UP);
xIndices.push_back (SECTION_SLOT_UP);
}else{
xIndices.push_back (SECTION_PNO_DOWN);
xIndices.push_back (SECTION_SLOT_DOWN);
}
xAttrs.push_back ( new CcInt(true,actPageNum) );
xAttrs.push_back ( new CcInt(true,actSlotNum) );
m_pSections->UpdateTuple(pSect, xIndices, xAttrs);
pSect->DeleteIfAllowed();
//increment actSlotNum
actSlotNum++;
}
}
// reset the counter of neighbours after the Entry in the pageRecord
counterN =0;
}
// Check if entry allready exists in list. As the list is sorted it
// has to be the entry before.
if ( i == 0 ||
xLastPair.m_iFirstSectionTid != xPair.m_iFirstSectionTid ||
xLastPair.m_bFirstUpDown != xPair.m_bFirstUpDown ||
xLastPair.m_iSecondSectionTid != xPair.m_iSecondSectionTid ||
xLastPair.m_bSecondUpDown != xPair.m_bSecondUpDown )
{
counterN++; // the counter of neighbours must increment
}
//check, if sections after the last Entry exist, that have no neighbours
if (i == xList.size() -1){
while(lastDS.GetSectionTid() != actDS.GetSectionTid()
|| lastDS.GetUpDownFlag() != actDS.GetUpDownFlag()){
//set next actDirectedSection to be processed
if(flag){
flag = false;
} else {
flag= true;
actTid++;
}
actDS = DirectedSection(actTid,flag);
// if there is a section without neighbours put it in pageRecord
if(lastDS.GetSectionTid() != actDS.GetSectionTid()
|| lastDS.GetUpDownFlag() != actDS.GetUpDownFlag()){
//get sid, meas1,meas2and rid
Tuple *pSect =
m_pSections->GetTuple (actDS.GetSectionTid(),false );
double actMeas1 =
((CcReal*)pSect->GetAttribute(SECTION_MEAS1))->GetRealval();
double actMeas2 =
((CcReal*)pSect->GetAttribute(SECTION_MEAS2))->GetRealval();
int actRid =
(( CcInt* )pSect->GetAttribute(SECTION_RID))->GetIntval();
double actCost =
(( CcReal*)pSect->GetAttribute(SECTION_COST))->GetRealval();
double actDuration =
((CcReal*)pSect->GetAttribute(SECTION_DURATION))->GetRealval();
int actSid =
((CcInt*)pSect->GetAttribute(SECTION_SID))->GetIntval();
// stored Section-Information in page
bool success = actPage.SetSectionContent(
actDS.GetSectionTid(),actSid, actDS.GetUpDownFlag(),
actMeas1, actMeas2, actRid, actCost, actDuration , 0,
actSlotNum);
if(!success){
// page was full, store the pagerecord in adjacencylist
m_xAdjacencyList.Append(actPage);
// reset actSlotNum to 1 and increment actPageNum
actSlotNum = 1;
actPageNum++;
//create a new Page and stored section information there
actPage = PageRecord(0);
actPage.SetSectionContent(
actDS.GetSectionTid(),actSid, actDS.GetUpDownFlag(),
actMeas1, actMeas2, actRid, actCost, actDuration ,0,
actSlotNum);
}
//stored PageNum and SlotNum in Section
vector<int> xIndices;
vector<Attribute*> xAttrs;
if(actDS.GetUpDownFlag()){
xIndices.push_back (SECTION_PNO_UP);
xIndices.push_back (SECTION_SLOT_UP);
}else{
xIndices.push_back (SECTION_PNO_DOWN);
xIndices.push_back (SECTION_SLOT_DOWN);
}
xAttrs.push_back ( new CcInt(true,actPageNum) );
xAttrs.push_back ( new CcInt(true,actSlotNum) );
m_pSections->UpdateTuple(pSect, xIndices, xAttrs);
pSect->DeleteIfAllowed();
//increment actSlotNum
actSlotNum++;
}
}
}
// set last Entry
xLastPair = xPair;
}
if(xList.size()!= 0){
// store last Page in the AdjacencyList
m_xAdjacencyList.Append(PageRecord(actPage));
}
m_xAdjacencyList.TrimToSize();
//
//*****************************************************************
// Second step to fill the adjacencylist is to set all pagenumbers and
// Slotindex for the neighbours of a section. Because that information
// is collected in the first Step.
actPageNum =0; // reset old used variable for actual PageNumber
actSlotNum =0; // reset old used variable for actual SlotNumber
actPage = PageRecord(0); // reset old used variable for actual Page
DirectedSectionPair actPair;// actual read sectionPair from xList
DirectedSectionPair lastPair;
int nCounter=0;// counts the proceeded neighbours start even by 0
int actNPage,actNSlot; // actual PageNR and SlotNR of a Neighboursection
TupleId nSTid; // sectionid and UpDownFlag of a neighbour
bool nUpD;
size_t actIndex = 0; // actual Index of the xList
while(actIndex < xList.size()){
//get actual element
actPair = xList[actIndex];
// get actual Tuple from section relation
Tuple *pSect = m_pSections->GetTuple (actPair.m_iFirstSectionTid,false);
// get page and slotnumber of this DirectionPair
if (actPair.m_bFirstUpDown){
actPageNum =((CcInt*)pSect->GetAttribute(SECTION_PNO_UP))->GetIntval();
actSlotNum =((CcInt*)pSect->GetAttribute(SECTION_SLOT_UP))->GetIntval();
}else{
actPageNum=((CcInt*)pSect->GetAttribute(SECTION_PNO_DOWN))->GetIntval();
actSlotNum=((CcInt*)pSect->GetAttribute(SECTION_SLOT_DOWN))->GetIntval();
}
// get page, where the actual section is stored
m_xAdjacencyList.Get(actPageNum-1, actPage);
nCounter =0;
// at first element strored this as last element
if(actIndex == 0){
lastPair = actPair;
}
while(actIndex==0 ||
(actPair.m_iFirstSectionTid== lastPair.m_iFirstSectionTid
&& actPair.m_bFirstUpDown==lastPair.m_bFirstUpDown)){
if(actIndex !=0 &&
!(lastPair.m_iSecondSectionTid == xList[actIndex].m_iSecondSectionTid
&& lastPair.m_bSecondUpDown ==xList[actIndex].m_bSecondUpDown)){
// read nSid and nUpD form xList
nSTid = lastPair.m_iSecondSectionTid;
nUpD = lastPair.m_bSecondUpDown;
// for each Entry stored Information
Tuple *pNSect = m_pSections->GetTuple (nSTid,false );
if (nUpD){
actNPage =
(( CcInt* )pNSect->GetAttribute(SECTION_PNO_UP))->GetIntval();
actNSlot =
(( CcInt* )pNSect->GetAttribute(SECTION_SLOT_UP))->GetIntval();
}else{
actNPage =
(( CcInt* )pNSect->GetAttribute(SECTION_PNO_DOWN))->GetIntval();
actNSlot =
(( CcInt* )pNSect->GetAttribute(SECTION_SLOT_DOWN))->GetIntval();
}
pNSect->DeleteIfAllowed();
// Update the Information on the page
actPage.SetSectionNeighbour(actSlotNum,nCounter,actNPage,actNSlot);
nCounter++;
}
lastPair = xList[actIndex];
actIndex++;
}
// Delete section Tupel if allowed
pSect->DeleteIfAllowed();
//page stored back in the adjacencyList
// get page, where the actual section is stored
m_xAdjacencyList.Put(actPageNum-1, actPage);
//Reset all used values
actPageNum=0;
actSlotNum=0;
actPage=PageRecord(0);
}
// test output
//of the content from xList, m_xAdjacencyList, m_xSubAdjacencyList
// and all neighbourSection which are issued from GetAdjacentSections()
/* cout << "Output of xList:" <<endl;
DirectedSectionPair actDSP;
for(size_t i=0; i< xList.size();i++){
cout << "[(" << xList[i].m_iFirstSectionTid << ","
<< xList[i].m_bFirstUpDown << ")"
<< "(" << xList[i].m_iSecondSectionTid << ","
<< xList[i].m_bSecondUpDown << ")]" <<endl;
}
//print all information which are stored in the PageRecord
PrintAdjacentSectionInfo();
cout << "output all neighbours with GetAdjacentSections:" << endl;
vector<DirectedSection> actVDS;
for (int i=1; i<= m_pSections->GetNoTuples();i++){
actVDS.clear();
cout << "Sec:(" << i <<",0): [";
GetAdjacentSections(i,false,actVDS);
for(size_t k=0; k<actVDS.size();k++){
cout <<"("<< actVDS[k].GetSectionTid() << ","
<< actVDS[k].GetUpDownFlag() <<")";
}
cout << "]" << endl;
actVDS.clear();
cout << "Sec:(" << i <<",1): [";
GetAdjacentSections(i,true,actVDS);
for(size_t k=0; k<actVDS.size();k++){
cout <<"("<< actVDS[k].GetSectionTid() << ","
<< actVDS[k].GetUpDownFlag() <<")";
}
cout << "]" << endl;
}
//statistic output of the numbers of neighbours
CountNeighbours(xList); */
}
/*
Method ~FillAdjacencyPair~
Build vector of directed section pairs.
*/
void Network::FillAdjacencyPair ( TupleId in_pFirstSection,
bool in_bFirstUp,
TupleId in_pSecondSection,
bool in_bSecondUp,
ConnectivityCode in_xCc,
Transition in_xTransition,
vector<DirectedSectionPair> &inout_xPairs )
{
if ( in_pFirstSection != 0 &&
in_pSecondSection != 0 &&
in_xCc.IsPossible ( in_xTransition ) )
{
inout_xPairs.push_back ( DirectedSectionPair ( in_pFirstSection,
in_bFirstUp,
in_pSecondSection,
in_bSecondUp ) );
}
}
/*
Method ~PrintAdjacentSectionInfo~
prints informations of ~sections~ which are stored in a ~PageRecord~.
first output: all ~sections~ with there sectionId and cost-value
second output: all ~routes~ iterated over the startposId
third output: all neighbours-information of the ~sections~
Sec (SectionTupelId,UpDownFlag):[(NeighborSectionTId, UpDownFlag, Meas1, Meas2,
RId, Cost, Time)(..)]
*/
bool Network::PrintAdjacentSectionInfo(){
cout << "output of all Sections: (Section_SId,Section_Cost)"<< endl;
for (int i =1; i<=m_pSections->GetNoTuples();i++){
Tuple *n = m_pSections->GetTuple(i,false);
cout <<"("<< ((CcInt*)n->GetAttribute(SECTION_SID))->GetIntval() << ","
<< ((CcReal*)n->GetAttribute(SECTION_COST))->GetRealval()<< ")"<<endl;
n->DeleteIfAllowed();
}
cout << "ROUTES over startposid: (Routes_Id, Routes_StartposId)" << endl;
BTreeIterator* pRoutesIt = m_pBTreeRoutesByStartposId->SelectAll();
Tuple* pRoute;
while ( pRoutesIt->Next() )
{
pRoute = m_pRoutes->GetTuple(pRoutesIt->GetId(),false);
cout <<"("<< ((CcInt*)pRoute->GetAttribute(ROUTE_ID))->GetIntval() << ","
<< ((CcInt*)pRoute->GetAttribute(ROUTE_STARTPOS_ID))->GetIntval()<< ")"
<<endl;
pRoute->DeleteIfAllowed();
}
delete pRoutesIt;
cout << "output all neighbours with GetAdjacentSectionsInfo" << endl;
cout << "Sec:(SectionTupelId,UpDownFlag):[(NeighborSectionTId,"
<< " UpDownFlag, Meas1, Meas2, RId, Cost, Time)(..)]" << endl;
vector<DirectedSectionInfo> actVDSI;
BTreeIterator* pSectionIt;
pSectionIt = m_pBTreeSections->SelectAll();
while ( pSectionIt->Next() )
{
actVDSI.clear();
TupleId sTid = pSectionIt->GetId();
cout << "Sec:(" << sTid <<",0): [";
GetAdjacentSectionsInfo(sTid,false,actVDSI);
for(size_t k=0; k<actVDSI.size();k++){
cout <<"("<< actVDSI[k].GetSectionTid()<< ","<< actVDSI[k].GetUpDownFlag()
<<","<< actVDSI[k].GetMeas1() << "," << actVDSI[k].GetMeas2() << ","
<< actVDSI[k].GetRid()<<","<< actVDSI[k].GetCost() <<","
<< actVDSI[k].GetDuration()<< ")";
}
cout << "]" << endl;
actVDSI.clear();
cout << "Sec:(" << sTid <<",1): [";
GetAdjacentSectionsInfo(sTid,true,actVDSI);
for(size_t k=0; k<actVDSI.size();k++){
cout <<"("<< actVDSI[k].GetSectionTid()<< ","<< actVDSI[k].GetUpDownFlag()
<<","<< actVDSI[k].GetMeas1() << "," << actVDSI[k].GetMeas2() << ","
<< actVDSI[k].GetRid()<<","<< actVDSI[k].GetCost() <<","
<< actVDSI[k].GetDuration() <<")";
}
cout << "]" << endl;
}
delete pSectionIt;
return true;
}
/*
Method ~CountNeighbours~
calculate the numbers of neighbours of all ~sections~. Only used for internal
debug informations.
*/
void Network::CountNeighbours(vector<DirectedSectionPair> in_xList){
cout << "count all neighbours of all sections:" << endl;
//Counter for neighbours, if more then nine, the counter a10 is increased
int a0=0,a1=0,a2=0,a3=0,a4=0,a5=0,a6=0,a7=0,a8=0,a9=0,a10=0;
int actCounter=0;
DirectedSectionPair xLastPair;
//determin the number of neighbours of the sections
actCounter=0;
//pass through all pairs
for (size_t i=0; i<in_xList.size(); i++){
//get next
DirectedSectionPair xPair = in_xList[i];
//at the first element,remember it as the last pair
if(i==0){
xLastPair = xPair;
actCounter++;
}
if ( i == in_xList.size() -1 ||
(i != 0 &&
( xLastPair.m_iFirstSectionTid != xPair.m_iFirstSectionTid ||
xLastPair.m_bFirstUpDown != xPair.m_bFirstUpDown
)
)
){
switch(actCounter){
case 1: a1++;break;
case 2: a2++;break;
case 3: a3++;break;
case 4: a4++;break;
case 5: a5++;break;
case 6: a6++;break;
case 7: a7++;break;
case 8: a8++;break;
case 9: a9++;break;
default: a10++;
}
actCounter = 0;
}
if ( i == 0 ||
xLastPair.m_iFirstSectionTid != xPair.m_iFirstSectionTid ||
xLastPair.m_bFirstUpDown != xPair.m_bFirstUpDown ||
xLastPair.m_iSecondSectionTid != xPair.m_iSecondSectionTid ||
xLastPair.m_bSecondUpDown != xPair.m_bSecondUpDown ){
actCounter++;
}
xLastPair = xPair;
}
//determine sections without neighbours
a0 = (m_pSections->GetNoTuples() *2) -(a1+a2+a3+a4+a5+a6+a7+a8+a9+a10);
// output of the results
cout << "sections without neighbours: " << a0 << endl;
cout << "sections with one neighbour: " << a1 << endl;
cout << "sections with two neighbours: " << a2 << endl;
cout << "sections with three neighbours: " << a3 << endl;
cout << "sections with four neighbours: " << a4<< endl;
cout << "sections with five neighbours: " << a5 << endl;
cout << "sections with six neighbours: " << a6 << endl;
cout << "sections with seven neighbours: " << a7 << endl;
cout << "sections with eight neighbours: " << a8 << endl;
cout << "sections with nine neighbours: " << a9 << endl;
cout << "sections with more than nine neighbours : " << a10 << endl;
}
/*
Method ~InShortestPath~
*/
bool Network::InShortestPath ( GPoint*start,GPoint *to, GLine *result )
{
GPoint* end = new GPoint ( *to );//copy the gpoint
result->Clear();
if ( start == 0 || end == 0 || !start->IsDefined() ||
!end->IsDefined() )
{
sendMessage ( "Both gpoints must exist and be defined." );
result->SetDefined ( false );
end->DeleteIfAllowed();
return false;
}
// Check wether both points belong to the same network
if ( start->GetNetworkId() != end->GetNetworkId() )
{
sendMessage ( "Both gpoints belong to different networks." );
result->SetDefined ( false );
end->DeleteIfAllowed();
return false;
}
result->SetNetworkId ( GetId() );
// Get sections where the path should start or end
Tuple* startSection = GetSectionOnRoute ( start );
if ( startSection == 0 )
{
sendMessage ( "Starting GPoint not found in network." );
result->SetDefined ( false );
end->DeleteIfAllowed();
return false;
}
Tuple* endSection = GetSectionOnRoute ( end );
if ( endSection == 0 )
{
sendMessage ( "End GPoint not found in network." );
startSection->DeleteIfAllowed();
result->SetDefined ( false );
end->DeleteIfAllowed();
return false;
}
////////////////////////////////////////////////////
bool junctionpoint = false;
Point* endp = new Point();
GetPointOnRoute ( end,endp ); //end point
vector<JunctionSortEntry> juns;
CcInt* routeid = new CcInt ( true,end->GetRouteId() );
GetJunctionsOnRoute ( routeid,juns );
for ( unsigned int i = 0;i < juns.size();i++ )
{
Tuple* t = juns[i].m_pJunction;
if ( ( ( CcInt* ) t->GetAttribute ( JUNCTION_ROUTE1_ID ) )->GetIntval() ==
end->GetRouteId() &&
fabs ( ( ( CcReal* ) t->GetAttribute ( JUNCTION_ROUTE1_MEAS )
)->GetRealval()-
end->GetPosition() ) < 0.1 )
junctionpoint = true;
if ( ( ( CcInt* ) t->GetAttribute ( JUNCTION_ROUTE2_ID ) )->GetIntval() ==
end->GetRouteId() &&
fabs ( ( ( CcReal* ) t->GetAttribute ( JUNCTION_ROUTE2_MEAS )
)->GetRealval()-
end->GetPosition() ) < 0.1 )
junctionpoint = true;
}
vector<TupleId> secjunid;
if ( junctionpoint ) //it is a junction point
{
vector<DirectedSection> sectionlist;
if ( fabs ( end->GetPosition()-
( ( CcReal* ) endSection->GetAttribute ( SECTION_MEAS1 )
)->GetRealval() ) < 0.1 )
GetAdjacentSections ( endSection->GetTupleId(),false,sectionlist );
else
GetAdjacentSections ( endSection->GetTupleId(),true,sectionlist );
for ( unsigned int i = 0;i < sectionlist.size();i++ )
{
if ( sectionlist[i].GetSectionTid() != endSection->GetTupleId() )
secjunid.push_back ( sectionlist[i].GetSectionTid() );
}
}
endp->DeleteIfAllowed();
routeid->DeleteIfAllowed();
/////////////////////////////////////////////////////
// Calculate the shortest path using dijkstras algorithm.
TupleId startSectTID = startSection->GetTupleId();
TupleId lastSectTID = endSection->GetTupleId();
if ( startSectTID == lastSectTID )
{
result->AddRouteInterval ( start->GetRouteId(), start->GetPosition(),
end->GetPosition() );
}
else
{
//Initialize PriorityQueue
PrioQueue *prioQ = new PrioQueue ( 0 );
SectIDTree *visitedSect = 0;
double sectMeas1 =
( ( CcReal* ) startSection->GetAttribute ( SECTION_MEAS1 )
)->GetRealval();
double sectMeas2 =
( ( CcReal* ) startSection->GetAttribute ( SECTION_MEAS2 )
)->GetRealval();
double dist = 0.0;
vector<DirectedSection> adjSectionList;
adjSectionList.clear();
if ( start->GetSide() == 0 )
{
dist = start->GetPosition() - sectMeas1;
GetAdjacentSections ( startSectTID, false, adjSectionList );
SectIDTree *startTree = new SectIDTree ( startSectTID,
( TupleId ) numeric_limits<long>::max(),
false,
numeric_limits<int>::max() );
visitedSect = startTree;
for ( size_t i = 0; i < adjSectionList.size(); i++ )
{
DirectedSection actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != startSectTID )
{
PQEntry *actEntry = new PQEntry ( actNextSect.GetSectionTid(), dist,
actNextSect.GetUpDownFlag(),
startSectTID );
prioQ->Insert ( *actEntry, visitedSect ) ;
delete actEntry;
}
}
adjSectionList.clear();
}
else
{
if ( start->GetSide() == 1 )
{
dist = sectMeas2 - start->GetPosition();
SectIDTree *startTree = new SectIDTree ( startSectTID,
( TupleId ) numeric_limits<long>::max(),
true,
numeric_limits<int>::max() );
visitedSect = startTree;
GetAdjacentSections ( startSectTID, true, adjSectionList );
for ( size_t i = 0; i < adjSectionList.size(); i++ )
{
DirectedSection actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != startSectTID )
{
PQEntry *actEntry = new PQEntry ( actNextSect.GetSectionTid(), dist,
actNextSect.GetUpDownFlag(),
startSectTID );
prioQ->Insert ( *actEntry, visitedSect );
delete actEntry;
}
}
adjSectionList.clear();
}
else
{
dist = start->GetPosition() - sectMeas1;
GetAdjacentSections ( startSectTID, false, adjSectionList );
bool first = true;
for ( size_t i = 0; i < adjSectionList.size(); i++ )
{
DirectedSection actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != startSectTID )
{
if ( first )
{
first = false;
SectIDTree *startTree = new SectIDTree ( startSectTID,
( TupleId ) numeric_limits<long>::max(),
false,
numeric_limits<int>::max() );
visitedSect = startTree;
}
PQEntry *actEntry = new PQEntry ( actNextSect.GetSectionTid(), dist,
actNextSect.GetUpDownFlag(),
startSectTID );
prioQ->Insert ( *actEntry, visitedSect );
delete actEntry;
}
}
adjSectionList.clear();
dist = sectMeas2 -start->GetPosition();
GetAdjacentSections ( startSectTID, true, adjSectionList );
for ( size_t i = 0; i < adjSectionList.size(); i++ )
{
DirectedSection actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != startSectTID )
{
if ( first )
{
first = false;
SectIDTree *startTree = new SectIDTree ( startSectTID,
( TupleId ) numeric_limits<long>::max(),
true,
numeric_limits<int>::max() );
visitedSect = startTree;
}
PQEntry *actEntry = new PQEntry ( actNextSect.GetSectionTid(), dist,
actNextSect.GetUpDownFlag(),
startSectTID );
prioQ->Insert ( *actEntry, visitedSect );
delete actEntry;
}
}
adjSectionList.clear();
}
}
// Use priorityQueue to find shortestPath.
PQEntry *actPQEntry;
bool found = false;
while ( !prioQ->IsEmpty() && !found )
{
actPQEntry = prioQ->GetAndDeleteMin ( visitedSect );
Tuple *actSection = GetSection ( actPQEntry->sectID );
sectMeas1 =
( ( CcReal* ) actSection->GetAttribute ( SECTION_MEAS1 )
)->GetRealval();
sectMeas2 =
( ( CcReal* ) actSection->GetAttribute ( SECTION_MEAS2 )
)->GetRealval();
dist = actPQEntry->distFromStart + fabs ( sectMeas2 - sectMeas1 );
//////////////////////////////////////
if ( junctionpoint ) //end point is a junction point
{
for ( unsigned int i = 0;i < secjunid.size();i++ )
{
if ( secjunid[i] == actPQEntry->sectID )
{
lastSectTID = actPQEntry->sectID;
Tuple* sect = GetSection ( lastSectTID );
double m1 =
( ( CcReal* ) sect->GetAttribute ( SECTION_MEAS1 )
)->GetRealval();
double m2 =
( ( CcReal* ) sect->GetAttribute ( SECTION_MEAS2 )
)->GetRealval();
if ( actPQEntry->upDownFlag )
{
GPoint* temp = new GPoint ( true,end->GetNetworkId(),
end->GetRouteId(),m2,None );
*end = *temp;
temp->DeleteIfAllowed();
}
else
{
GPoint* temp = new GPoint ( true,end->GetNetworkId(),
end->GetRouteId(),m1,None );
*end = *temp;
temp->DeleteIfAllowed();
}
sect->DeleteIfAllowed();
break;
}
}
}
////////////////////////////////////
if ( actPQEntry->sectID != lastSectTID )
{
//Search further in the network unitl reached last section.
//Get adjacent sections and insert into priority Queue.
adjSectionList.clear();
GetAdjacentSections ( actPQEntry->sectID,
actPQEntry->upDownFlag,
adjSectionList );
for ( size_t i = 0; i <adjSectionList.size();i++ )
{
DirectedSection actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != actPQEntry->sectID )
{
PQEntry *actEntry = new PQEntry ( actNextSect.GetSectionTid(),
dist,
actNextSect.GetUpDownFlag(),
actPQEntry->sectID );
prioQ->Insert ( *actEntry, visitedSect );
delete actEntry;
}
}
delete actPQEntry;
actSection->DeleteIfAllowed();
}
else
{
// Shortest Path found.
// Compute last route interval and resulting gline.
found = true;
double startRI, endRI;
int actRouteId =
( ( CcInt* ) actSection->GetAttribute ( SECTION_RID )
)->GetIntval();
if ( actPQEntry->upDownFlag == true )
{
startRI = sectMeas1;
endRI = end->GetPosition();
}
else
{
startRI = sectMeas2;
endRI = end->GetPosition();
}
actSection->DeleteIfAllowed();
//Get the sections used for shortest path and write them in right
//order (from start to end ) in the resulting gline. Because dijkstra gives
//the sections from end to start we first have to put the result sections on a
//stack to turn in right order.
RIStack *riStack = new RIStack ( actRouteId, startRI, endRI );
TupleId lastSectId = actPQEntry->sectID;
SectIDTree *pElem = visitedSect->Find ( actPQEntry->beforeSectID );
bool end = false;
bool upDown;
// if (startRI >= endRI) upDown = false;
if ( startRI > endRI || fabs ( startRI-endRI ) < 0.1 ) upDown = false;
else upDown = true;
while ( !end )
{
//GetSection
actSection = GetSection ( pElem->sectID );
actRouteId =
( ( CcInt* ) actSection->GetAttribute ( SECTION_RID )
)->GetIntval();
sectMeas1 =
( ( CcReal* ) actSection->GetAttribute ( SECTION_MEAS1 )
)->GetRealval();
sectMeas2 =
( ( CcReal* ) actSection->GetAttribute ( SECTION_MEAS2 )
)->GetRealval();
upDown = pElem->upDownFlag;
if ( pElem->sectID != startSectTID )
{
if ( upDown )
riStack->Push ( actRouteId, sectMeas1, sectMeas2, riStack );
else
riStack->Push ( actRouteId, sectMeas2, sectMeas1, riStack );
lastSectId = pElem->sectID;
pElem = visitedSect->Find ( pElem->beforeSectId );
}
else
{
end = true;
GetAdjacentSections ( startSectTID, true, adjSectionList );
size_t i = 0;
bool stsectfound = false;
while ( i < adjSectionList.size() && !stsectfound )
{
DirectedSection adjSection = adjSectionList[i];
if ( adjSection.GetSectionTid() == lastSectId )
{
if ( fabs ( start->GetPosition()-sectMeas2 ) > 0.1 )
{
stsectfound = true;
riStack->Push ( actRouteId, start->GetPosition(), sectMeas2,
riStack );
end = true;
}
}
i++;
}
adjSectionList.clear();
if ( !stsectfound )
{
GetAdjacentSections ( startSectTID, false,
adjSectionList );
i = 0;
while ( i < adjSectionList.size() && !stsectfound )
{
DirectedSection adjSection = adjSectionList[i];
if ( adjSection.GetSectionTid() == lastSectId )
{
if ( fabs ( start->GetPosition() - sectMeas1 ) > 0.1 )
{
stsectfound = true;
riStack->Push ( actRouteId, start->GetPosition(), sectMeas1,
riStack );
end = true;
}
}
i++;
}
adjSectionList.clear();
}
}
}
// Cleanup and return result
riStack->StackToGLine ( result );
riStack->RemoveStack();
delete actPQEntry;
}
}
visitedSect->Remove();
prioQ->Destroy();
delete prioQ;
}
startSection->DeleteIfAllowed();
endSection->DeleteIfAllowed();
result->SetSorted ( false );
result->SetDefined ( true );
result->TrimToSize();
end->DeleteIfAllowed();
return true;
};
/*
Method ~FindSP~
*/
void Network::FindSP ( TupleId j1,TupleId j2,double& length,GLine* res )
{
res->SetNetworkId ( GetId() );
for ( int i = 1; i <= alldistance->GetNoTuples();i++ )
{
Tuple* tuple = alldistance->GetTuple ( i, false );
TupleId jun1 = ( ( CcInt* ) tuple->GetAttribute ( 0 ) )->GetIntval();
TupleId jun2 = ( ( CcInt* ) tuple->GetAttribute ( 1 ) )->GetIntval();
if ( ( jun1 == j1 && jun2 == j2 ) ||
( jun1 ==j2 && jun2 == j1 ) )
{
length = ( ( CcReal* ) tuple->GetAttribute ( 2 ) )->GetRealval();
GLine* gline = ( GLine* ) tuple->GetAttribute ( 3 );
*res = *gline;
tuple->DeleteIfAllowed();
break;
}
tuple->DeleteIfAllowed();
}
res->TrimToSize();
}
/*
Method ~FillDistanceStorage~
*/
void Network::FillDistanceStorage()
{
ListExpr xType;
nl->ReadFromString ( distancestorageTypeInfo,xType );
ListExpr xNumType = SecondoSystem::GetCatalog()->NumericType ( xType );
alldistance = new Relation ( xNumType );
//store the distance between each two junction points
for ( int i = 1;i <= m_pJunctions->GetNoTuples();i++ )
{
for ( int j = i+1; j <= m_pJunctions->GetNoTuples();j++ )
{
Tuple* jun1 = m_pJunctions->GetTuple ( i, false );
Tuple* jun2 = m_pJunctions->GetTuple ( j , false);
int rid1 = ( ( CcInt* ) jun1->GetAttribute ( JUNCTION_ROUTE1_ID )
)->GetIntval();
int rid2 = ( ( CcInt* ) jun2->GetAttribute ( JUNCTION_ROUTE1_ID )
)->GetIntval();
float pos1 =
( ( CcReal* ) jun1->GetAttribute ( JUNCTION_ROUTE1_MEAS )
)->GetRealval();
float pos2 =
( ( CcReal* ) jun2->GetAttribute ( JUNCTION_ROUTE1_MEAS )
)->GetRealval();
Side side = None;
Point* p1 = ( Point* ) jun1->GetAttribute ( JUNCTION_POS );
Point* p2 = ( Point* ) jun2->GetAttribute ( JUNCTION_POS );
if ( fabs ( p1->GetX()-p2->GetX() ) < 0.1 &&
fabs ( p1->GetY()-p2->GetY() ) < 0.1 ) //different junction point
continue;
GPoint* gp1 = new GPoint ( true,GetId(),rid1,pos1,side );
GPoint* gp2 = new GPoint ( true,GetId(),rid2,pos2,side );
Tuple* tuple = new Tuple ( nl->Second ( xNumType ) );
tuple->PutAttribute ( 0,new TupleIdentifier ( true,i ) );
tuple->PutAttribute ( 1,new TupleIdentifier ( true,j ) );
GLine* gline = new GLine ( 0 );
assert ( InShortestPath ( gp1,gp2,gline ) );
tuple->PutAttribute ( 2,new CcReal ( true,gline->GetLength() ) );
GLine* temp = new GLine ( 0 );
temp->SetNetworkId ( gline->GetNetworkId() );
RouteInterval ri;
gline->Get ( 0,ri );
temp->AddRouteInterval ( ri );//head
gline->Get ( gline->Size()-1,ri );
temp->AddRouteInterval ( ri );//tail
tuple->PutAttribute ( 3,new GLine ( temp ) );
temp->DeleteIfAllowed();
gline->DeleteIfAllowed();
alldistance->AppendTuple ( tuple );
tuple->DeleteIfAllowed();
gp1->DeleteIfAllowed();
gp2->DeleteIfAllowed();
}
}
}
/*
Method ~UpdateSectionCost~
update the cost of a given ~section~
returns ~true~, if the update was successful, otherwise ~false~
*/
bool Network::UpdateSectionCost(int sectId,double newCost){
BTreeIterator* pSectIter;
CcInt* ciSectId = new CcInt(true,sectId);
pSectIter = m_pBTreeSections->ExactMatch (ciSectId);
delete ciSectId;
if(pSectIter->Next()){
//get act Tuple
Tuple *actSect = 0;
actSect = m_pSections->GetTuple(pSectIter->GetId(), false);
//save cost in the section relation
vector<int> xIndices;
vector<Attribute*> xAttrs;
xIndices.push_back ( SECTION_COST );
xAttrs.push_back ( new CcReal ( true, newCost ) );
m_pSections->UpdateTuple(actSect, xIndices, xAttrs);
//save cost in the PageRecord of the section
// read pages und Slots
int pageUp =
((CcInt* )actSect->GetAttribute(SECTION_PNO_UP))->GetIntval();
int slotUp =
((CcInt* )actSect->GetAttribute(SECTION_SLOT_UP))->GetIntval();
int pageDown =
((CcInt* )actSect->GetAttribute(SECTION_PNO_DOWN))->GetIntval();
int slotDown =
((CcInt* )actSect->GetAttribute(SECTION_SLOT_DOWN))->GetIntval();
//get the page and save cost for both entries
PageRecord actPage =PageRecord(0);
m_xAdjacencyList.Get(pageUp-1, actPage);
actPage.SetSectionCost(slotUp, newCost);
if(pageDown == pageUp){
actPage.SetSectionCost(slotDown, newCost);
m_xAdjacencyList.Put(pageUp-1, actPage);
}else{
m_xAdjacencyList.Put(pageUp-1, actPage);
m_xAdjacencyList.Get(pageDown-1, actPage);
actPage.SetSectionCost(slotDown, newCost);
m_xAdjacencyList.Put(pageDown-1, actPage);
}
//clean up
actSect->DeleteIfAllowed();
delete pSectIter;
return true;
}
else {
//errormessage
sendMessage ( "the section with the given SectId must exist." );
cout << "the section " <<sectId <<" doesn't exist." <<endl;
//clean up
delete pSectIter;
return false;
}
}
/*
Method ~UpdateMoreSectionCost~
update the cost of some ~sections~ which are in the given relation.
returns ~true~, if the update was successful, otherwise ~false~
*/
bool Network::UpdateMoreSectionCost(const Relation* in_pCosts){
//DEBUG PrintAdjacentSectionInfo();
// check input
if(in_pCosts->GetNoTuples() >0){
//for each tuple of the Relation
for(int i=1; i<=in_pCosts->GetNoTuples();i++){
//Get sid and cost
Tuple *actTuple = 0;
actTuple = in_pCosts->GetTuple(i, false);
int sid = ((CcInt*)actTuple->GetAttribute(0))->GetIntval();
double cost = ((CcReal*)actTuple->GetAttribute(1))->GetRealval();
//call the function UpdateSectionCost(sid,cost)
UpdateSectionCost(sid,cost);
// clean up
actTuple->DeleteIfAllowed();
}
//DEBUG PrintAdjacentSectionInfo();
return true;
}else{
sendMessage ( "the relation is empty." );
cout << "the relation is empty." <<endl;
return false;
}
}
/*
Method ~UpdateSectionDuration~
update the duration of a given ~section~
returns ~true~, if the update was successful, otherwise ~false~
*/
bool Network::UpdateSectionDuration(int sectId,double newDuration){
BTreeIterator* pSectIter;
CcInt* ciSectId = new CcInt(true,sectId);
pSectIter = m_pBTreeSections->ExactMatch (ciSectId);
delete ciSectId;
if(pSectIter->Next()){
//get act Tuple
Tuple *actSect = 0;
actSect = m_pSections->GetTuple(pSectIter->GetId(), false);
//save duration in the section relation
vector<int> xIndices;
vector<Attribute*> xAttrs;
xIndices.push_back ( SECTION_DURATION );
xAttrs.push_back ( new CcReal ( true, newDuration ) );
m_pSections->UpdateTuple(actSect, xIndices, xAttrs);
//save duration in the PageRecord of the section
// read pages und Slots
int pageUp =
((CcInt* )actSect->GetAttribute(SECTION_PNO_UP))->GetIntval();
int slotUp =
((CcInt* )actSect->GetAttribute(SECTION_SLOT_UP))->GetIntval();
int pageDown =
((CcInt* )actSect->GetAttribute(SECTION_PNO_DOWN))->GetIntval();
int slotDown =
((CcInt* )actSect->GetAttribute(SECTION_SLOT_DOWN))->GetIntval();
//get the page and save duration for both entries
PageRecord actPage;
m_xAdjacencyList.Get(pageUp-1, actPage);
actPage.SetSectionDuration(slotUp, newDuration);
if(pageDown == pageUp){
actPage.SetSectionDuration(slotDown, newDuration);
m_xAdjacencyList.Put(pageUp-1, actPage);
}else{
m_xAdjacencyList.Put(pageUp-1, actPage);
m_xAdjacencyList.Get(pageDown-1, actPage);
actPage.SetSectionDuration(slotDown, newDuration);
m_xAdjacencyList.Put(pageDown-1, actPage);
}
//clean up
actSect->DeleteIfAllowed();
delete pSectIter;
return true;
}
else {
//errormessage
sendMessage ( "the section with the given SectId must exist." );
cout << "the section " <<sectId <<" doesn't exist." <<endl;
//clean up
delete pSectIter;
return false;
}
}
/*
Method ~UpdateMoreSectionDuration~
update the cost of some ~sections~ which are in the given relation.
returns ~true~, if the update was successful, otherwise ~false~
*/
bool Network::UpdateMoreSectionDuration(const Relation* in_pDurations){
//DEBUG PrintAdjacentSectionInfo();
// check input
if(in_pDurations->GetNoTuples() >0){
//for each tuple of the Relation
for(int i=1; i<=in_pDurations->GetNoTuples();i++){
//Get sid and duration
Tuple *actTuple = 0;
actTuple = in_pDurations->GetTuple(i, false);
int sid = ((CcInt*)actTuple->GetAttribute(0))->GetIntval();
double duration =((CcReal*)actTuple->GetAttribute(1))->GetRealval();
//call the function UpdateSectionDuration(sid,duration)
UpdateSectionDuration(sid,duration);
// clean up
actTuple->DeleteIfAllowed();
}
//DEBUG PrintAdjacentSectionInfo();
return true;
}else{
sendMessage ( "the relation is empty." );
cout << "the relation is emplty." <<endl;
return false;
}
}
/*
Method ~chkStartEndA~
Returns the route Interval between the two points
*/
void chkStartEndA ( double &StartPos, double &EndPos )
{
double help;
if ( StartPos > EndPos )
{
help = StartPos;
StartPos = EndPos;
EndPos = help;
}
};
/*
Method ~ShorterConnection~
*/
bool Network::ShorterConnection ( Tuple *route, double &start,
double &end, double &dpos, double &dpos2,
int &rid, int &ridt, Point p1, Point p2 )
{
if ( AlmostEqual ( p1.Distance ( p2 ), fabs ( end-start ) ) ) return false;
double difference;
GPoint *gp = new GPoint ( true, GetId(), route->GetTupleId(), end - 0.01 );
TupleId pSection1 = GetTupleIdSectionOnRoute ( gp );
gp->DeleteIfAllowed();
vector<DirectedSection> pAdjSect1;
vector<DirectedSection> pAdjSect2;
pAdjSect1.clear();
pAdjSect2.clear();
GetAdjacentSections ( pSection1,true, pAdjSect1 );
GetAdjacentSections ( pSection1,false, pAdjSect2 );
if ( pAdjSect1.size() == 0 || pAdjSect2.size() == 0 )
{
pAdjSect1.clear();
pAdjSect2.clear();
return false;
}
else
{
size_t j = 0;
while ( j < pAdjSect1.size() )
{
DirectedSection actSection = pAdjSect1[j];
Tuple *pCurrSect = m_pSections->GetTuple ( actSection.GetSectionTid(),
false );
ridt = ( ( CcInt* ) pCurrSect->GetAttribute ( SECTION_RID )
)->GetIntval();
pCurrSect->DeleteIfAllowed();
if ( ridt != rid )
{
Tuple *pRoute = GetRoute ( ridt );
SimpleLine *pCurve =
( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
if ( ( chkPoint ( pCurve, p1, true, dpos, difference ) ) &&
( chkPoint ( pCurve, p2, true, dpos2, difference ) ) )
{
pAdjSect1.clear();
pAdjSect2.clear();
chkStartEndA ( dpos, dpos2 );
pRoute->DeleteIfAllowed();
if ( fabs ( dpos2 - dpos ) < fabs ( end - start ) ) return true;
else return false;
}
pRoute->DeleteIfAllowed();
}
j++;
}
pAdjSect1.clear();
j = 0;
while ( j < pAdjSect2.size() )
{
DirectedSection actSection = pAdjSect2[j];
Tuple *pCurrSect = m_pSections->GetTuple ( actSection.GetSectionTid(),
false );
ridt = ( ( CcInt* ) pCurrSect->GetAttribute ( SECTION_RID )
)->GetIntval();
pCurrSect->DeleteIfAllowed();
if ( ridt != rid )
{
Tuple *pRoute = GetRoute ( ridt );
SimpleLine *pCurve =
( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
if ( ( chkPoint ( pCurve, p1, true, dpos, difference ) ) &&
( chkPoint ( pCurve, p2, true, dpos2, difference ) ) )
{
pAdjSect2.clear();
chkStartEndA ( dpos, dpos2 );
pRoute->DeleteIfAllowed();
if ( fabs ( dpos2-dpos ) < fabs ( end - start ) ) return true;
else return false;
}
pRoute->DeleteIfAllowed();
}
j++;
}
return false;
}
}
/*
Method ~ShorterConnection2~
*/
bool Network::ShorterConnection2 ( Tuple *route, double &start,
double &end, double &dpos, double &dpos2,
int &rid, int &ridt, Point p1, Point p2 )
{
if ( AlmostEqual ( p1.Distance ( p2 ), fabs ( end-start ) ) ) return false;
double difference = 0.0;
if ( start < end && end > 0.01 ) difference = end - 0.01;
else
if ( start < end && end <= 0.01 ) difference = 0.01;
else
if ( start > end ) difference = end + 0.01;
else difference = end; //start == end
GPoint *gp = new GPoint ( true, GetId(), route->GetTupleId(), difference );
TupleId pSection1 = GetTupleIdSectionOnRoute ( gp );
gp->DeleteIfAllowed();
vector<DirectedSection> pAdjSect1;
vector<DirectedSection> pAdjSect2;
pAdjSect1.clear();
pAdjSect2.clear();
GetAdjacentSections ( pSection1,true, pAdjSect1 );
GetAdjacentSections ( pSection1,false, pAdjSect2 );
if ( pAdjSect1.size() == 0 || pAdjSect2.size() == 0 )
{
pAdjSect1.clear();
pAdjSect2.clear();
return false;
}
else
{
size_t j = 0;
while ( j < pAdjSect1.size() )
{
DirectedSection actSection = pAdjSect1[j];
Tuple *pCurrSect = m_pSections->GetTuple ( actSection.GetSectionTid(),
false );
ridt = ( ( CcInt* ) pCurrSect->GetAttribute ( SECTION_RID )
)->GetIntval();
pCurrSect->DeleteIfAllowed();
if ( ridt != rid )
{
Tuple *pRoute = GetRoute ( ridt );
SimpleLine *pCurve =
( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
if ( ( chkPoint ( pCurve, p1, true, dpos, difference ) ) &&
( chkPoint ( pCurve, p2, true, dpos2, difference ) ) )
{
pAdjSect1.clear();
pAdjSect2.clear();
pRoute->DeleteIfAllowed();
if ( fabs ( dpos2 - dpos ) < fabs ( end - start ) ) return true;
else return false;
}
pRoute->DeleteIfAllowed();
}
j++;
}
pAdjSect1.clear();
j = 0;
while ( j < pAdjSect2.size() )
{
DirectedSection actSection = pAdjSect2[j];
Tuple *pCurrSect = m_pSections->GetTuple ( actSection.GetSectionTid(),
false );
ridt = ( ( CcInt* ) pCurrSect->GetAttribute ( SECTION_RID )
)->GetIntval();
pCurrSect->DeleteIfAllowed();
if ( ridt != rid )
{
Tuple *pRoute = GetRoute ( ridt );
SimpleLine *pCurve =
( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
if ( ( chkPoint ( pCurve, p1, true, dpos, difference ) ) &&
( chkPoint ( pCurve, p2, true, dpos2, difference ) ) )
{
pAdjSect2.clear();
pRoute->DeleteIfAllowed();
if ( fabs ( dpos2-dpos ) < fabs ( end - start ) ) return true;
else return false;
}
pRoute->DeleteIfAllowed();
}
j++;
}
return false;
}
}
/*
Method ~Find~
Searches the route interval between the two given point values.
*/
RouteInterval* Network::Find ( Point p1, Point p2 )
{
GPoint *gpp1 = GetNetworkPosOfPoint ( p1 );
GPoint *gpp2 = GetNetworkPosOfPoint ( p2 );
assert ( gpp1->IsDefined() && gpp2->IsDefined() );
int rid, ridt;
double start, end, dpos, dpos2, difference;
if ( gpp1->GetRouteId() == gpp2->GetRouteId() )
{
rid = gpp1->GetRouteId();
start = gpp1->GetPosition();
end = gpp2->GetPosition();
chkStartEndA ( start,end );
Tuple *pRoute = GetRoute ( rid );
if ( ShorterConnection ( pRoute, start, end, dpos, dpos2, rid, ridt, p1, p2
) )
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( ridt, dpos, dpos2 );
}
else
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( rid, start, end );
}
}
else // different RouteIds
{
Tuple *pRoute = GetRoute ( gpp1->GetRouteId() );
SimpleLine *pCurve =
( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
if ( chkPoint ( pCurve, p2, true, dpos, difference ) )
{
rid =
( ( CcInt* ) pRoute->GetAttribute ( ROUTE_ID ) )->GetIntval();
start = gpp1->GetPosition();
end = dpos;
chkStartEndA ( start, end );
if ( ShorterConnection ( pRoute, start, end, dpos, dpos2, rid, ridt, p1,
p2 ) )
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( ridt, dpos, dpos2 );
}
else
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( rid, start, end );
}
}
pRoute->DeleteIfAllowed();
pRoute = GetRoute ( gpp2->GetRouteId() );
pCurve = ( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
if ( chkPoint ( pCurve, p1, true, dpos, difference ) )
{
rid =
( ( CcInt* ) pRoute->GetAttribute ( ROUTE_ID ) )->GetIntval();
start = gpp2->GetPosition();
end = dpos;
chkStartEndA ( start, end );
if ( ShorterConnection ( pRoute, start, end, dpos, dpos2, rid, ridt, p1,
p2 ) )
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( ridt, dpos, dpos2 );
}
else
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( rid, start, end );
}
}
pRoute->DeleteIfAllowed();
TupleId pSection = GetTupleIdSectionOnRoute ( gpp1 );
vector<DirectedSection> pAdjSect1;
vector<DirectedSection> pAdjSect2;
pAdjSect1.clear();
pAdjSect2.clear();
GetAdjacentSections ( pSection,true, pAdjSect1 );
GetAdjacentSections ( pSection,false, pAdjSect2 );
size_t j = 0;
Tuple *pCurrSect;
while ( j < pAdjSect1.size() )
{
DirectedSection actSection = pAdjSect1[j];
pCurrSect = m_pSections->GetTuple ( actSection.GetSectionTid(),
false );
rid = ( ( CcInt* ) pCurrSect->GetAttribute ( SECTION_RID ) )->GetIntval();
pCurrSect->DeleteIfAllowed();
pRoute = GetRoute ( rid );
pCurve = ( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
if ( ( chkPoint ( pCurve, p1, true, dpos, difference ) ) &&
( chkPoint ( pCurve, p2, true, dpos2, difference ) ) )
{
start = dpos;
end = dpos2;
chkStartEndA ( start, end );
pAdjSect1.clear();
pAdjSect2.clear();
if ( ShorterConnection ( pRoute, start, end, dpos, dpos2,
rid, ridt, p1, p2 ) )
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( ridt, dpos, dpos2 );
}
else
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( rid, start, end );
}
}
j++;
pRoute->DeleteIfAllowed();
}
j = 0;
pAdjSect1.clear();
while ( j < pAdjSect2.size() )
{
DirectedSection actSection = pAdjSect2[j];
pCurrSect = m_pSections->GetTuple ( actSection.GetSectionTid(),
false );
rid = ( ( CcInt* ) pCurrSect->GetAttribute ( SECTION_RID ) )->GetIntval();
pCurrSect->DeleteIfAllowed();
pRoute = GetRoute ( rid );
pCurve = ( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
if ( ( chkPoint ( pCurve, p1, true, dpos, difference ) ) &&
( chkPoint ( pCurve, p2, true, dpos2, difference ) ) )
{
start = dpos;
end = dpos2;
chkStartEndA ( start, end );
pAdjSect2.clear();
if ( ShorterConnection ( pRoute, start, end, dpos, dpos2,
rid, ridt, p1, p2 ) )
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( ridt, dpos, dpos2 );
}
else
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( rid, start, end );
}
}
j++;
pRoute->DeleteIfAllowed();
}//should never be reached
pAdjSect2.clear();
}//should never be reached
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
return 0;
}
/*
Method ~FindInterval~
Returns the route interval for the connection from p1 to p2
*/
RouteInterval* Network::FindInterval ( Point p1, Point p2 )
{
GPoint *gpp1 = GetNetworkPosOfPoint ( p1 );
GPoint *gpp2 = GetNetworkPosOfPoint ( p2 );
assert ( gpp1->IsDefined() && gpp2->IsDefined() );
int rid, ridt;
double start, end, dpos, dpos2, difference;
if ( gpp1->GetRouteId() == gpp2->GetRouteId() )
{
rid = gpp1->GetRouteId();
start = gpp1->GetPosition();
end = gpp2->GetPosition();
Tuple *pRoute = GetRoute ( rid );
if ( ShorterConnection2 ( pRoute, start, end, dpos, dpos2, rid, ridt,
p1, p2) )
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( ridt, dpos, dpos2 );
}
else
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( rid, start, end );
}
}
else
{
Tuple *pRoute = GetRoute ( gpp1->GetRouteId() );
SimpleLine *pCurve =
( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
if ( chkPoint ( pCurve, p2, true, dpos, difference ) )
{
rid =
( ( CcInt* ) pRoute->GetAttribute ( ROUTE_ID ) )->GetIntval();
start = gpp1->GetPosition();
end = dpos;
if ( ShorterConnection2 ( pRoute, start, end, dpos, dpos2,
rid, ridt, p1, p2 ) )
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( ridt, dpos, dpos2 );
}
else
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( rid, start, end );
}
}
pRoute->DeleteIfAllowed();
pRoute = GetRoute ( gpp2->GetRouteId() );
pCurve = ( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
if ( chkPoint ( pCurve, p1, true, dpos, difference ) )
{
rid =
( ( CcInt* ) pRoute->GetAttribute ( ROUTE_ID ) )->GetIntval();
start = dpos;
end = gpp2->GetPosition();
if ( ShorterConnection2 ( pRoute, start, end, dpos, dpos2,
rid, ridt, p1, p2 ) )
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( ridt, dpos, dpos2 );
}
else
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( rid, start, end );
}
}
pRoute->DeleteIfAllowed();
TupleId pSection = GetTupleIdSectionOnRoute ( gpp1 );
vector<DirectedSection> pAdjSect1;
vector<DirectedSection> pAdjSect2;
pAdjSect1.clear();
pAdjSect2.clear();
GetAdjacentSections ( pSection,true, pAdjSect1 );
GetAdjacentSections ( pSection,false, pAdjSect2 );
size_t j = 0;
Tuple *pCurrSect;
while ( j < pAdjSect1.size() )
{
DirectedSection actSection = pAdjSect1[j];
pCurrSect = m_pSections->GetTuple ( actSection.GetSectionTid(), false );
rid = ( ( CcInt* ) pCurrSect->GetAttribute ( SECTION_RID ) )->GetIntval();
pCurrSect->DeleteIfAllowed();
pRoute = GetRoute ( rid );
pCurve = ( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
if ( ( chkPoint ( pCurve, p1, true, dpos, difference ) ) &&
( chkPoint ( pCurve, p2, true, dpos2, difference ) ) )
{
start = dpos;
end = dpos2;
pAdjSect1.clear();
pAdjSect2.clear();
if ( ShorterConnection2 ( pRoute, start, end, dpos, dpos2,
rid, ridt, p1, p2 ) )
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( ridt, dpos, dpos2 );
}
else
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( rid, start, end );
}
}
j++;
pRoute->DeleteIfAllowed();
}
j = 0;
pAdjSect1.clear();
while ( j < pAdjSect2.size() )
{
DirectedSection actSection = pAdjSect2[j];
pCurrSect = m_pSections->GetTuple ( actSection.GetSectionTid(), false );
rid = ( ( CcInt* ) pCurrSect->GetAttribute ( SECTION_RID ) )->GetIntval();
pCurrSect->DeleteIfAllowed();
pRoute = GetRoute ( rid );
pCurve = ( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
if ( ( chkPoint ( pCurve, p1, true, dpos, difference ) ) &&
( chkPoint ( pCurve, p2, true, dpos2, difference ) ) )
{
start = dpos;
end = dpos2;
pAdjSect2.clear();
if ( ShorterConnection2 ( pRoute, start, end, dpos, dpos2,
rid, ridt, p1, p2 ) )
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( ridt, dpos, dpos2 );
}
else
{
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
pRoute->DeleteIfAllowed();
return new RouteInterval ( rid, start, end );
}
}
j++;
pRoute->DeleteIfAllowed();
}//should never be reached
pAdjSect2.clear();
}//should never be reached
gpp1->DeleteIfAllowed();
gpp2->DeleteIfAllowed();
return 0;
}
/*
Get-Methodes of network parameters.
~GetId~, ~GetRoutes~, ~GetJunctions~, ~GetJunctionsOnRoute~, ~GetSection~,
~GetTupleIdSectionOnRoute~, ~GetTupleIdSectionOnRoute~, ~GetSectionOnRoute~,
~GetRoute~, ~GetSectionsOfRouteInterval~, ~GetSectionsOfRoutInterval~,
~GetPointOnRoute~, ~GetSectionsInternal~, ~GetSections~,
~GetAdjacentSectionsInfo~, ~GetAdjacentSections~, ~GetRouteCurve~, ~GetDual~,
~GetTupleIdSectionOnRouteJun~, ~GetNetworkPosOfPoint~,
~GetJunctionMeasForRoutes~, ~GetLineValueOfRouteInterval~
*/
int Network::GetId()
{
return m_iId;
}
Relation *Network::GetRoutes()
{
return m_pRoutes;
/* ostringstream strRoutesPtr;
strRoutesPtr << ( long ) m_pRoutes;
string querystring = "(consume (feed (" + routesTypeInfo +
" (ptr " + strRoutesPtr.str() + "))))";
Word resultWord;
int QueryExecuted = QueryProcessor::ExecuteQuery ( querystring, resultWord );
assert ( QueryExecuted ); // no ASSERT with side effects, please
return ( Relation * ) resultWord.addr;*/
}
Relation *Network::GetJunctions()
{
ostringstream strJunctionsPtr;
strJunctionsPtr << ( long ) m_pJunctions;
string querystring = "(consume (feed (" + junctionsInternalTypeInfo +
" (ptr " + strJunctionsPtr.str() + "))))";
Word resultWord;
int QueryExecuted = QueryProcessor::ExecuteQuery ( querystring, resultWord );
assert ( QueryExecuted ); // no ASSERT with side effects, please
return ( Relation * ) resultWord.addr;
}
void Network::GetJunctionsOnRoute ( CcInt* in_pRouteId,
vector<JunctionSortEntry> &inout_xJunctions
)
{
BTreeIterator* pJunctionsIt;
pJunctionsIt = m_pBTreeJunctionsByRoute1->ExactMatch ( in_pRouteId );
while ( pJunctionsIt->Next() )
{
// Get next junction
Tuple* pCurrentJunction = m_pJunctions->GetTuple ( pJunctionsIt->GetId(),
false );
inout_xJunctions.push_back ( JunctionSortEntry ( true, pCurrentJunction ) );
}
delete pJunctionsIt;
// Now we look up the second b-tree
pJunctionsIt = m_pBTreeJunctionsByRoute2->ExactMatch ( in_pRouteId );
while ( pJunctionsIt->Next() )
{
Tuple* pCurrentJunction = m_pJunctions->GetTuple ( pJunctionsIt->GetId(),
false );
inout_xJunctions.push_back ( JunctionSortEntry ( false, pCurrentJunction )
);
}
delete pJunctionsIt;
// The junctions will be sorted by their mesure on the relevant route.
sort ( inout_xJunctions.begin(),
inout_xJunctions.end() );
}
Tuple* Network::GetSection ( TupleId n )
{
return m_pSections->GetTuple ( n, false );
}
TupleId Network::GetTupleIdSectionOnRoute ( GPoint* in_xGPoint )
{
CcInt *ciRouteId = new CcInt ( true, in_xGPoint->GetRouteId() );
BTreeIterator* pSectionIter =
m_pBTreeSectionsByRoute->ExactMatch ( ciRouteId );
ciRouteId->DeleteIfAllowed();
Tuple *actSect = 0;
TupleId result;
while ( pSectionIter->Next() )
{
result = pSectionIter->GetId();
actSect =
m_pSections->GetTuple ( pSectionIter->GetId(), false );
if ( actSect != 0 )
{
double start =
( ( CcReal* ) actSect->GetAttribute ( SECTION_MEAS1 ) )->GetRealval();
double end =
( ( CcReal* ) actSect->GetAttribute ( SECTION_MEAS2 ) )->GetRealval();
if ( in_xGPoint->GetPosition() >= start&&in_xGPoint->GetPosition() <= end
)
{
delete pSectionIter;
actSect->DeleteIfAllowed();
return result;
}
else
{
if ( fabs ( in_xGPoint->GetPosition() - start ) <= 0.01 )
{
delete pSectionIter;
actSect->DeleteIfAllowed();
return result;
}
else
{
if ( fabs ( in_xGPoint->GetPosition() - end ) <= 0.01 )
{
Tuple *pRoute = GetRoute ( ( ( TupleIdentifier* )
actSect->GetAttribute ( SECTION_RRC )
)->GetTid() );
if ( fabs ( ( ( CcReal* )
pRoute->GetAttribute ( ROUTE_LENGTH ) )->GetRealval()
- end ) <= 0.01 )
{
pRoute->DeleteIfAllowed();
delete pSectionIter;
actSect->DeleteIfAllowed();
return result;
}
else
{
pRoute->DeleteIfAllowed();
}
}
}
}
actSect->DeleteIfAllowed();
}
}
delete pSectionIter;
return 0;
}
Tuple* Network::GetSectionOnRoute ( GPoint* in_xGPoint )
{
return GetSection ( GetTupleIdSectionOnRoute ( in_xGPoint ) );
/*
New implementation using sectionsBTree
CcInt *ciRouteId = new CcInt(true, in_xGPoint->GetRouteId());
BTreeIterator* pSectionIter =
m_pBTreeSectionsByRoute->ExactMatch(ciRouteId);
ciRouteId->DeleteIfAllowed();
Tuple *actSect = 0;
while (pSectionIter->Next()){
actSect =
m_pSections->GetTuple(pSectionIter->GetId());
if(actSect != 0){
double start =
((CcReal*)actSect->GetAttribute(SECTION_MEAS1))->GetRealval();
double end =
((CcReal*) actSect->GetAttribute(SECTION_MEAS2))->GetRealval();
if (in_xGPoint->GetPosition() >= start&&in_xGPoint->GetPosition() <= end)
{
delete pSectionIter;
return actSect;
}
else {
if (fabs(in_xGPoint->GetPosition() - start) <= 0.01) {
delete pSectionIter;
return actSect;
}
else {
if (fabs(in_xGPoint->GetPosition() - end) <= 0.01) {
Tuple *pRoute = GetRoute(((TupleIdentifier*)
actSect->GetAttribute(SECTION_RRC))->GetTid());
if (fabs(((CcReal*)
pRoute->GetAttribute(ROUTE_LENGTH))->GetRealval()
- end) <= 0.01){
pRoute->DeleteIfAllowed();
delete pSectionIter;
return actSect;
} else {
pRoute->DeleteIfAllowed();
}
}
}
}
actSect->DeleteIfAllowed();
}
}
delete pSectionIter;
return 0;
vector<JunctionSortEntry> xJunctions;
CcInt xRouteId(true, in_xGPoint->GetRouteId());
GetJunctionsOnRoute(&xRouteId,
xJunctions);
// Now that we found all relevant junctions we can iterate over them.
int iSectionId = 0;
double juncpos;
for(size_t i = 0; i < xJunctions.size(); i++)
{
// Get next junction
JunctionSortEntry xCurrentEntry = xJunctions[i];
iSectionId = xCurrentEntry.GetDownSectionId();
juncpos = xCurrentEntry.GetRouteMeas();
if(juncpos > in_xGPoint->GetPosition())
{
break;
}
if (juncpos != 0 && fabs(juncpos - in_xGPoint->GetPosition()) < 0.01){
break;
}
iSectionId = xCurrentEntry.GetUpSectionId();
}
for(size_t i = 0; i < xJunctions.size(); i++)
{
// Get next junction
JunctionSortEntry xCurrentEntry = xJunctions[i];
xCurrentEntry.m_pJunction->DeleteIfAllowed();
}
if(iSectionId == 0) return 0;
else return m_pSections->GetTuple(iSectionId);
*/
}
Tuple* Network::GetRoute ( int in_RouteId )
{
CcInt* pRouteId = new CcInt ( true, in_RouteId );
BTreeIterator *pRoutesIter = m_pBTreeRoutes->ExactMatch ( pRouteId );
pRouteId->DeleteIfAllowed();
Tuple *pRoute = 0;
if ( pRoutesIter->Next() )
pRoute = m_pRoutes->GetTuple ( pRoutesIter->GetId() , false);
assert ( pRoute != 0 );
delete pRoutesIter;
return pRoute;
}
Tuple* Network::GetRoute ( TupleId in_routeTID )
{
return m_pRoutes->GetTuple ( in_routeTID, false );
}
void Network::GetSectionsOfRouteInterval ( const RouteInterval *ri,
DbArray<SectTreeEntry> *io_SectionIds )
{
double ristart = min ( ri->GetStartPos(), ri->GetEndPos() );
double riend = max ( ri->GetStartPos(), ri->GetEndPos() );
CcInt* ciRouteId = new CcInt ( true, ri->GetRouteId() );
BTreeIterator* pSectionIter =
m_pBTreeSectionsByRoute->ExactMatch ( ciRouteId );
ciRouteId->DeleteIfAllowed();
Tuple *actSect;
TupleId actSectTID;
bool bsectstart = true;
bool bsectend = true;
while ( pSectionIter->Next() )
{
actSectTID = pSectionIter->GetId();
actSect = m_pSections->GetTuple ( actSectTID, false );
assert ( actSect != 0 );
double start =
( ( CcReal* ) actSect->GetAttribute ( SECTION_MEAS1 ) )->GetRealval();
double end =
( ( CcReal* ) actSect->GetAttribute ( SECTION_MEAS2 ) )->GetRealval();
if ( ( ristart <= start && riend >= end ) ||
( start <= ristart && end >= ristart ) ||
( start <= riend && end >= riend ) )
{
if ( start <= ristart )
{
start = ristart;
bsectstart = false;
}
if ( riend <= end )
{
end = riend;
bsectend = false;
}
SectTreeEntry *sect =
new SectTreeEntry ( actSect->GetTupleId(), ri->GetRouteId(), start,
end,
bsectstart, bsectend );
io_SectionIds->Append ( *sect );
delete sect;
if ( riend <= end )
{
actSect->DeleteIfAllowed();
break;
}
}
actSect->DeleteIfAllowed();
}
io_SectionIds->TrimToSize();
delete pSectionIter;
};
void Network::GetSectionsOfRoutInterval ( const RouteInterval *ri,
vector<TupleId> &res )
{
res.clear();
double ristart = min ( ri->GetStartPos(), ri->GetEndPos() );
double riend = max ( ri->GetStartPos(), ri->GetEndPos() );
CcInt* ciRouteId = new CcInt ( true, ri->GetRouteId() );
BTreeIterator* pSectionIter =
m_pBTreeSectionsByRoute->ExactMatch ( ciRouteId );
ciRouteId->DeleteIfAllowed();
Tuple *actSect;
TupleId actSectTID;
//bool bsectstart = true;
//bool bsectend = true;
while ( pSectionIter->Next() )
{
actSectTID = pSectionIter->GetId();
actSect = m_pSections->GetTuple ( actSectTID, false );
assert ( actSect != 0 );
double start =
( ( CcReal* ) actSect->GetAttribute ( SECTION_MEAS1 ) )->GetRealval();
double end =
( ( CcReal* ) actSect->GetAttribute ( SECTION_MEAS2 ) )->GetRealval();
if ( fabs ( ristart - riend ) <= 0.01 &&
( fabs ( ristart - start ) <= 0.01 || fabs ( ristart - end ) <= 0.01
) )
{
res.push_back ( actSectTID );
actSect->DeleteIfAllowed();
break;
}
else
{
if ( ( ( ristart <= start && end <= riend ) ||
( start <= ristart && end > ristart ) ||
( start < riend && riend <= end ) ) &&
( ! ( fabs ( ristart - end ) <= 0.01 || fabs ( start - riend ) <=
0.01 ) ) )
res.push_back ( actSectTID );
}
actSect->DeleteIfAllowed();
}
delete pSectionIter;
}
void Network::GetPointOnRoute ( const GPoint* in_pGPoint, Point*& res )
{
/*Point *res = new Point(false);*/
CcInt* pRouteId = new CcInt ( true, in_pGPoint->GetRouteId() );
BTreeIterator* pRoutesIter = m_pBTreeRoutes->ExactMatch ( pRouteId );
pRouteId->DeleteIfAllowed();
Tuple *pRoute = 0;
if ( pRoutesIter->Next() )
pRoute = m_pRoutes->GetTuple ( pRoutesIter->GetId(), false );
assert ( pRoute != 0 );
SimpleLine* pLine = ( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
assert ( pLine != 0 );
pLine->AtPosition ( in_pGPoint->GetPosition(),true, *res );
pRoute->DeleteIfAllowed();
delete pRoutesIter;
/*return res;*/
}
Relation* Network::GetSectionsInternal()
{
return m_pSections;
}
Relation* Network::GetSections()
{
ostringstream strSectionsPtr;
strSectionsPtr << ( long ) m_pSections;
string querystring = "(consume (feed (" + sectionsInternalTypeInfo +
" (ptr " + strSectionsPtr.str() + "))))";
Word resultWord;
int QueryExecuted = QueryProcessor::ExecuteQuery ( querystring, resultWord );
assert ( QueryExecuted ); // No ASSERT with side effect, please!
return ( Relation * ) resultWord.addr;
}
void Network::GetAdjacentSectionsInfo ( TupleId in_iSectionTId,
bool in_bUpDown,
vector<DirectedSectionInfo> &inout_xSections )
{
inout_xSections.clear();
Tuple *pSect = GetSection ( in_iSectionTId );
if ( pSect != 0 )
{
// get Sid, SectionPage and SectionSlot
int iSectionPage, iSectionSlot;
if (in_bUpDown){
iSectionPage=((CcInt*)pSect->GetAttribute(SECTION_PNO_UP))->GetIntval();
iSectionSlot=((CcInt*)pSect->GetAttribute(SECTION_SLOT_UP))->GetIntval();
}else{
iSectionPage=((CcInt*)pSect->GetAttribute(SECTION_PNO_DOWN))->GetIntval();
iSectionSlot=((CcInt*)pSect->GetAttribute(SECTION_SLOT_DOWN))->GetIntval();
}
pSect->DeleteIfAllowed();
if(iSectionPage != 0 && iSectionSlot !=0){
//getSectionPage
PageRecord xPage;
m_xAdjacencyList.Get ( iSectionPage-1, xPage );
//get Number of Neighbours
int iNeighbours=0;
xPage.GetSectionNoNeighbours(iSectionSlot, iNeighbours);
//Cache for Pages and Slots defined
int **iPagesSlots;
iPagesSlots = new int* [iNeighbours];
for (int i=0; i<iNeighbours;i++){
iPagesSlots[i] = new int[2];
}
for(int i =0; i<iNeighbours ;i++){
xPage.GetSectionNeighbourPage(iSectionSlot,i,iPagesSlots[i][0]);
xPage.GetSectionNeighbourSlot(iSectionSlot,i,iPagesSlots[i][1]);
}
// store all needet attributes of the Neighbour in DirectedSectionInfo
int actPageNum = iSectionPage;
bool bUpDownFlag;
int iSectionId, irid;
double dcost, dduration;
TupleId sectionTid;
double dmeas1, dmeas2;
for(int i=0; i< iNeighbours; i++){
if(actPageNum != iPagesSlots[i][0]){
// get new Page
actPageNum = iPagesSlots[i][0];
m_xAdjacencyList.Get ( actPageNum-1, xPage );
}
xPage.GetSectionId(iPagesSlots[i][1],iSectionId);
xPage.GetSectionUpdown(iPagesSlots[i][1],bUpDownFlag);
xPage.GetSectionMeas1(iPagesSlots[i][1],dmeas1);
xPage.GetSectionMeas2(iPagesSlots[i][1],dmeas2);
xPage.GetSectionRid(iPagesSlots[i][1],irid);
xPage.GetSectionCost(iPagesSlots[i][1],dcost);
xPage.GetSectionDuration(iPagesSlots[i][1],dduration);
xPage.GetSectionTid(iPagesSlots[i][1],sectionTid);
inout_xSections.push_back (
DirectedSectionInfo(sectionTid,bUpDownFlag,dmeas1,dmeas2,irid,
dcost,dduration));
}
//Delete Array
for (int i=0; i<iNeighbours;i++){
delete [] iPagesSlots[i];
}
delete [] iPagesSlots;
}
}
}
void Network::GetAdjacentSections ( TupleId in_iSectionTId,
bool in_bUpDown,
vector<DirectedSection> &inout_xSections )
{
inout_xSections.clear();
Tuple *pSect = GetSection ( in_iSectionTId );
if ( pSect != 0 )
{
// get Sid, SectionPage and SectionSlot
int iSectionPage, iSectionSlot;
if (in_bUpDown){
iSectionPage =((CcInt*)pSect->GetAttribute(SECTION_PNO_UP))->GetIntval();
iSectionSlot =((CcInt*)pSect->GetAttribute(SECTION_SLOT_UP))->GetIntval();
}else{
iSectionPage =((CcInt*)pSect->GetAttribute(SECTION_PNO_DOWN))->GetIntval();
iSectionSlot=((CcInt*)pSect->GetAttribute(SECTION_SLOT_DOWN))->GetIntval();
}
pSect->DeleteIfAllowed();
if(iSectionPage != 0 && iSectionSlot !=0){
//getSectionPage
PageRecord xPage;
m_xAdjacencyList.Get ( iSectionPage-1, xPage );
//get Number of Neighbours
int iNeighbours=0;
xPage.GetSectionNoNeighbours(iSectionSlot, iNeighbours);
//Cache for Pages and Slots defined
int **iPagesSlots;
iPagesSlots = new int* [iNeighbours];
for (int i=0; i<iNeighbours;i++){
iPagesSlots[i] = new int[2];
}
for(int i =0; i<iNeighbours ;i++){
xPage.GetSectionNeighbourPage(iSectionSlot,i,iPagesSlots[i][0]);
xPage.GetSectionNeighbourSlot(iSectionSlot,i,iPagesSlots[i][1]);
}
// store the Sid and UpDownFlag of the Neighbour in DirectedSection
int actPageNum = iSectionPage;
bool bUpDownFlag;
int iSectionId;
TupleId sectionTid;
for(int i=0; i< iNeighbours; i++){
if(actPageNum != iPagesSlots[i][0]){
// get new Page
actPageNum = iPagesSlots[i][0];
m_xAdjacencyList.Get ( actPageNum-1, xPage );
}
xPage.GetSectionId(iPagesSlots[i][1],iSectionId);
xPage.GetSectionUpdown(iPagesSlots[i][1],bUpDownFlag);
xPage.GetSectionTid(iPagesSlots[i][1],sectionTid);
inout_xSections.push_back (DirectedSection(sectionTid,bUpDownFlag));
}
//Delete Array
for (int i=0; i<iNeighbours;i++){
delete [] iPagesSlots[i];
}
delete [] iPagesSlots;
}
}
}
SimpleLine Network::GetRouteCurve ( int in_iRouteId )
{
Tuple *pRoute = GetRoute ( in_iRouteId );
SimpleLine sl = * ( ( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE ) );
pRoute->DeleteIfAllowed();
return sl;
}
bool Network::GetDual ( int in_iRouteId )
{
Tuple *pRoute = GetRoute ( in_iRouteId );
bool dual = ( ( CcBool* ) pRoute->GetAttribute ( ROUTE_DUAL ) )->GetBoolval();
pRoute->DeleteIfAllowed();
return dual;
}
void Network::GetTupleIdSectionOnRouteJun(GPoint* in_xGPoint,
vector<TupleId>& res)
{
CcInt *ciRouteId = new CcInt ( true, in_xGPoint->GetRouteId() );
BTreeIterator* pSectionIter =
m_pBTreeSectionsByRoute->ExactMatch ( ciRouteId );
delete ciRouteId;
Tuple *actSect = 0;
TupleId result;
while ( pSectionIter->Next() )
{
result = pSectionIter->GetId();
actSect = m_pSections->GetTuple ( pSectionIter->GetId(), false );
if ( actSect != 0 )
{
double start =
((CcReal*)actSect->GetAttribute(SECTION_MEAS1))->GetRealval();
double end =
((CcReal*)actSect->GetAttribute(SECTION_MEAS2))->GetRealval();
if(in_xGPoint->GetPosition() >= start&&in_xGPoint->GetPosition() <= end)
{
// delete pSectionIter;
// actSect->DeleteIfAllowed();
// return result;
res.push_back(result);
}
else
{
if ( fabs ( in_xGPoint->GetPosition() - start ) <= 0.01 )
{
// delete pSectionIter;
// actSect->DeleteIfAllowed();
// return result;
res.push_back(result);
}
else
{
if ( fabs ( in_xGPoint->GetPosition() - end ) <= 0.01 )
{
Tuple *pRoute = GetRoute(((TupleIdentifier* )
actSect->GetAttribute ( SECTION_RRC ))->GetTid() );
if ( fabs ( ( ( CcReal* )
pRoute->GetAttribute ( ROUTE_LENGTH ) )->GetRealval()
- end ) <= 0.01 )
{
// pRoute->DeleteIfAllowed();
// delete pSectionIter;
// actSect->DeleteIfAllowed();
res.push_back(result);
// return result;
}
pRoute->DeleteIfAllowed();
}
}
}
// actSect->DeleteIfAllowed();
}
actSect->DeleteIfAllowed();
}
delete pSectionIter;
}
GPoint* Network::GetNetworkPosOfPoint ( Point p )
{
const Rectangle<2> orig = p.BoundingBox();
double minMax[] = {orig.MinD ( 0 ) - 1.0,
orig.MaxD ( 0 ) + 1.0,
orig.MinD ( 1 ) - 1.0,
orig.MaxD ( 1 ) + 1.0 };
const Rectangle<2> bbox = Rectangle<2> ( true,minMax);
R_TreeLeafEntry<2,TupleId> res;
Tuple *pCurrRoute = 0;
if ( m_pRTreeRoutes->First ( bbox, res ) )
{
pCurrRoute = m_pRoutes->GetTuple ( res.info, false );
// pCurrRoute->PutAttribute(0, new TupleIdentifier(true, res.info));
}
else
{
GPoint *result = new GPoint ( false );
pCurrRoute->DeleteIfAllowed();
return result;
}
double dpos, difference;
SimpleLine* pRouteCurve = ( SimpleLine* ) pCurrRoute->GetAttribute (
ROUTE_CURVE );
if ( chkPoint ( pRouteCurve, p, true, dpos, difference ) )
{
int rid = ( ( CcInt* ) pCurrRoute->GetAttribute ( ROUTE_ID ) )->GetIntval();
GPoint *result = new GPoint ( true, GetId(), rid, dpos, None );
pCurrRoute->DeleteIfAllowed();
return result;
}
else
{
pCurrRoute->DeleteIfAllowed();
while ( m_pRTreeRoutes->Next ( res ) )
{
pCurrRoute = m_pRoutes->GetTuple ( res.info, false );
pRouteCurve = ( SimpleLine* ) pCurrRoute->GetAttribute ( ROUTE_CURVE );
if ( chkPoint ( pRouteCurve, p, true, dpos, difference ) )
{
int rid = ( ( CcInt* ) pCurrRoute->GetAttribute ( ROUTE_ID )
)->GetIntval();
GPoint *result = new GPoint ( true, GetId(),
rid,
dpos, None );
pCurrRoute->DeleteIfAllowed();
return result;
}
pCurrRoute->DeleteIfAllowed();
}
/*
If the point exact hits a route the route should be found here. If the point
value is not exact on the route curve we try to map it in the next step with
bigger tolerance for the hit of the route curve.
*/
if ( m_pRTreeRoutes->First ( bbox, res ) )
pCurrRoute = m_pRoutes->GetTuple ( res.info, false );
pRouteCurve = ( SimpleLine* ) pCurrRoute->GetAttribute ( ROUTE_CURVE );
if ( chkPoint03 ( pRouteCurve, p, true, dpos, difference ) )
{
int rid = ( ( CcInt* ) pCurrRoute->GetAttribute ( ROUTE_ID )
)->GetIntval();
GPoint *result = new GPoint ( true, GetId(),
rid,
dpos, None );
pCurrRoute->DeleteIfAllowed();
return result;
}
else
{
pCurrRoute->DeleteIfAllowed();
while ( m_pRTreeRoutes->Next ( res ) )
{
pCurrRoute = m_pRoutes->GetTuple ( res.info , false);
pRouteCurve = ( SimpleLine* ) pCurrRoute->GetAttribute ( ROUTE_CURVE );
if ( chkPoint03 ( pRouteCurve, p, true, dpos, difference ) )
{
int rid = ( ( CcInt* ) pCurrRoute->GetAttribute ( ROUTE_ID )
)->GetIntval();
GPoint *result = new GPoint ( true, GetId(),
rid,
dpos, None );
pCurrRoute->DeleteIfAllowed();
return result;
}
pCurrRoute->DeleteIfAllowed();
}
}
if ( m_pRTreeRoutes->First ( bbox, res ) )
pCurrRoute = m_pRoutes->GetTuple ( res.info, false );
pRouteCurve = ( SimpleLine* ) pCurrRoute->GetAttribute ( ROUTE_CURVE );
if ( lastchkPoint03 ( pRouteCurve, p, true, dpos, difference ) )
{
int rid = ( ( CcInt* ) pCurrRoute->GetAttribute ( ROUTE_ID )
)->GetIntval();
GPoint *result = new GPoint ( true, GetId(),
rid,
dpos, None );
pCurrRoute->DeleteIfAllowed();
return result;
}
else
{
pCurrRoute->DeleteIfAllowed();
while ( m_pRTreeRoutes->Next ( res ) )
{
pCurrRoute = m_pRoutes->GetTuple ( res.info, false );
pRouteCurve = ( SimpleLine* ) pCurrRoute->GetAttribute ( ROUTE_CURVE );
if ( lastchkPoint03 ( pRouteCurve, p, true, dpos, difference ) )
{
int rid = ( ( CcInt* ) pCurrRoute->GetAttribute ( ROUTE_ID )
)->GetIntval();
GPoint *result = new GPoint ( true, GetId(),
rid,
dpos, None );
pCurrRoute->DeleteIfAllowed();
return result;
}
pCurrRoute->DeleteIfAllowed();
}
} // should not be reached
GPoint *result = new GPoint ( false );
pCurrRoute->DeleteIfAllowed();
return result;
}
}
void Network::GetJunctionMeasForRoutes ( CcInt *pRoute1Id, CcInt *pRoute2Id,
double &rid1meas, double &rid2meas )
{
CcInt *pCurrJuncR2id, *pCurrJuncR1id;
int iCurrJuncTupleR2id, iCurrJuncR1id, iRoute1Id, iRoute2Id;
CcReal *pRid1Meas, *pRid2Meas;
bool r1smallerr2, found;
BTreeIterator *pJunctionsIt;
if ( pRoute1Id->GetIntval() <= pRoute2Id->GetIntval() )
{
pJunctionsIt = m_pBTreeJunctionsByRoute1->ExactMatch ( pRoute1Id );
iRoute1Id = pRoute1Id->GetIntval();
iRoute2Id = pRoute2Id->GetIntval();
r1smallerr2 = true;
}
else
{
pJunctionsIt = m_pBTreeJunctionsByRoute1->ExactMatch ( pRoute2Id );
iRoute1Id = pRoute2Id->GetIntval();
iRoute2Id = pRoute1Id->GetIntval();
r1smallerr2 = false;
}
found = false;
while ( !found && pJunctionsIt->Next() )
{
Tuple *pCurrJuncTuple = m_pJunctions->GetTuple ( pJunctionsIt->GetId(),
false );
pCurrJuncR2id = ( CcInt* ) pCurrJuncTuple->GetAttribute ( JUNCTION_ROUTE2_ID
);
iCurrJuncTupleR2id = pCurrJuncR2id->GetIntval();
pCurrJuncR1id = ( CcInt* ) pCurrJuncTuple->GetAttribute ( JUNCTION_ROUTE1_ID
);
iCurrJuncR1id = pCurrJuncR1id->GetIntval();
if ( iCurrJuncTupleR2id == iRoute2Id && iCurrJuncR1id == iRoute1Id )
{
found = true;
if ( r1smallerr2 )
{
pRid1Meas = ( CcReal* ) pCurrJuncTuple->GetAttribute (
JUNCTION_ROUTE1_MEAS );
rid1meas = pRid1Meas->GetRealval();
pRid2Meas = ( CcReal* ) pCurrJuncTuple->GetAttribute (
JUNCTION_ROUTE2_MEAS );
rid2meas = pRid2Meas->GetRealval();
}
else
{
pRid1Meas = ( CcReal* ) pCurrJuncTuple->GetAttribute (
JUNCTION_ROUTE2_MEAS );
rid1meas = pRid1Meas->GetRealval();
pRid2Meas = ( CcReal* ) pCurrJuncTuple->GetAttribute (
JUNCTION_ROUTE1_MEAS );
rid2meas = pRid2Meas->GetRealval();
}
}
pCurrJuncTuple->DeleteIfAllowed();
}
delete pJunctionsIt;
if ( !found )
{
rid1meas = numeric_limits<double>::max();
rid2meas = numeric_limits<double>::max();
}
}
void Network::GetLineValueOfRouteInterval ( const RouteInterval *in_ri,
SimpleLine *out_Line )
{
CcInt* pRouteId = new CcInt ( true, in_ri->GetRouteId() );
BTreeIterator *pRoutesIter = m_pBTreeRoutes->ExactMatch ( pRouteId );
pRouteId->DeleteIfAllowed();
Tuple *pRoute = 0;
if ( pRoutesIter->Next() ) pRoute = m_pRoutes->GetTuple (
pRoutesIter->GetId(), false);
assert ( pRoute != 0 );
SimpleLine* pLine = ( SimpleLine* ) pRoute->GetAttribute ( ROUTE_CURVE );
assert ( pLine != 0 );
CcBool* pStSm = ( CcBool* ) pRoute->GetAttribute ( ROUTE_STARTSSMALLER );
bool startSmaller = pStSm->GetBoolval();
pLine->SubLine ( min ( in_ri->GetStartPos(), in_ri->GetEndPos() ),
max ( in_ri->GetStartPos(), in_ri->GetEndPos() ),
startSmaller, *out_Line );
pRoute->DeleteIfAllowed();
delete pRoutesIter;
}
/*
3.1.4 Support functions of type constructor ~network~
~Out~-function of type constructor ~network~
*/
ListExpr Network::Out ( ListExpr typeInfo )
{
//cout << "NetworkOut" << endl;
///////////////////////
// Output of all routes
GenericRelationIterator *pRoutesIter = m_pRoutes->MakeScan();
Tuple *pCurrentRoute = 0;
ListExpr xLast = nl->TheEmptyList();
ListExpr xNext = nl->TheEmptyList();
ListExpr xRoutes = nl->TheEmptyList();
bool bFirst = true;
while ( ( pCurrentRoute = pRoutesIter->GetNextTuple() ) != 0 )
{
// Read values from table
CcInt* pRouteId = ( CcInt* ) pCurrentRoute->GetAttribute ( ROUTE_ID );
int iRouteId = pRouteId->GetIntval();
CcReal* pLength = ( CcReal* ) pCurrentRoute->GetAttribute ( ROUTE_LENGTH );
double dLength = pLength->GetRealval();
SimpleLine *pCurve = ( SimpleLine* ) pCurrentRoute->GetAttribute (
ROUTE_CURVE );
// The list for the curve contains all segments of the curve.
ListExpr xCurve = OutSimpleLine ( nl->TheEmptyList(), SetWord ( pCurve ) );
CcBool* pDual = ( CcBool* ) pCurrentRoute->GetAttribute ( ROUTE_DUAL );
bool bDual= pDual->GetBoolval();
CcBool* pStartsSmaller;
pStartsSmaller = ( CcBool* ) pCurrentRoute->GetAttribute (
ROUTE_STARTSSMALLER );
bool bStartsSmaller = pStartsSmaller->GetBoolval();
// Build list
xNext = nl->FiveElemList ( nl->IntAtom ( iRouteId ),
nl->RealAtom ( dLength ),
xCurve,
nl->BoolAtom ( bDual ),
nl->BoolAtom ( bStartsSmaller ) );
// Create new list or append element to existing list
if ( bFirst )
{
xRoutes = nl->OneElemList ( xNext );
xLast = xRoutes;
bFirst = false;
}
else
{
xLast = nl->Append ( xLast, xNext );
}
pCurrentRoute->DeleteIfAllowed();
}
delete pRoutesIter;
///////////////////////
// Output of all junctions
GenericRelationIterator *pJunctionsIter = m_pJunctions->MakeScan();
Tuple *pCurrentJunction;
ListExpr xJunctions = nl->TheEmptyList();
bFirst = true;
while ( ( pCurrentJunction = pJunctionsIter->GetNextTuple() ) != 0 )
{
// Read values from table
CcInt* pRoute1Id;
pRoute1Id = ( CcInt* ) pCurrentJunction->GetAttribute ( JUNCTION_ROUTE1_ID
);
int iRoute1Id = pRoute1Id->GetIntval();
CcReal* pMeas1;
pMeas1 = ( CcReal* ) pCurrentJunction->GetAttribute ( JUNCTION_ROUTE1_MEAS
);
double dMeas1 = pMeas1->GetRealval();
CcInt* pRoute2Id;
pRoute2Id = ( CcInt* ) pCurrentJunction->GetAttribute ( JUNCTION_ROUTE2_ID
);
int iRoute2Id = pRoute2Id->GetIntval();
CcReal* pMeas2;
pMeas2 = ( CcReal* ) pCurrentJunction->GetAttribute ( JUNCTION_ROUTE2_MEAS
);
double dMeas2 = pMeas2->GetRealval();
CcInt* pConnectivityCode;
pConnectivityCode = ( CcInt* ) pCurrentJunction->GetAttribute ( JUNCTION_CC
);
int iConnectivityCode= pConnectivityCode->GetIntval();
Point* pPoint = ( Point* ) pCurrentJunction->GetAttribute ( JUNCTION_POS );
ListExpr xPoint = OutPoint ( nl->TheEmptyList(), SetWord ( pPoint ) );
// Build list
xNext = nl->SixElemList ( nl->IntAtom ( iRoute1Id ),
nl->RealAtom ( dMeas1 ),
nl->IntAtom ( iRoute2Id ),
nl->RealAtom ( dMeas2 ),
nl->IntAtom ( iConnectivityCode ),
xPoint );
// Create new list or append element to existing list
if ( bFirst )
{
xJunctions= nl->OneElemList ( xNext );
xLast = xJunctions;
bFirst = false;
}
else
{
xLast = nl->Append ( xLast, xNext );
}
pCurrentJunction->DeleteIfAllowed();
}
delete pJunctionsIter;
return nl->ThreeElemList ( nl->IntAtom ( m_iId ),
xRoutes,
xJunctions );
}
/*
~Save~-function of type constructor ~network~
*/
ListExpr Network::Save ( SmiRecord& in_xValueRecord,
size_t& inout_iOffset,
const ListExpr in_xTypeInfo )
{
// Save id of the network
int iId = m_iId;
in_xValueRecord.Write ( &iId,
sizeof ( int ),
inout_iOffset );
inout_iOffset += sizeof ( int );
// Save routes
ListExpr xType;
nl->ReadFromString ( routesInternalTypeInfo, xType );
ListExpr xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
if ( !m_pRoutes->Save ( in_xValueRecord,
inout_iOffset,
xNumericType ) )
{
return false;
}
// Save junctions
nl->ReadFromString ( junctionsInternalTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
if ( !m_pJunctions->Save ( in_xValueRecord,
inout_iOffset,
xNumericType ) )
{
return false;
}
// Save sections
nl->ReadFromString ( sectionsInternalTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
if ( !m_pSections->Save ( in_xValueRecord,
inout_iOffset,
xNumericType ) )
{
return false;
}
// Save btree for routes
nl->ReadFromString ( routesBTreeTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
if ( !m_pBTreeRoutes->Save ( in_xValueRecord,
inout_iOffset,
xNumericType ) )
{
return false;
}
// Save btree for routesByStartposId
nl->ReadFromString ( routesBTreeTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
if ( !m_pBTreeRoutesByStartposId->Save ( in_xValueRecord,
inout_iOffset,
xNumericType ) )
{
return false;
}
// Save rtree for routes
if ( !m_pRTreeRoutes->Save ( in_xValueRecord,
inout_iOffset ) )
{
return false;
}
// Save first btree for junctions
nl->ReadFromString ( junctionsBTreeTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
if ( !m_pBTreeJunctionsByRoute1->Save ( in_xValueRecord,
inout_iOffset,
xNumericType ) )
{
return false;
}
// Save second btree for junctions
nl->ReadFromString ( junctionsBTreeTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
if ( !m_pBTreeJunctionsByRoute2->Save ( in_xValueRecord,
inout_iOffset,
xNumericType ) )
{
return false;
}
//SmiFileId fileId = 0;
//m_xAdjacencyList.SaveToRecord(in_xValueRecord, inout_iOffset, fileId);
//m_xSubAdjacencyList.SaveToRecord(in_xValueRecord, inout_iOffset, fileId);
//save m_xAdjacencyLlist
//Flob *tmpAdjList = &m_xAdjacencyList;
/* cout << "before storing:" << endl;
cout << "adjList" << ((Flob)m_xAdjacencyList) << endl;
cout << "adjList" << ((Flob)m_xSubAdjacencyList) << endl;
cout << "----" << endl;*/
SecondoCatalog *ctlg = SecondoSystem::GetCatalog();
SmiRecordFile *rf = ctlg->GetFlobFile();
m_xAdjacencyList.saveToFile(rf, m_xAdjacencyList);
SmiSize offset = 0;
size_t bufsize = m_xAdjacencyList.headerSize();
char* buf = (char*) malloc(bufsize);
m_xAdjacencyList.serializeHeader(buf,offset);
assert(offset==bufsize);
in_xValueRecord.Write(buf, bufsize, inout_iOffset);
inout_iOffset += bufsize;
free(buf);
//save m_xSubAdjacencyList
//Flob *tmpSubAdjList = &m_xSubAdjacencyList;
// SmiRecordFile *rf1 = ctlg->GetFlobFile();
m_xSubAdjacencyList.saveToFile(rf, m_xSubAdjacencyList);
offset = 0;
buf = (char*) malloc(bufsize);
m_xSubAdjacencyList.serializeHeader(buf,offset);
assert(offset==bufsize);
in_xValueRecord.Write(buf,bufsize, inout_iOffset);
free(buf);
inout_iOffset += bufsize;
// Save btree for sections
nl->ReadFromString ( sectionsBTreeTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
if ( !m_pBTreeSectionsByRoute->Save ( in_xValueRecord,
inout_iOffset,
xNumericType ) )
{
//cout << "cannot store BTree_sections" << endl;
return false;
}
nl->ReadFromString ( sectionsBTreeTypeInfo, xType );
xNumericType =SecondoSystem::GetCatalog()->NumericType ( xType );
if ( !m_pBTreeSections->Save ( in_xValueRecord,
inout_iOffset,
xNumericType ) )
{
//cout << "cannot store BTree_sections" << endl;
return false;
}
//save distance storage
/*
nl->ReadFromString(distancestorageTypeInfo, xType);
xNumericType =SecondoSystem::GetCatalog()->NumericType(xType);
if(!alldistance->Save(in_xValueRecord,
inout_iOffset,
xNumericType))
{
return false;
}
*/
return true;
}
/*
~Open~-function of type constructor ~network~
*/
Network *Network::Open ( SmiRecord& in_xValueRecord,
size_t& inout_iOffset,
const ListExpr in_xTypeInfo )
{
//cout << "NetworkOpen" << endl;
// Create network
return new Network ( in_xValueRecord,
inout_iOffset,
in_xTypeInfo );
}
/*
~NetworkProp~-funtion of the type constructor ~network~
*/
ListExpr Network::NetworkProp()
{
ListExpr examplelist = nl->TextAtom();
nl->AppendText ( examplelist,
"thenetwork(<id>,<routes-relation>, <junctions-relation>)" );
return ( nl->TwoElemList (
nl->TwoElemList ( nl->StringAtom ( "Creation" ),
nl->StringAtom ( "Example Creation" ) ),
nl->TwoElemList ( examplelist,
nl->StringAtom ( "(let n = thenetwork(id, r,j))" ) ) ));
}
/*
~OutNetwork~-funtion of the type constructor ~network~
*/
ListExpr Network::OutNetwork ( ListExpr typeInfo, Word value )
{
Network *n = ( Network* ) value.addr;
return n->Out ( typeInfo );
}
/*
~InNetwork~-funtion of the type constructor ~network~
*/
Word Network::InNetwork ( ListExpr in_xTypeInfo,
ListExpr in_xValue,
int in_iErrorPos,
ListExpr& inout_xErrorInfo,
bool& inout_bCorrect )
{
//cout << "inNetwork" << endl;
Network* pNetwork = new Network ( in_xValue,
in_iErrorPos,
inout_xErrorInfo,
inout_bCorrect );
if ( inout_bCorrect )
{
return SetWord ( pNetwork );
}
else
{
delete pNetwork;
return SetWord ( Address ( 0 ) );
}
}
/*
~CreateNetwork~-funtion of the type constructor ~network~
*/
Word Network::CreateNetwork ( const ListExpr typeInfo )
{
return SetWord ( new Network() );
}
/*
~CloseNetwork~-funtion of the type constructor ~network~
*/
void Network::CloseNetwork ( const ListExpr typeInfo, Word& w )
{
delete static_cast<Network*> ( w.addr );
w.addr = 0;
}
/*
~Clone~-function of type constructor ~network~
Not implemented yet.
*/
Word Network::CloneNetwork ( const ListExpr typeInfo, const Word& w )
{
return SetWord ( Address ( 0 ) );
}
/*
~DeleteNetwork~-funtion of the type constructor ~network~
*/
void Network::DeleteNetwork ( const ListExpr typeInfo, Word& w )
{
Network* n = ( Network* ) w.addr;
//n->Destroy();
delete n;
w.addr = 0;
}
/*
~CheckNetwork~-funtion of the type constructor ~network~
*/
bool Network::CheckNetwork ( ListExpr type, ListExpr& errorInfo )
{
return ( nl->IsEqual ( type, "network" ) );
}
/*
~CastNetwork~-funtion of the type constructor ~network~
*/
void* Network::CastNetwork ( void* addr )
{
return ( 0 );
}
/*
~SaveNetwork~-funtion of the type constructor ~network~
*/
bool Network::SaveNetwork ( SmiRecord& valueRecord,
size_t& offset,
const ListExpr typeInfo,
Word& value )
{
// cout << "Save Network" << endl;
Network *n = ( Network* ) value.addr;
return n->Save ( valueRecord, offset, typeInfo );
}
/*
~OpenNetwork~-funtion of the type constructor ~network~
*/
bool Network::OpenNetwork ( SmiRecord& valueRecord,
size_t& offset,
const ListExpr typeInfo,
Word& value )
{
value.addr = Network::Open ( valueRecord, offset, typeInfo );
return value.addr != 0;
}
/*
~SizeOfNetwork~-funtion of the type constructor ~network~
*/
int Network::SizeOfNetwork()
{
return 0;
}
/*
~IsDefined~-funtion of the type constructor ~network~
*/
int Network::IsDefined()
{
return m_bDefined;
}
/*
Secondo TypeConstructor for class ~Network~
*/
TypeConstructor network ( "network", Network::NetworkProp,
Network::OutNetwork, Network::InNetwork,
0, 0,
Network::CreateNetwork, Network::DeleteNetwork,
Network::OpenNetwork, Network::SaveNetwork,
Network::CloseNetwork, Network::CloneNetwork,
Network::CastNetwork, Network::SizeOfNetwork,
Network::CheckNetwork );
/*
3.2 class ~GLine~
3.2.1 Constructors
The simple constructor. Should not be used.
*/
GLine::GLine():Attribute()
{}
GLine::GLine ( int in_iSize ) :
Attribute(true),
m_xRouteIntervals ( in_iSize )
{
SetDefined(true);
m_bSorted = false;
m_dLength = 0.0;
}
GLine::GLine ( const GLine* in_xOther ) :
Attribute(in_xOther->IsDefined()),
m_xRouteIntervals ( 0 )
{
SetDefined(in_xOther->IsDefined());
m_bSorted = in_xOther->m_bSorted;
m_iNetworkId = in_xOther->m_iNetworkId;
m_dLength = 0.0;
// Iterate over all RouteIntervalls
for ( int i = 0; i < in_xOther->m_xRouteIntervals.Size(); i++ )
{
// Get next Interval
RouteInterval pCurrentInterval;
in_xOther->m_xRouteIntervals.Get ( i, pCurrentInterval );
int iRouteId = pCurrentInterval.GetRouteId();
double dStart = pCurrentInterval.GetStartPos();
double dEnd = pCurrentInterval.GetEndPos();
AddRouteInterval ( iRouteId,
dStart,
dEnd );
}
TrimToSize();
}
GLine::GLine ( ListExpr in_xValue,
int in_iErrorPos,
ListExpr& inout_xErrorInfo,
bool& inout_bCorrect ):
Attribute(true)
{
// Check the list
if ( ! ( nl->ListLength ( in_xValue ) == 2 ) )
{
string strErrorMessage = "GLine(): List length must be 2.";
inout_xErrorInfo = nl->Append ( inout_xErrorInfo,
nl->StringAtom ( strErrorMessage ) );
inout_bCorrect = false;
SetDefined(false);
m_bSorted = false;
return;
}
// Split into the two parts
ListExpr xNetworkIdList = nl->First ( in_xValue );
ListExpr xRouteIntervalList = nl->Second ( in_xValue );
// Check the parts
if ( !nl->IsAtom ( xNetworkIdList ) ||
nl->AtomType ( xNetworkIdList ) != IntType )
{
string strErrorMessage = "GLine(): Error while reading network-id.";
inout_xErrorInfo = nl->Append ( inout_xErrorInfo,
nl->StringAtom ( strErrorMessage ) );
SetDefined(false);
m_bSorted = false;
inout_bCorrect = false;
return;
}
m_iNetworkId = nl->IntValue ( xNetworkIdList );
m_dLength = 0.0;
if ( !nl->IsEmpty ( xRouteIntervalList ) )
{
// Iterate over all routes
while ( !nl->IsEmpty ( xRouteIntervalList ) )
{
ListExpr xCurrentRouteInterval = nl->First ( xRouteIntervalList );
xRouteIntervalList = nl->Rest ( xRouteIntervalList );
if ( nl->ListLength ( xCurrentRouteInterval ) != 3 ||
( !nl->IsAtom ( nl->First ( xCurrentRouteInterval ) ) ) ||
nl->AtomType ( nl->First ( xCurrentRouteInterval ) ) != IntType ||
( !nl->IsAtom ( nl->Second ( xCurrentRouteInterval ) ) ) ||
nl->AtomType ( nl->Second ( xCurrentRouteInterval ) ) != RealType
||
( !nl->IsAtom ( nl->Third ( xCurrentRouteInterval ) ) ) ||
nl->AtomType ( nl->Third ( xCurrentRouteInterval ) ) != RealType )
{
string strErrorMessage = "GLine(): Error while reading route-interval.";
inout_xErrorInfo = nl->Append ( inout_xErrorInfo,
nl->StringAtom ( strErrorMessage ) );
inout_bCorrect = false;
SetDefined(false);
m_bSorted = false;
return;
}
// Read attributes from list
// Read values from table
int iRouteId = nl->IntValue ( nl->First ( xCurrentRouteInterval ) );
double dStart = nl->RealValue ( nl->Second ( xCurrentRouteInterval ) );
double dEnd = nl->RealValue ( nl->Third ( xCurrentRouteInterval ) );
AddRouteInterval ( iRouteId,
dStart,
dEnd );
}
inout_bCorrect = true;
SetDefined(true);
m_bSorted = false;
}
else
{
SetDefined(false);
m_bSorted = false;
inout_bCorrect = true;
}
TrimToSize();
return;
}
/*
2.2.2 Methods of class ~GLine~
*/
void GLine::SetNetworkId ( int in_iNetworkId )
{
m_iNetworkId = in_iNetworkId;
SetDefined(true);
}
void GLine::AddRouteInterval ( RouteInterval ri )
{
m_xRouteIntervals.Append ( ri );
m_dLength = m_dLength + fabs ( ri.GetEndPos() - ri.GetStartPos() );
}
void GLine::AddRouteInterval ( int in_iRouteId,
double in_dStart,
double in_dEnd )
{
RouteInterval *ri = new RouteInterval ( in_iRouteId,
in_dStart,
in_dEnd );
AddRouteInterval ( *ri );
delete ri;
}
bool GLine::IsSorted()
{
return m_bSorted;
}
void GLine::SetSorted ( bool in_bSorted )
{
m_bSorted = in_bSorted;
}
/*
Secondo Integration
*/
Word GLine::In ( const ListExpr typeInfo, const ListExpr instance,
const int errorPos, ListExpr& errorInfo, bool& correct )
{
GLine* pGline = new GLine ( 0 );
if ( nl->ListLength ( instance ) == 0 )
{
correct = true;
pGline->SetDefined ( false );
return SetWord ( pGline );
}
if ( nl->ListLength ( instance ) != 2 )
{
correct = false;
pGline->DeleteIfAllowed();
cmsg.inFunError ( "Expecting (networkid (list of routeintervals))" );
return SetWord ( Address ( 0 ) );
}
ListExpr FirstElem = nl->First ( instance );
ListExpr SecondElem = nl->Second ( instance );
if ( !nl->IsAtom ( FirstElem ) || !nl->AtomType ( FirstElem ) == IntType )
{
correct = false;
pGline->DeleteIfAllowed();
cmsg.inFunError ( "Networkadress is not evaluable" );
return SetWord ( Address ( 0 ) );
}
pGline->SetNetworkId ( nl->IntValue ( FirstElem ) );
if ( nl->IsEmpty ( SecondElem ) )
{
correct = false;
pGline->DeleteIfAllowed();
return SetWord ( Address ( 0 ) );
}
while ( !nl->IsEmpty ( SecondElem ) )
{
ListExpr start = nl->First ( SecondElem );
SecondElem = nl->Rest ( SecondElem );
if ( nl->ListLength ( start ) != 3 )
{
correct = false;
pGline->DeleteIfAllowed();
cmsg.inFunError ( "Routeinterval incorrect.Expected list of 3 Elements."
);
return SetWord ( Address ( 0 ) );
}
ListExpr lrid = nl->First ( start );
ListExpr lpos1 = nl->Second ( start );
ListExpr lpos2 = nl->Third ( start );
if ( !nl->IsAtom ( lrid ) || !nl->AtomType ( lrid ) == IntType ||
!nl->IsAtom ( lpos1 ) || !nl->AtomType ( lpos1 ) == RealType ||
!nl->IsAtom ( lpos2 ) || !nl->AtomType ( lpos2 ) == RealType )
{
correct = false;
pGline->DeleteIfAllowed();
cmsg.inFunError ( "Routeinterval should be list int, real, real." );
return SetWord ( Address ( 0 ) );
}
pGline->AddRouteInterval ( nl->IntValue ( lrid ),
nl->RealValue ( lpos1 ),
nl->RealValue ( lpos2 ) );
}
correct = true;
pGline->SetDefined(true);
pGline->TrimToSize();
return SetWord ( pGline );
}
ListExpr GLine::Out ( ListExpr in_xTypeInfo,
Word in_xValue )
{
GLine *pGline = ( GLine* ) in_xValue.addr;
if ( pGline == 0 || !pGline->IsDefined() )
{
return nl->SymbolAtom ( "undef" );
}
ListExpr xLast = nl->TheEmptyList();
ListExpr xNext = nl->TheEmptyList();
bool bFirst = true;
ListExpr xNetworkId = nl->IntAtom ( pGline->m_iNetworkId );
ListExpr xRouteIntervals = nl->TheEmptyList();
// Iterate over all RouteIntervalls
for ( int i = 0; i < pGline->m_xRouteIntervals.Size(); ++i )
{
// Get next Interval
RouteInterval pCurrentInterval;
pGline->m_xRouteIntervals.Get ( i, pCurrentInterval );
int iRouteId = pCurrentInterval.GetRouteId();
double dStart = pCurrentInterval.GetStartPos();
double dEnd = pCurrentInterval.GetEndPos();
// Build list
xNext = nl->ThreeElemList ( nl->IntAtom ( iRouteId ),
nl->RealAtom ( dStart ),
nl->RealAtom ( dEnd ) );
// Create new list or append element to existing list
if ( bFirst )
{
xRouteIntervals = nl->OneElemList ( xNext );
xLast = xRouteIntervals;
bFirst = false;
}
else
{
xLast = nl->Append ( xLast, xNext );
}
}
if ( pGline->m_xRouteIntervals.Size() == 0 )
{
xRouteIntervals = nl->TheEmptyList();
}
return nl->TwoElemList ( xNetworkId,
xRouteIntervals );
}
Word GLine::Create ( const ListExpr typeInfo )
{
return SetWord ( new GLine ( 0 ) );
}
void GLine::Clear()
{
m_xRouteIntervals.clean();
SetSorted ( false );
m_dLength = 0.0;
}
void GLine::Delete ( const ListExpr typeInfo,
Word& w )
{
GLine *l = ( GLine* ) w.addr;
//if (l->del.refs == 1) l->m_xRouteIntervals.Destroy();
l->DeleteIfAllowed();
w.addr = 0;
}
void GLine::Close ( const ListExpr typeInfo,
Word& w )
{
( ( GLine* ) w.addr )->DeleteIfAllowed();
w.addr = 0;
}
Word GLine::CloneGLine ( const ListExpr typeInfo,
const Word& w )
{
return SetWord ( ( ( GLine* ) w.addr )->Clone() );
}
GLine* GLine::Clone() const
{
GLine *xOther = new GLine ( Size() );
xOther->SetDefined ( IsDefined() );
xOther->SetSorted ( m_bSorted );
xOther->SetNetworkId ( m_iNetworkId );
/*RouteInterval ri;
for ( int i = 0; i < Size(); i++ )
{
Get ( i, ri );
int rid = ri.GetRouteId();
double start = ri.GetStartPos();
double end = ri.GetEndPos();
xOther->AddRouteInterval ( rid, start, end );
}*/
xOther->m_xRouteIntervals.copyFrom(m_xRouteIntervals);
return xOther;
}
void* GLine::Cast ( void* addr )
{
return new ( addr ) GLine;
}
int GLine::Size() const
{
return m_xRouteIntervals.Size();
}
int GLine::SizeOf()
{
return sizeof ( GLine );
}
size_t GLine::Sizeof() const
{
return sizeof ( *this );
}
ostream& GLine::Print ( ostream& os ) const
{
os << "GLine: NetworkId: " << m_iNetworkId << endl;
for ( int i = 0; i < m_xRouteIntervals.Size() ; i++ )
{
RouteInterval ri;
Get ( i, ri );
os << "RouteInterval: " << i << " rid: " << ri.GetRouteId();
os << " from: " << ri.GetStartPos() << " to: " << ri.GetEndPos();
os << endl;
}
os << " end gline";
return os;
};
bool GLine::Adjacent ( const Attribute* arg ) const
{
return false;
}
/*
Compare
*/
int GLine::Compare ( const Attribute* arg ) const
{
GLine *gl2 = ( GLine* ) arg;
if ( IsDefined() && !gl2->IsDefined() ) return 1;
else
if ( !IsDefined() && gl2->IsDefined() ) return -1;
else
if ( !IsDefined() && !gl2->IsDefined() ) return 0;
else
if ( m_dLength < gl2->m_dLength ) return -1;
else
if ( m_dLength > gl2->m_dLength ) return 1;
else
if ( m_xRouteIntervals.Size() < gl2->m_xRouteIntervals.Size() )
return -1;
else
if ( m_xRouteIntervals.Size() > gl2->m_xRouteIntervals.Size() )
return 1;
else
if ( *this == *gl2 ) return 0;
else
{
RouteInterval ri1, ri2;
int i = 0;
while ( i < m_xRouteIntervals.Size() )
{
Get ( i,ri1 );
gl2->Get ( i,ri2 );
if ( ri1.GetRouteId() < ri2.GetRouteId() ) return -1;
else
if ( ri1.GetRouteId() > ri2.GetRouteId() ) return 1;
else
if ( ri1.GetStartPos() < ri2.GetStartPos() ) return -1;
else
if ( ri1.GetStartPos() > ri2.GetStartPos() ) return 1;
else
if ( ri1.GetEndPos() < ri2.GetEndPos() ) return -1;
else
if ( ri1.GetEndPos() > ri2.GetEndPos() ) return 1;
i++;
}
}
return 0;
}
GLine& GLine::operator= ( const GLine& l )
{
m_xRouteIntervals.copyFrom(l.m_xRouteIntervals);
m_bSorted = l.m_bSorted;
SetDefined(l.IsDefined());
m_iNetworkId = l.m_iNetworkId;
TrimToSize();
return *this;
}
bool GLine::operator== ( const GLine& l ) const
{
if ( !IsDefined() || !l.IsDefined())
{
return false;
}
else
{
RouteInterval rIt, rIl;
if ( m_xRouteIntervals.Size() == l.m_xRouteIntervals.Size() &&
AlmostEqual ( m_dLength, l.m_dLength ) )
{
if ( m_bSorted && l.m_bSorted )
{
for ( int i=0; i < m_xRouteIntervals.Size(); i++ )
{
Get ( i,rIt );
l.Get ( i,rIl );
if ( ! ( rIt.GetRouteId() == rIl.GetRouteId() &&
rIt.GetStartPos() == rIl.GetStartPos() &&
rIt.GetEndPos() == rIl.GetEndPos() ) ) return false;
}
return true;
}
else
{
for ( int i=0; i < m_xRouteIntervals.Size(); i++ )
{
Get ( i,rIt );
for ( int j = 0; j < m_xRouteIntervals.Size(); j++ )
{
l.Get ( i,rIl );
if ( ! ( rIt.GetRouteId() == rIl.GetRouteId() &&
rIt.GetStartPos() == rIl.GetStartPos() &&
rIt.GetEndPos() == rIl.GetEndPos() ) ) return false;
}
}
return true;
}
}
else return false;
}
}
size_t GLine::HashValue() const
{
size_t xHash = m_iNetworkId;
// Iterate over all RouteIntervalls
for ( int i = 0; i < m_xRouteIntervals.Size(); ++i )
{
// Get next Interval
RouteInterval pCurrentInterval;
m_xRouteIntervals.Get ( i, pCurrentInterval );
// Add something for each entry
int iRouteId = pCurrentInterval.GetRouteId();
double dStart = pCurrentInterval.GetStartPos();
double dEnd = pCurrentInterval.GetEndPos();
xHash += iRouteId + ( size_t ) dStart + ( size_t ) dEnd;
}
return xHash;
}
int GLine::NumOfFLOBs() const
{
return 1;
}
Flob* GLine::GetFLOB ( const int i )
{
if ( i == 0 ) return &m_xRouteIntervals;
return 0;
}
DbArray<RouteInterval>* GLine::GetRouteIntervals()
{
if ( IsDefined() ) return &m_xRouteIntervals;
else return 0;
};
void GLine::CopyFrom ( const Attribute* right )
{
*this = * ( ( const GLine* ) right );
//Clear();
/*
GLine *src = (GLine*) right;
SetDefined(src->IsDefined());
SetSorted(src->IsSorted());
const RouteInterval* ri;
for (int i = 0; i < src->Size(); i++) {
src->Get(i,ri);
int rid = ri.GetRouteId();
double start = ri.GetStartPos();
double end = ri.GetEndPos();
AddRouteInterval(rid, start, end);
}
*/
}
double GLine::GetLength()
{
return m_dLength;
}
int GLine::GetNetworkId()
{
return m_iNetworkId;
};
/*
~Get~ returns the route interval at position i in the route intervals ~DbArray~.
*/
void GLine::Get ( const int i, RouteInterval &ri ) const
{
m_xRouteIntervals.Get ( i, ri );
};
int GLine::NoOfComponents()
{
return m_xRouteIntervals.Size();
};
ListExpr GLine::Property()
{
return ( nl->TwoElemList (
nl->FourElemList ( nl->StringAtom ( "Signature" ),
nl->StringAtom ( "Example Type List" ),
nl->StringAtom ( "List Rep" ),
nl->StringAtom ( "Example List" ) ),
nl->FourElemList (
nl->StringAtom ( "-> DATA" ),
nl->StringAtom ( "gline" ),
nl->StringAtom ( "(<nid> ((<rid> <startpos><endpos>)...))"),
nl->StringAtom ( "(1 ((1 1.5 2.5)(2 1.5 2.0)))" ) ) ) );
}
bool GLine::Check ( ListExpr type, ListExpr& errorInfo )
{
return ( nl->IsEqual ( type, "gline" ) );
}
/*
Netdistance method computes the network distance between two glines. Uses
network distance method of ~GPoint~.
*/
double GLine::Netdistance ( GLine* pgl2 )
{
//GLine* pgl1 = (GLine*) this;
double minDist = numeric_limits<double>::max();
double aktDist = numeric_limits<double>::max();
if ( GetNetworkId() != pgl2->GetNetworkId() )
{
cmsg.inFunError ( "Both glines must belong to the network." );
return minDist;
}
GPoints *bGPgl1 = GetBGP();
GPoints *bGPgl2 = pgl2->GetBGP();
GPoint gp1, gp2;
for ( int i = 0; i < bGPgl1->Size(); i++ )
{
bGPgl1->Get ( i,gp1 );
if ( gp1.Inside ( pgl2 ) )
{
bGPgl1->DeleteIfAllowed();
bGPgl2->DeleteIfAllowed();
return 0.0;
}
for ( int j = 0; j < bGPgl2->Size(); j++ )
{
bGPgl2->Get ( j, gp2 );
if ( gp2.Inside ( this ) )
{
bGPgl1->DeleteIfAllowed();
bGPgl2->DeleteIfAllowed();
return 0.0;
}
aktDist = gp1.Netdistance ( &gp2 );
if ( aktDist < minDist ) minDist = aktDist;
if ( minDist <= 0.0 )
{
bGPgl1->DeleteIfAllowed();
bGPgl2->DeleteIfAllowed();
return 0.0;
}
}
}
bGPgl1->DeleteIfAllowed();
bGPgl2->DeleteIfAllowed();
return minDist;
}
/*
Distance method computes the Euclidean Distance between two glines. Uses
distance method of ~GPoint~.
*/
double GLine::Distance ( GLine* pgl2 )
{
Line *l1 = new Line ( 0 );
Line *l2 = new Line ( 0 );
Gline2line ( l1 );
pgl2->Gline2line ( l2 );
if ( l1->IsDefined() && l2->IsDefined() )
{
double res = l1->Distance ( *l2 );
l1->DeleteIfAllowed();
l2->DeleteIfAllowed();
return res;
}
else return numeric_limits<double>::max();
}
void GLine::Uniongl ( GLine *pgl2, GLine *res )
{
RouteInterval pRi1, pRi2;
if ( !IsDefined() || NoOfComponents() == 0 )
{
if ( pgl2->IsDefined() && pgl2->NoOfComponents() > 0 )
{
if ( pgl2->IsSorted() )
{
for ( int j = 0; j < pgl2->NoOfComponents(); j++ )
{
pgl2->Get ( j,pRi2 );
res->AddRouteInterval ( pRi2.GetRouteId(),
pRi2.GetStartPos(),
pRi2.GetEndPos() );
}
}
else
{
pgl2->Get ( 0,pRi2 );
RITree *ritree = new RITree ( pRi2.GetRouteId(),
pRi2.GetStartPos(), pRi2.GetEndPos(),0,0
);
for ( int j = 1; j < pgl2->NoOfComponents(); j++ )
{
pgl2->Get ( j,pRi2 );
ritree->Insert ( pRi2.GetRouteId(), pRi2.GetStartPos(),
pRi2.GetEndPos() );
}
ritree->TreeToGLine ( res );
ritree->RemoveTree();
}
res->SetDefined ( true );
res->SetSorted ( true );
res->SetNetworkId ( pgl2->GetNetworkId() );
}
else
{
res->SetDefined ( false );
res->SetSorted ( false );
}
}
else
{
if ( !pgl2->IsDefined() || pgl2->NoOfComponents() == 0 )
{
if ( IsDefined() && NoOfComponents() >0 )
{
if ( IsSorted() )
{
for ( int i = 0; i < NoOfComponents(); i++ )
{
Get ( i,pRi1 );
res->AddRouteInterval ( pRi1.GetRouteId(),
pRi1.GetStartPos(),
pRi1.GetEndPos() );
}
}
else
{
Get ( 0,pRi1 );
RITree *ritree = new RITree ( pRi1.GetRouteId(),
pRi1.GetStartPos(), pRi1.GetEndPos(),0,0
);
for ( int i = 1; i < NoOfComponents(); i++ )
{
Get ( i,pRi1 );
ritree->Insert ( pRi1.GetRouteId(), pRi1.GetStartPos(),
pRi1.GetEndPos() );
}
ritree->TreeToGLine ( res );
ritree->RemoveTree();
}
res->SetDefined ( true );
res->SetSorted ( true );
res->SetNetworkId ( GetNetworkId() );
}
else
{
res->SetDefined ( false );
res->SetSorted ( false );
}
}
else
{
if ( GetNetworkId() != pgl2->GetNetworkId() )
{
res->SetDefined ( false );
res->SetSorted ( false );
}
else
{
res->SetNetworkId ( GetNetworkId() );
if ( IsSorted() && pgl2->IsSorted() )
{
int i=0;
int j=0;
bool newroute = false;
int iRouteId;
double start, end;
while ( i < NoOfComponents() && j < pgl2->NoOfComponents() )
{
Get ( i, pRi1 );
pgl2->Get ( j, pRi2 );
if ( pRi1.GetRouteId() < pRi2.GetRouteId() )
{
res->AddRouteInterval ( pRi1.GetRouteId(),
pRi1.GetStartPos(),
pRi1.GetEndPos() );
i++;
}
else
{
if ( pRi1.GetRouteId() > pRi2.GetRouteId() )
{
res->AddRouteInterval ( pRi2.GetRouteId(), pRi2.GetStartPos(),
pRi2.GetEndPos() );
j++;
}
else
{
if ( pRi1.GetEndPos() < pRi2.GetStartPos() )
{
res->AddRouteInterval ( pRi1.GetRouteId(), pRi1.GetStartPos(),
pRi1.GetEndPos() );
i++;
}
else
{
if ( pRi2.GetEndPos() < pRi1.GetStartPos() )
{
res->AddRouteInterval ( pRi2.GetRouteId(),
pRi2.GetStartPos(),
pRi2.GetEndPos() );
j++;
}
else
{
iRouteId = pRi1.GetRouteId();
start = min ( pRi1.GetStartPos(), pRi2.GetStartPos() ),
end = max ( pRi1.GetEndPos(), pRi2.GetEndPos() );
i++;
j++;
newroute = false;
while ( i < NoOfComponents() && !newroute )
{
Get ( i,pRi1 );
if ( pRi1.GetRouteId() == iRouteId )
{
if ( pRi1.GetStartPos() <= end )
{
end = max ( pRi1.GetEndPos(), end );
i++;
}
else newroute = true;
}
else newroute = true;
}
newroute = false;
while ( j < pgl2->NoOfComponents() && !newroute )
{
pgl2->Get ( j,pRi2 );
if ( pRi2.GetRouteId() == iRouteId )
{
if ( pRi2.GetStartPos() <= end )
{
end = max ( pRi2.GetEndPos(), end );
j++;
}
else newroute = true;
}
else newroute = true;
}
res->AddRouteInterval ( iRouteId, start, end );
}
}
}
}
}
while ( i < NoOfComponents() )
{
Get ( i,pRi1 );
res->AddRouteInterval ( pRi1.GetRouteId(),
pRi1.GetStartPos(),
pRi1.GetEndPos() );
i++;
}
while ( j < pgl2->NoOfComponents() )
{
pgl2->Get ( j,pRi2 );
res->AddRouteInterval ( pRi2.GetRouteId(), pRi2.GetStartPos(),
pRi2.GetEndPos() );
j++;
}
res->SetDefined ( true );
res->SetSorted ( true );
}
else
{
RITree *ritree;
Get ( 0,pRi1 );
ritree = new RITree ( pRi1.GetRouteId(),
pRi1.GetStartPos(), pRi1.GetEndPos(),0,0 );
for ( int i = 1; i < NoOfComponents(); i++ )
{
Get ( i,pRi1 );
ritree->Insert ( pRi1.GetRouteId(), pRi1.GetStartPos(),
pRi1.GetEndPos() );
}
for ( int j = 0; j < pgl2->NoOfComponents(); j++ )
{
pgl2->Get ( j,pRi2 );
ritree->Insert ( pRi2.GetRouteId(), pRi2.GetStartPos(),
pRi2.GetEndPos() );
}
ritree->TreeToGLine ( res );
ritree->RemoveTree();
res->SetDefined ( true );
res->SetSorted ( true );
}
}
}
}
res->TrimToSize();
}
void GLine::Gline2line ( Line* res )
{
res->Clear();
if ( IsDefined() && NoOfComponents() > 0 )
{
//Network* pNetwork = NetworkManager::GetNetwork(GetNetworkId());
Network* pNetwork = NetworkManager::GetNetworkNew ( GetNetworkId(), netList
);
RouteInterval rI;
Line *l = new Line ( 0 );
Line *x = l;
for ( int i=0; i < this->NoOfComponents(); i++ )
{
this->Get ( i,rI );
SimpleLine *pSubline = new SimpleLine ( 0 );
pNetwork->GetLineValueOfRouteInterval ( &rI, pSubline );
if ( pSubline->IsDefined() )
{
Line *partLine = new Line ( 0 );
pSubline->toLine ( *partLine );
pSubline->DeleteIfAllowed();
x = SetOp ( *l, *partLine, avlseg::union_op );
partLine->DeleteIfAllowed();
l->DeleteIfAllowed();
l = x;
}
}
NetworkManager::CloseNetwork ( pNetwork );
( *res ) = *x;
x->DeleteIfAllowed();
res->SetDefined ( true );
}
else
{
if ( IsDefined() && NoOfComponents() == 0 )
{
res->SetDefined ( true );
}
else
{
res->SetDefined ( false );
}
}
res->TrimToSize();
}
bool GLine::Intersects ( GLine *pgl )
{
RouteInterval pRi1, pRi2;
if ( !IsSorted() )
{
for ( int i = 0; i < NoOfComponents(); i++ )
{
Get ( i, pRi1 );
if ( pgl->IsSorted() )
{
if ( searchUnit ( pgl, 0, pgl->NoOfComponents()-1, pRi1 ) )
{
return true;
};
}
else
{
for ( int j = 0 ; j < pgl->NoOfComponents(); j ++ )
{
pgl->Get ( j,pRi2 );
if ( pRi1.GetRouteId() == pRi2.GetRouteId() &&
( ! ( pRi1.GetEndPos() < pRi2.GetStartPos() ||
pRi2.GetStartPos() > pRi1.GetEndPos() ) ) )
{
return true;
}
}
}
}
}
else
{
if ( pgl->IsSorted() )
{
int i = 0;
int j = 0;
while ( i<NoOfComponents() && j < pgl->NoOfComponents() )
{
Get ( i,pRi1 );
pgl->Get ( j,pRi2 );
if ( pRi1.GetRouteId() < pRi2.GetRouteId() ) i++;
else
if ( pRi1.GetRouteId() > pRi2.GetRouteId() ) j++;
else
if ( pRi1.GetStartPos() > pRi2.GetEndPos() ) j++;
else
if ( pRi1.GetEndPos() < pRi2.GetStartPos() ) i++;
else return true;
}
}
else
{
for ( int i = 0; i < pgl->NoOfComponents(); i++ )
{
pgl->Get ( i, pRi2 );
if ( searchUnit ( this, 0, NoOfComponents()-1, pRi2 ) ) return true;
}
}
}
return false;
}
/*
Secondo Type Constructor for class ~GLine~
*/
TypeConstructor gline (
"gline", //name
GLine::Property, //property function
GLine::Out, GLine::In, //Out and In functions
0, 0, //SaveToList and
//RestoreFromList functions
GLine::Create, GLine::Delete, //object creation and deletion
OpenAttribute<GLine>, SaveAttribute<GLine>, //open and save functions
GLine::Close, GLine::CloneGLine, //object close, and clone
GLine::Cast, //cast function
GLine::SizeOf, //sizeof function
GLine::Check ); //kind checking function
/*
3.3 class ~GPoint~
3.3.1 Constructors
See ~network.h~ class definition of ~GPoint~
3.3.2 Methods of class ~GPoint~
*/
Word GPoint::InGPoint ( const ListExpr typeInfo,
const ListExpr instance,
const int errorPos,
ListExpr& errorInfo,
bool& correct )
{
if ( nl->ListLength ( instance ) == 4 )
{
if ( nl->IsAtom ( nl->First ( instance ) ) &&
nl->AtomType ( nl->First ( instance ) ) == IntType &&
nl->IsAtom ( nl->Second ( instance ) ) &&
nl->AtomType ( nl->Second ( instance ) ) == IntType &&
nl->IsAtom ( nl->Third ( instance ) ) &&
nl->AtomType ( nl->Third ( instance ) ) == RealType &&
nl->IsAtom ( nl->Fourth ( instance ) ) &&
nl->AtomType ( nl->Fourth ( instance ) ) == IntType )
{
GPoint *gp = new GPoint (
true,
nl->IntValue ( nl->First ( instance ) ),
nl->IntValue ( nl->Second ( instance ) ),
nl->RealValue ( nl->Third ( instance ) ),
( Side ) nl->IntValue ( nl->Fourth ( instance ) ) );
correct = true;
return SetWord ( gp );
}
}
correct = false;
return SetWord ( Address ( 0 ) );
}
ListExpr GPoint::OutGPoint ( ListExpr typeInfo, Word value )
{
GPoint *gp = ( GPoint* ) value.addr;
if ( gp->IsDefined() )
{
return nl->FourElemList (
nl->IntAtom ( gp->GetNetworkId() ),
nl->IntAtom ( gp->GetRouteId() ),
nl->RealAtom ( gp->GetPosition() ),
nl->IntAtom ( gp->GetSide() ) );
}
return nl->SymbolAtom ( "undef" );
}
Word GPoint::CreateGPoint ( const ListExpr typeInfo )
{
return SetWord ( new GPoint ( false ) );
}
void GPoint::DeleteGPoint ( const ListExpr typeInfo, Word& w )
{
GPoint *gp = ( GPoint* ) w.addr;
if (gp->DeleteIfAllowed()) w.addr = 0;
}
void GPoint::CloseGPoint ( const ListExpr typeInfo, Word& w )
{
GPoint *gp = ( GPoint* ) w.addr;
if(gp->DeleteIfAllowed()) w.addr = 0;
}
Word GPoint::CloneGPoint ( const ListExpr typeInfo, const Word& w )
{
return SetWord ( ( ( GPoint* ) w.addr )->Clone() );
}
void* GPoint::CastGPoint ( void* addr )
{
return new ( addr ) GPoint;
}
int GPoint::SizeOfGPoint()
{
return sizeof ( GPoint );
}
ListExpr GPoint::GPointProperty()
{
return ( nl->TwoElemList (
nl->FourElemList ( nl->StringAtom ( "Signature" ),
nl->StringAtom ( "Example Type List" ),
nl->StringAtom ( "List Rep" ),
nl->StringAtom ( "Example List" ) ),
nl->FourElemList ( nl->StringAtom ( "-> DATA" ),
nl->StringAtom ( "gpoint" ),
nl->StringAtom ( "(<network_id> <route_id> "
"<position> <side>)" ),
nl->StringAtom ( "(1 1 0.0 0)" ) ) ) );
}
bool GPoint::CheckGPoint ( ListExpr type, ListExpr& errorInfo )
{
return ( nl->IsEqual ( type, "gpoint" ) );
}
/*
Netdistance function computes the network distance between two ~GPoint~s.
Using Dijkstras-Algorithm for shortest path computing
*/
double GPoint::Netdistance ( GPoint* pToGPoint )
{
GLine* pGLine = new GLine ( 0 );
double res;
if ( ShortestPath ( pToGPoint, pGLine ) )
{
res = pGLine->GetLength();
pGLine->DeleteIfAllowed();
return res;
}
else
{
pGLine->DeleteIfAllowed();
return 0;
}
}
double GPoint::NewNetdistance ( GPoint* pToGPoint,GLine* gline )
{
GPoint* gp1 = new GPoint ( true,GetNetworkId(),GetRouteId(),GetPosition() );
GPoint* gp2 = new GPoint ( true,pToGPoint->GetNetworkId(),
pToGPoint->GetRouteId(),pToGPoint->GetPosition() );
double res;
if ( gp1->ShortestPath ( gp2, gline ) )
{
res = gline->GetLength();
gp1->DeleteIfAllowed();
gp2->DeleteIfAllowed();
return res;
}
else
{
gp1->DeleteIfAllowed();
gp2->DeleteIfAllowed();
return 0;
}
}
/*
Distance function computes the Euclidean Distance between two ~GPoint~s.
*/
double GPoint::Distance ( GPoint* pToGPoint )
{
map<int,string>::iterator it = netList->begin();
if ( IsDefined() && pToGPoint->IsDefined() &&
GetNetworkId() == pToGPoint->GetNetworkId() )
{
//Network* pNetwork=NetworkManager::GetNetwork(GetNetworkId());
Network* pNetwork = NetworkManager::GetNetworkNew ( GetNetworkId(),
netList );
Point *from = new Point ( false );
pNetwork->GetPointOnRoute ( this, from );
Point *to = new Point ( false );
pNetwork->GetPointOnRoute ( pToGPoint,to );
double res = from->Distance ( *to );
from->DeleteIfAllowed();
to->DeleteIfAllowed();
NetworkManager::CloseNetwork ( pNetwork );
return res;
}
else return numeric_limits<double>::max();
}
/*
Returns true if the gpoint is inside the gline false elsewhere.
*/
bool GPoint::Inside ( GLine *gl )
{
if ( ! ( gl->IsDefined() ) || !IsDefined() ||
gl->NoOfComponents() < 1 ) return false;
if ( GetNetworkId() != gl->GetNetworkId() ) return false;
RouteInterval pCurrRInter;
if ( gl->IsSorted() )
return ( searchRouteInterval ( this, gl, 0, gl->NoOfComponents()-1 ) );
else
{
int i = 0;
while ( i < gl->NoOfComponents() )
{
gl->Get ( i, pCurrRInter );
if ( pCurrRInter.GetRouteId() == GetRouteId() )
{
if ( pCurrRInter.GetStartPos() < GetPosition() &&
GetPosition() < pCurrRInter.GetEndPos() )
return true;
if ( pCurrRInter.GetStartPos() > GetPosition() &&
GetPosition() > pCurrRInter.GetEndPos() )
return true;
if ( fabs ( pCurrRInter.GetStartPos() - GetPosition() ) < 0.1 )
return true;
if ( fabs ( pCurrRInter.GetEndPos() - GetPosition() ) < 0.1 )
return true;
}
i++;
}
return false;
}
return false;
}
bool GPoint::operator== ( const GPoint& p ) const
{
if ( !IsDefined() || !p.IsDefined() ) return false;
else
{
if ( m_iNetworkId == p.GetNetworkId() &&
m_xRouteLocation.rid == p.GetRouteId() &&
m_xRouteLocation.d == p.GetPosition() &&
( m_xRouteLocation.side == p.GetSide() || m_xRouteLocation.side == 2
||
p.GetSide() == 2 ) )
{
return true;
}
else return false;
}
}
bool GPoint::operator!= ( const GPoint& p ) const
{
return ! ( *this == p );
}
/*
Computes the shortest path between start and end in the network. Using
Dijkstras Algorithm. The path is returned as gline value.
*/
bool GPoint::ShortestPath ( GPoint *to, GLine *result )
{
GPoint* start =
new GPoint ( true,GetNetworkId(),GetRouteId(),GetPosition(), GetSide() );
GPoint* end = new GPoint ( true,to->GetNetworkId(),to->GetRouteId(),
to->GetPosition(),to->GetSide() );//copy the gpoint
result->Clear();
if ( start == 0 || end == 0 || !start->IsDefined() ||
!end->IsDefined() )
{
sendMessage ( "Both gpoints must exist and be defined." );
result->SetDefined ( false );
start->DeleteIfAllowed();
end->DeleteIfAllowed();
return false;
}
// Check wether both points belong to the same network
if ( start->GetNetworkId() != end->GetNetworkId() )
{
sendMessage ( "Both gpoints belong to different networks." );
result->SetDefined ( false );
start->DeleteIfAllowed();
end->DeleteIfAllowed();
return false;
}
result->SetNetworkId ( start->GetNetworkId() );
// Load the network
//Network* pNetwork = NetworkManager::GetNetwork(start->GetNetworkId());
Network* pNetwork = NetworkManager::GetNetworkNew ( start->GetNetworkId(),
netList );
if ( pNetwork == 0 )
{
sendMessage ( "Network not found." );
result->SetDefined ( false );
start->DeleteIfAllowed();
end->DeleteIfAllowed();
return false;
}
// Get sections where the path should start or end
TupleId startSectTID = pNetwork->GetTupleIdSectionOnRoute ( start );
Tuple* startSection = pNetwork->GetSection ( startSectTID );
if ( startSection == 0 )
{
sendMessage ( "Starting GPoint not found in network." );
NetworkManager::CloseNetwork ( pNetwork );
result->SetDefined ( false );
start->DeleteIfAllowed();
end->DeleteIfAllowed();
return false;
}
TupleId lastSectTID = pNetwork->GetTupleIdSectionOnRoute ( end );
Tuple* endSection = pNetwork->GetSection ( lastSectTID );
if ( endSection == 0 )
{
sendMessage ( "End GPoint not found in network." );
startSection->DeleteIfAllowed();
NetworkManager::CloseNetwork ( pNetwork );
result->SetDefined ( false );
start->DeleteIfAllowed();
end->DeleteIfAllowed();
return false;
}
////////////////////////////////////////////////////
/* bool junctionpoint = false;
Point* endp = new Point();
pNetwork->GetPointOnRoute(end,endp); //end point
Point* startp = new Point();
pNetwork->GetPointOnRoute(start,startp);
if(fabs(endp->GetX() - startp->GetX()) < 0.1 &&
fabs(endp->GetY() - startp->GetY()) < 0.1){
endp->DeleteIfAllowed();
startp->DeleteIfAllowed();
start->DeleteIfAllowed();
end->DeleteIfAllowed();
startSection->DeleteIfAllowed();
endSection->DeleteIfAllowed();
NetworkManager::CloseNetwork(pNetwork);
return false;
}
vector<JunctionSortEntry> juns;
CcInt* routeid = new CcInt(true,end->GetRouteId());
pNetwork->GetJunctionsOnRoute(routeid,juns);
for(unsigned int i = 0;i < juns.size();i++){
Tuple* t = juns[i].m_pJunction;
if(((CcInt*)t->GetAttribute(JUNCTION_ROUTE1_ID))->GetIntval() ==
end->GetRouteId() &&
fabs(((CcReal*)t->GetAttribute(JUNCTION_ROUTE1_MEAS))->GetRealval()-
end->GetPosition()) < 0.1)
junctionpoint = true;
if(((CcInt*)t->GetAttribute(JUNCTION_ROUTE2_ID))->GetIntval() ==
end->GetRouteId() &&
fabs(((CcReal*)t->GetAttribute(JUNCTION_ROUTE2_MEAS))->GetRealval()-
end->GetPosition()) < 0.1)
junctionpoint = true;
}
vector<TupleId> secjunid;
if(junctionpoint){//it is a junction point
vector<DirectedSection> sectionlist;
if(fabs(end->GetPosition()-
((CcReal*)endSection->GetAttribute(SECTION_MEAS1))->GetRealval())< 0.1)
pNetwork->GetAdjacentSections(endSection->GetTupleId(),false,sectionlist);
else
pNetwork->GetAdjacentSections(endSection->GetTupleId(),true,sectionlist);
for(unsigned int i = 0;i < sectionlist.size();i++){
if(sectionlist[i].GetSectionTid() != endSection->GetTupleId())
secjunid.push_back(sectionlist[i].GetSectionTid());
}
}
endp->DeleteIfAllowed();
routeid->DeleteIfAllowed();*/
/////////////////////////////////////////////////////
/*
Calculate the shortest path using dijkstras algorithm.
*/
if ( startSectTID == lastSectTID ||
GetRouteId() == to->GetRouteId() )
{
result->AddRouteInterval ( start->GetRouteId(), start->GetPosition(),
end->GetPosition() );
}
else
{
/*
Initialize PriorityQueue
*/
PrioQueue *prioQ = new PrioQueue ( 0 );
SectIDTree *visitedSect = 0;
double sectMeas1 =
( ( CcReal* ) startSection->GetAttribute ( SECTION_MEAS1 )
)->GetRealval();
double sectMeas2 =
( ( CcReal* ) startSection->GetAttribute ( SECTION_MEAS2 )
)->GetRealval();
double dist = 0.0;
vector<DirectedSectionInfo> adjSectionList;
adjSectionList.clear();
if ( start->GetSide() == 0 )
{
dist = start->GetPosition() - sectMeas1;
pNetwork->GetAdjacentSectionsInfo ( startSectTID, false, adjSectionList );
SectIDTree *startTree = new SectIDTree ( startSectTID,
( TupleId ) numeric_limits<long>::max(),
false,
numeric_limits<int>::max() );
visitedSect = startTree;
for ( size_t i = 0; i < adjSectionList.size(); i++ )
{
DirectedSectionInfo actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != startSectTID )
{
PQEntry *actEntry = new PQEntry ( actNextSect.GetSectionTid(), dist,
actNextSect.GetUpDownFlag(),
startSectTID,
actNextSect.GetMeas1(),
actNextSect.GetMeas2(),
actNextSect.GetRid());
prioQ->Insert ( *actEntry, visitedSect ) ;
delete actEntry;
}
}
adjSectionList.clear();
}
else
{
if ( start->GetSide() == 1 )
{
dist = sectMeas2 - start->GetPosition();
SectIDTree *startTree = new SectIDTree ( startSectTID,
( TupleId ) numeric_limits<long>::max(),
true,
numeric_limits<int>::max() );
visitedSect = startTree;
pNetwork->GetAdjacentSectionsInfo ( startSectTID, true, adjSectionList);
for ( size_t i = 0; i < adjSectionList.size(); i++ )
{
DirectedSectionInfo actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != startSectTID )
{
PQEntry *actEntry = new PQEntry ( actNextSect.GetSectionTid(), dist,
actNextSect.GetUpDownFlag(),
startSectTID,
actNextSect.GetMeas1(),
actNextSect.GetMeas2(),
actNextSect.GetRid() );
prioQ->Insert ( *actEntry, visitedSect );
delete actEntry;
}
}
adjSectionList.clear();
}
else
{
dist = start->GetPosition() - sectMeas1;
pNetwork->GetAdjacentSectionsInfo ( startSectTID, false, adjSectionList);
bool first = true;
for ( size_t i = 0; i < adjSectionList.size(); i++ )
{
DirectedSectionInfo actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != startSectTID )
{
if ( first )
{
first = false;
SectIDTree *startTree = new SectIDTree ( startSectTID,
( TupleId ) numeric_limits<long>::max(),
false,
numeric_limits<int>::max() );
visitedSect = startTree;
}
PQEntry *actEntry = new PQEntry ( actNextSect.GetSectionTid(), dist,
actNextSect.GetUpDownFlag(),
startSectTID,
actNextSect.GetMeas1(),
actNextSect.GetMeas2(),
actNextSect.GetRid() );
prioQ->Insert ( *actEntry, visitedSect );
delete actEntry;
}
}
adjSectionList.clear();
dist = sectMeas2 -start->GetPosition();
pNetwork->GetAdjacentSectionsInfo ( startSectTID, true, adjSectionList);
for ( size_t i = 0; i < adjSectionList.size(); i++ )
{
DirectedSectionInfo actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != startSectTID )
{
if ( first )
{
first = false;
SectIDTree *startTree = new SectIDTree ( startSectTID,
( TupleId ) numeric_limits<long>::max(),
true,
numeric_limits<int>::max() );
visitedSect = startTree;
}
PQEntry *actEntry = new PQEntry ( actNextSect.GetSectionTid(), dist,
actNextSect.GetUpDownFlag(),
startSectTID,
actNextSect.GetMeas1(),
actNextSect.GetMeas2(),
actNextSect.GetRid() );
prioQ->Insert ( *actEntry, visitedSect );
delete actEntry;
}
}
adjSectionList.clear();
}
}
/*
Use priorityQueue to find shortestPath.
*/
PQEntry *actPQEntry;
bool found = false;
vector<PQEntry> candidate;
while ( !prioQ->IsEmpty() && !found )
{
actPQEntry = prioQ->GetAndDeleteMin ( visitedSect );
sectMeas1 = actPQEntry->meas1;
sectMeas2 = actPQEntry->meas2;
dist = actPQEntry->distFromStart + fabs ( sectMeas2 - sectMeas1 );
//////////////////////////////////////
/*if(junctionpoint){ //end point is a junction point
for(unsigned int i = 0;i < secjunid.size();i++){
if(secjunid[i] == actPQEntry->sectID){
lastSectTID = actPQEntry->sectID;
Tuple* sect = pNetwork->GetSection(lastSectTID);
double m1 =
((CcReal*)sect->GetAttribute(SECTION_MEAS1))->GetRealval();
double m2 =
((CcReal*)sect->GetAttribute(SECTION_MEAS2))->GetRealval();
if(actPQEntry->upDownFlag){
GPoint* temp = new GPoint(true,end->GetNetworkId(),
end->GetRouteId(),m2,None);
*end = *temp;
temp->DeleteIfAllowed();
}else{
GPoint* temp = new GPoint(true,end->GetNetworkId(),
end->GetRouteId(),m1,None);
*end = *temp;
temp->DeleteIfAllowed();
}
sect->DeleteIfAllowed();
break;
}
}
}*/
////////////////////////////////////
if ( actPQEntry->sectID != lastSectTID )
{
/*
Search further in the network unitl reached last section.
Get adjacent sections and insert into priority Queue.
*/
adjSectionList.clear();
pNetwork->GetAdjacentSectionsInfo ( actPQEntry->sectID,
actPQEntry->upDownFlag,
adjSectionList );
for ( size_t i = 0; i <adjSectionList.size();i++ )
{
DirectedSectionInfo actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != actPQEntry->sectID )
{
PQEntry *actEntry = new PQEntry ( actNextSect.GetSectionTid(),
dist,
actNextSect.GetUpDownFlag(),
actPQEntry->sectID,
actNextSect.GetMeas1(),
actNextSect.GetMeas2(),
actNextSect.GetRid() );
prioQ->Insert ( *actEntry, visitedSect );
delete actEntry;
}
}
delete actPQEntry;
actPQEntry=0;
}
else
{
/*
Shortest Path found.
Compute last route interval and resulting gline.
*/
//actually not really found
/*candidate.push_back(*actPQEntry);
while(!prioQ->IsEmpty()){
PQEntry* temp = prioQ->GetAndDeleteMin(visitedSect);
Tuple *act = pNetwork->GetSection(temp->sectID);
//double m1 =
// ((CcReal*) act->GetAttribute(SECTION_MEAS1))->GetRealval();
//double m2 =
// ((CcReal*) act->GetAttribute(SECTION_MEAS2))->GetRealval();
act->DeleteIfAllowed();
if(temp->distFromStart >=
(actPQEntry->distFromStart+fabs(sectMeas2-sectMeas1))){
temp->DeleteIfAllowed();
break;
}
if(junctionpoint){ //end point is a junction point
for(unsigned int i = 0;i < secjunid.size();i++){
if(secjunid[i] == temp->sectID){
Tuple* sect = pNetwork->GetSection(temp->sectID);
double m1 =
((CcReal*)sect->GetAttribute(SECTION_MEAS1))->GetRealval();
double m2 =
((CcReal*)sect->GetAttribute(SECTION_MEAS2))->GetRealval();
if(temp->distFromStart+m2-m1 >
actPQEntry->distFromStart+fabs(sectMeas2-sectMeas1)){
sect->DeleteIfAllowed();
continue;
}
lastSectTID = temp->sectID;
if(actPQEntry->upDownFlag){
GPoint* temp = new GPoint(true,end->GetNetworkId(),
end->GetRouteId(),m2,None);
*end = *temp;
temp->DeleteIfAllowed();
}else{
GPoint* temp = new GPoint(true,end->GetNetworkId(),
end->GetRouteId(),m1,None);
*end = *temp;
temp->DeleteIfAllowed();
}
sect->DeleteIfAllowed();
break;
}
}
}
if(temp->sectID == lastSectTID){
candidate.push_back(*temp);
}else{
adjSectionList.clear();
pNetwork->GetAdjacentSections(temp->sectID,
temp->upDownFlag,
adjSectionList);
Tuple *tempsec = pNetwork->GetSection(temp->sectID);
double meas1 =
((CcReal*) tempsec->GetAttribute(SECTION_MEAS1))->GetRealval();
double meas2 =
((CcReal*) tempsec->GetAttribute(SECTION_MEAS2))->GetRealval();
dist = temp->distFromStart + fabs(meas2 - meas1);
for (size_t i = 0; i <adjSectionList.size();i++){
DirectedSection actNextSect = adjSectionList[i];
if (actNextSect.GetSectionTid() != temp->sectID) {
PQEntry *actEntry = new PQEntry(actNextSect.GetSectionTid(),
dist,
actNextSect.GetUpDownFlag(),
temp->sectID);
prioQ->Insert(*actEntry, visitedSect);
delete actEntry;
}
}
tempsec->DeleteIfAllowed();
}
temp->DeleteIfAllowed();
}
//double length;
delete actPQEntry;
actSection->DeleteIfAllowed();
double tempdist = numeric_limits<double>::max();
actPQEntry = &candidate[0];
for(unsigned int i = 0; i < candidate.size();i++){
Tuple *sec = pNetwork->GetSection(candidate[i].sectID);
double m1 =
((CcReal*)sec->GetAttribute(SECTION_MEAS1))->GetRealval();
double m2 =
((CcReal*)sec->GetAttribute(SECTION_MEAS2))->GetRealval();
if(candidate[i].upDownFlag == true){//UP
double dist = candidate[i].distFromStart + m2-m1;
if(dist < tempdist){
actPQEntry = &candidate[i];
tempdist = dist;
}
}else{//DOWN
double dist = candidate[i].distFromStart + m2-m1;
if(dist < tempdist){
actPQEntry = &candidate[i];
tempdist = dist;
}
}
sec->DeleteIfAllowed();
}
actSection = pNetwork->GetSection(actPQEntry->sectID);
sectMeas1 =
((CcReal*) actSection->GetAttribute(SECTION_MEAS1))->GetRealval();
sectMeas2 =
((CcReal*) actSection->GetAttribute(SECTION_MEAS2))->GetRealval();*/
///////////////////////////////////////////////
found = true;
double startRI, endRI;
int actRouteId =actPQEntry->rid;
if ( actPQEntry->upDownFlag == true )
{
startRI = sectMeas1;
endRI = end->GetPosition();
}
else
{
startRI = sectMeas2;
endRI = end->GetPosition();
}
/*
Get the sections used for shortest path and write them in right
order (from start to end gpoint) in the resulting gline. Because
dijkstra gives
the sections from end to start we first have to put the result sections
on a
stack to turn in right order.
*/
RIStack *riStack = new RIStack ( actRouteId, startRI, endRI );
TupleId lastSectId = actPQEntry->sectID;
SectIDTree *pElem = visitedSect->Find ( actPQEntry->beforeSectID );
bool end = false;
bool upDown;
// if (startRI >= endRI) upDown = false;
if ( startRI > endRI || fabs ( startRI-endRI ) < 0.1 ) upDown = false;
else upDown = true;
while ( !end )
{
//GetSection
Tuple *actSection = pNetwork->GetSection ( pElem->sectID );
actRouteId =
( ( CcInt* ) actSection->GetAttribute ( SECTION_RID )
)->GetIntval();
sectMeas1 =
( ( CcReal* ) actSection->GetAttribute ( SECTION_MEAS1 )
)->GetRealval();
sectMeas2 =
( ( CcReal* ) actSection->GetAttribute ( SECTION_MEAS2 )
)->GetRealval();
upDown = pElem->upDownFlag;
if ( pElem->sectID != startSectTID )
{
if ( upDown )
riStack->Push ( actRouteId, sectMeas1, sectMeas2, riStack );
else
riStack->Push ( actRouteId, sectMeas2, sectMeas1, riStack );
lastSectId = pElem->sectID;
pElem = visitedSect->Find ( pElem->beforeSectId );
}
else
{
end = true;
pNetwork->GetAdjacentSectionsInfo (startSectTID, true,adjSectionList
);
size_t i = 0;
bool stsectfound = false;
while ( i < adjSectionList.size() && !stsectfound )
{
DirectedSectionInfo adjSection = adjSectionList[i];
if ( adjSection.GetSectionTid() == lastSectId )
{
if ( fabs ( start->GetPosition()-sectMeas2 ) > 0.1 )
{
stsectfound = true;
riStack->Push ( actRouteId, start->GetPosition(), sectMeas2,
riStack );
end = true;
}
}
i++;
}
adjSectionList.clear();
if ( !stsectfound )
{
pNetwork->GetAdjacentSectionsInfo ( startSectTID, false,
adjSectionList );
i = 0;
while ( i < adjSectionList.size() && !stsectfound )
{
DirectedSectionInfo adjSection = adjSectionList[i];
if ( adjSection.GetSectionTid() == lastSectId )
{
if ( fabs ( start->GetPosition()-sectMeas1 ) > 0.1 )
{
stsectfound = true;
riStack->Push ( actRouteId, start->GetPosition(), sectMeas1,
riStack );
end = true;
}
}
i++;
}
adjSectionList.clear();
}
}
if ( actSection )
{
actSection->DeleteIfAllowed();
actSection = 0;
}
}
// Cleanup and return result
riStack->StackToGLine ( result );
riStack->RemoveStack();
}
if ( actPQEntry )
{
delete actPQEntry;
actPQEntry = 0;
}
}
if ( visitedSect != 0 ) visitedSect->Remove();
prioQ->Destroy();
delete prioQ;
}
startSection->DeleteIfAllowed();
endSection->DeleteIfAllowed();
NetworkManager::CloseNetwork ( pNetwork );
result->SetSorted ( false );
result->SetDefined ( true );
result->TrimToSize();
start->DeleteIfAllowed();
end->DeleteIfAllowed();
return true;
};
/*
Method ~ShortestPathAStarPlus~
Computes the shortest path between start- and endpoint in the network. Using
AStar-algorithm. The path is returned as gline value.
*/
bool GPoint::ShortestPathAStarPlus(GPoint *pToGPoint,GLine *result,Word func){
bool withfunc = false;
Word funcResult;
ArgVectorPointer funargs;
if (func.addr != 0)
{
withfunc = true;
funargs = qp->Argument(func.addr);
}
//reset the result
result->Clear();
//******************************************************************
// Check the Inputs whether they exist and are defined
//1. generate the startpoint of the search, corresponds with the
// pToGPoint, because we want to have the right sequence at the end
GPoint *end = new GPoint(true, pToGPoint->GetNetworkId(),
pToGPoint->GetRouteId(), pToGPoint->GetPosition(),pToGPoint->GetSide());
//2. generate the endpoint of the search,
// corresponts with the startpoint of the path
GPoint *start =
new GPoint(true, GetNetworkId(), GetRouteId(), GetPosition(), GetSide());
//3. check whether both Points are not 0
if ( start == 0 || end == 0 || !start->IsDefined() ||
!end->IsDefined() )
{
sendMessage ( "Both gpoints must exist and be defined." );
result->SetDefined ( false );
start->DeleteIfAllowed();
end->DeleteIfAllowed();
return false;
}
//4. check whether both Points belong to the same network
if ( start->GetNetworkId() != end->GetNetworkId() )
{
sendMessage ( "Both gpoints belong to different networks." );
result->SetDefined ( false );
start->DeleteIfAllowed();
end->DeleteIfAllowed();
return false;
}
//*************************************************
// Get sections where the path should start or end
//1. get the netwwork and check whether its not null
Network* pNetwork =
NetworkManager::GetNetworkNew ( start->GetNetworkId(),netList );
if ( pNetwork == 0 )
{
sendMessage ( "Network not found." );
result->SetDefined ( false );
start->DeleteIfAllowed();
end->DeleteIfAllowed();
return false;
}
//2. set networkId to the result-gline
TupleId netId = start->GetNetworkId();
result->SetNetworkId ( start->GetNetworkId() );
//3. determin the startsection and check whether its not null
TupleId startSectTID = pNetwork->GetTupleIdSectionOnRoute(start);
Tuple* startSection = pNetwork->GetSection(startSectTID);
if ( startSection == 0 )
{
sendMessage ( "Starting GPoint not found in network." );
NetworkManager::CloseNetwork ( pNetwork );
result->SetDefined ( false );
start->DeleteIfAllowed();
end->DeleteIfAllowed();
return false;
}
//4. determin the endsection and check whether its not null
TupleId endSectTID = pNetwork->GetTupleIdSectionOnRoute(end);
Tuple* endSection = pNetwork->GetSection(endSectTID);
if ( endSection == 0 )
{
sendMessage ( "End GPoint not found in network." );
startSection->DeleteIfAllowed();
NetworkManager::CloseNetwork ( pNetwork );
result->SetDefined ( false );
start->DeleteIfAllowed();
end->DeleteIfAllowed();
return false;
}
//******************************************************************
// CAlCULATE THE SHORTEST PATH WITH A*
//1. check whether both Points on the same Route
// if true, then the path can be directly calculated
if ( startSectTID == endSectTID ||
start->GetRouteId() == end->GetRouteId())
{
result->AddRouteInterval ( start->GetRouteId(), start->GetPosition(),
end->GetPosition());
}
// else calculate the shortespath with the A* algorithem
else{
//1. Generate the openlist,which save all known Points on the searchpath
// with the costs and a pointer to its predecessor used a PrioQueue
PrioQueue *openList = new PrioQueue(0);
//2. Generate the ClosedList, which save alle Points with the sid
// to which the shortest path is known
SectIDTree *closeList = 0;
//3. other variables, they are needed
double dist = 0.0; //distance
double totalcost =0.0; //totalcost of the section
double heuristic = 0.0; //heuristical part of the totalcost
vector<DirectedSectionInfo> adjSectionList;
adjSectionList.clear();
//4. Initialized the OpenList
//Determin the Side of the section, where the point is located
//DEBUG cout << start->GetSide()<<endl;
if(start->GetSide() == 0) // Down-Side of the section
{
//4a. Calculate the distance
double sectMeas1 =
((CcReal*)startSection->GetAttribute(SECTION_MEAS1))->GetRealval();
dist = start->GetPosition() - sectMeas1;
//4b. get the adjacent sections
pNetwork->GetAdjacentSectionsInfo(startSectTID,false,adjSectionList);
//4c. get startsection and put it in the closelist
SectIDTree *startTree = new SectIDTree ( startSectTID,
( TupleId ) numeric_limits<long>::max(),
false, numeric_limits<int>::max() );
closeList = startTree;
//4d. put all adjacent sections in the openlist
for ( size_t i = 0; i < adjSectionList.size(); i++ )
{
DirectedSectionInfo actNextSect = adjSectionList[i];
if (actNextSect.GetSectionTid() != startSectTID)
{
//calculate the totalcost
GPoint *sectEP =
new GPoint(true,netId,
actNextSect.GetRid(),actNextSect.GetMeas1());
heuristic = sectEP->Distance(end);
if(withfunc)
{ //funcargs[0]=cost,funcargs[1]=duration,funcargs[2]=laenge
(*funargs)[0] =new CcReal(true,actNextSect.GetCost());
(*funargs)[1] =new CcReal(true,actNextSect.GetDuration());
(*funargs)[2] =new CcReal(true,actNextSect.GetLength());
qp->Request(func.addr, funcResult);
double fr= ((CcReal*)(funcResult.addr))->GetRealval();
totalcost = fr + heuristic;
//DEBUG cout << "ERGEBNIS:" <<totalcost<<endl;
}
else
{
totalcost = actNextSect.GetCost() + heuristic;
}
//DEBUG
//cout << "section: "<< actNextSect.GetSectionTid()<<"."
// << actNextSect.GetUpDownFlag() << " heuristic: "
// << heuristic<< "+ kosten: "<< actNextSect.GetCost()
// <<"=totalcost: "<< totalcost <<endl;
sectEP->DeleteIfAllowed();
PQEntry *actEntry = new PQEntry(
actNextSect.GetSectionTid(),
dist,
actNextSect.GetUpDownFlag(),
startSectTID,
actNextSect.GetMeas1(),
actNextSect.GetMeas2(),
actNextSect.GetRid(),
totalcost);
openList->Insert (*actEntry, closeList,true);
delete actEntry;
}
}
adjSectionList.clear();
}//END IF (DownSide)
else if(start->GetSide() == 1) //Up-Side of the section
{
//4a. Calculate the distance
double sectMeas2 =
((CcReal*)startSection->GetAttribute(SECTION_MEAS2))->GetRealval();
dist = sectMeas2 - start->GetPosition();
//4b. get the adjacent sections
pNetwork->GetAdjacentSectionsInfo(startSectTID,true,adjSectionList);
//4c. get startsection and put it in the closelist
SectIDTree *startTree = new SectIDTree ( startSectTID,
(TupleId) numeric_limits<long>::max(),
true, numeric_limits<int>::max() );
closeList = startTree;
//4d. put all adjacent sections in the openlist
for ( size_t i = 0; i < adjSectionList.size(); i++ )
{
DirectedSectionInfo actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != startSectTID )
{
//calculate the totalcost
GPoint *sectEP =
new GPoint(true,netId, actNextSect.GetRid(),
actNextSect.GetMeas2());
heuristic = sectEP->Distance(end);
if(withfunc)
{ //funcargs[0]=cost,funcargs[1]=duration,funcargs[2]=laenge
(*funargs)[0] =new CcReal(true,actNextSect.GetCost());
(*funargs)[1] =new CcReal(true,actNextSect.GetDuration());
(*funargs)[2] =new CcReal(true,actNextSect.GetLength());
qp->Request(func.addr, funcResult);
double fr= ((CcReal*)(funcResult.addr))->GetRealval();
totalcost = fr + heuristic;
//DEBUG cout << "ERGEBNIS:" <<totalcost<<endl;
}
else
{
totalcost = actNextSect.GetCost() + heuristic;
}
sectEP->DeleteIfAllowed();
//DEBUG
//cout << "section: "<< actNextSect.GetSectionTid()<<"."
// << actNextSect.GetUpDownFlag() << " heuristic: "
// << heuristic << "+ kosten: " << actNextSect.GetCost()
// <<"=totalcost: "<< totalcost <<endl;
PQEntry *actEntry = new PQEntry (
actNextSect.GetSectionTid(),
dist,
actNextSect.GetUpDownFlag(),
startSectTID,
actNextSect.GetMeas1(),
actNextSect.GetMeas2(),
actNextSect.GetRid(),
totalcost);
openList->Insert ( *actEntry, closeList, true );
delete actEntry;
}
}
adjSectionList.clear();
}//END ELSE IF (UpSide)
else // NONE, not defined both ways must be calculate
{
bool first = true;
//Entries for the DownSide
//4a. Calculate the totalcost
double sectMeas1 =
((CcReal*)startSection->GetAttribute(SECTION_MEAS1))->GetRealval();
dist = start->GetPosition() - sectMeas1;
//4b. get the adjacent sections
pNetwork->GetAdjacentSectionsInfo(startSectTID,false,adjSectionList);
//4c. put all adjacent sections in the openlist
for ( size_t i = 0; i < adjSectionList.size(); i++ )
{
DirectedSectionInfo actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != startSectTID )
{
if ( first )
{ //4d. get startsection and put it in the closelist
first = false;
SectIDTree *startTree = new SectIDTree ( startSectTID,
( TupleId ) numeric_limits<long>::max(),
false, numeric_limits<int>::max() );
closeList = startTree;
}
//calculate the totalcost
GPoint *sectEP =
new GPoint(true,netId, actNextSect.GetRid(),
actNextSect.GetMeas1());
heuristic = sectEP->Distance(end);
if(withfunc)
{ //funcargs[0]=cost,funcargs[1]=duration,funcargs[2]=laenge
(*funargs)[0] =new CcReal(true,actNextSect.GetCost());
(*funargs)[1] =new CcReal(true,actNextSect.GetDuration());
(*funargs)[2] = new CcReal(true,actNextSect.GetLength());
qp->Request(func.addr, funcResult);
double fr= ((CcReal*)(funcResult.addr))->GetRealval();
totalcost = fr + heuristic;
//DEBUG cout << "ERGEBNIS:" <<totalcost<<endl;
}
else
{
totalcost = actNextSect.GetCost() + heuristic;
}
sectEP->DeleteIfAllowed();
//DEBUG
//cout << "section: "<< actNextSect.GetSectionTid()<<"."
// << actNextSect.GetUpDownFlag() << " heuristic: "
// << heuristic << "+ kosten: " << actNextSect.GetCost()
// <<"=totalcost: "<< totalcost <<endl;
PQEntry *actEntry = new PQEntry (
actNextSect.GetSectionTid(),
dist,
actNextSect.GetUpDownFlag(),
startSectTID,
actNextSect.GetMeas1(),
actNextSect.GetMeas2(),
actNextSect.GetRid(),
totalcost );
openList->Insert ( *actEntry, closeList, true );
delete actEntry;
}
}
adjSectionList.clear();
//Entries for the UpSide
//4a. Calculate the distance
double sectMeas2 =
((CcReal*)startSection->GetAttribute(SECTION_MEAS2))->GetRealval();
dist = sectMeas2 - start->GetPosition();
//4b. get the adjacent sections
pNetwork->GetAdjacentSectionsInfo(startSectTID,true,adjSectionList);
//4c. put all adjacent sections in the openlist
for ( size_t i = 0; i < adjSectionList.size(); i++ )
{
DirectedSectionInfo actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != startSectTID )
{
if ( first )
{
//4d. get startsection and put it in the closelist
first = false;
SectIDTree *startTree = new SectIDTree ( startSectTID,
( TupleId ) numeric_limits<long>::max(),
true, numeric_limits<int>::max() );
closeList = startTree;
}
//calculate the totalcost
GPoint *sectEP =
new GPoint(true,netId, actNextSect.GetRid(),
actNextSect.GetMeas2());
heuristic = sectEP->Distance(end);
if(withfunc)
{ //funcargs[0]=cost,funcargs[1]=duration,funcargs[2]=laenge
(*funargs)[0] =new CcReal(true,actNextSect.GetCost());
(*funargs)[1] =new CcReal(true,actNextSect.GetDuration());
(*funargs)[2] =new CcReal(true,actNextSect.GetLength());
qp->Request(func.addr, funcResult);
double fr= ((CcReal*)(funcResult.addr))->GetRealval();
totalcost = fr + heuristic;
//DEBUG cout << "ERGEBNIS:" <<totalcost<<endl;
}
else
{
totalcost = actNextSect.GetCost() + heuristic;
}
sectEP->DeleteIfAllowed();
//DEBUG
//cout << "section: "<< actNextSect.GetSectionTid()<<"."
// << actNextSect.GetUpDownFlag() << " heuristic: "
// << heuristic << "+ kosten: " << actNextSect.GetCost()
// <<"=totalcost: "<< totalcost <<endl;
PQEntry *actEntry = new PQEntry (
actNextSect.GetSectionTid(),
dist,
actNextSect.GetUpDownFlag(),
startSectTID,
actNextSect.GetMeas1(),
actNextSect.GetMeas2(),
actNextSect.GetRid(),
totalcost );
openList->Insert ( *actEntry, closeList, true );
delete actEntry;
}
}
adjSectionList.clear();
}//END ELSE (BothSide)
//5. Use openList to find shortestPath.
PQEntry *actPQEntry;
bool found = false;
vector<PQEntry> candidate;
while ( !openList->IsEmpty() && !found )
{
//5a get the minimum of the openList
actPQEntry = openList->GetAndDeleteMin ( closeList, true );
//5b calculate the totalcost of this element
double sectMeas1 = actPQEntry->meas1;
double sectMeas2 = actPQEntry->meas2;
dist = actPQEntry->distFromStart + fabs ( sectMeas2 - sectMeas1 );
if ( actPQEntry->sectID != endSectTID )
{
// Search further in the network unitl reached last section.
// Get adjacent sections and insert into priority Queue.
adjSectionList.clear();
//5c get adjacent section of the actual element
pNetwork->GetAdjacentSectionsInfo ( actPQEntry->sectID,
actPQEntry->upDownFlag,
adjSectionList );
for ( size_t i = 0; i <adjSectionList.size();i++ )
{
DirectedSectionInfo actNextSect = adjSectionList[i];
if ( actNextSect.GetSectionTid() != actPQEntry->sectID )
{
//calculate the totalcost
GPoint *sectEP;
if(actPQEntry->upDownFlag)
sectEP = new GPoint(true,netId,
actNextSect.GetRid(), actNextSect.GetMeas2());
else
sectEP = new GPoint(true,netId,
actNextSect.GetRid(), actNextSect.GetMeas1());
heuristic = sectEP->Distance(end);
if(withfunc)
{//fcargs[0]=cost,fcargs[1]=duration,fcargs[2]=laenge
(*funargs)[0]=
new CcReal(true,actNextSect.GetCost());
(*funargs)[1]=
new CcReal(true,actNextSect.GetDuration());
(*funargs)[2] =
new CcReal(true,actNextSect.GetLength());
qp->Request(func.addr, funcResult);
double fr=
((CcReal*)(funcResult.addr))->GetRealval();
totalcost = fr + heuristic;
//DEBUG cout << "ERGEBNIS:" <<totalcost<<endl;
}
else
{
totalcost = actNextSect.GetCost() + heuristic;
}
sectEP->DeleteIfAllowed();
//DEBUG
//cout << "section: "<< actNextSect.GetSectionTid()
// <<"."<< actNextSect.GetUpDownFlag()
// << " heuristic: "<< heuristic<<"+ vorkosten "
// << actPQEntry->costFromStart << "+ kosten: "
// << actNextSect.GetCost() <<"=totalcost: "
// << totalcost <<endl;
PQEntry *actEntry = new PQEntry (
actNextSect.GetSectionTid(),
dist,
actNextSect.GetUpDownFlag(),
actPQEntry->sectID,
actNextSect.GetMeas1(),
actNextSect.GetMeas2(),
actNextSect.GetRid(),
totalcost );
openList->Insert ( *actEntry, closeList, true );
delete actEntry;
}
}
delete actPQEntry;
actPQEntry=0;
}//END IF the end is not reached
else //shortespath has been found
{ //Compute last route interval and resulting gline.
found = true;
double startRI, endRI;
int actRouteId =actPQEntry->rid;
if ( actPQEntry->upDownFlag == true )
{
startRI = sectMeas1;
endRI = end->GetPosition();
}
else
{
startRI = sectMeas2;
endRI = end->GetPosition();
}
//6. Get the sections used for shortest path and write them in
// right order (from start to end gpoint) in the resulting
// gline. Because Astar gives the sections from end to start
// we first have to put the result sections on a stack to turn
// in right order.
RIStack *riStack = new RIStack ( actRouteId, startRI, endRI );
TupleId endSectId = actPQEntry->sectID;
SectIDTree *pElem = closeList->Find ( actPQEntry->beforeSectID);
bool end = false;
bool upDown;
if ( startRI > endRI
|| fabs ( startRI-endRI ) < 0.1 ) upDown = false;
else upDown = true;
while ( !end )
{
//GetSection
Tuple *actSection = pNetwork->GetSection ( pElem->sectID );
actRouteId =
((CcInt*)actSection->GetAttribute(SECTION_RID))->GetIntval();
sectMeas1 =
((CcReal*)actSection->GetAttribute(SECTION_MEAS1))
->GetRealval();
sectMeas2 =
(( CcReal*)actSection->GetAttribute(SECTION_MEAS2))
->GetRealval();
upDown = pElem->upDownFlag;
if ( pElem->sectID != startSectTID )
{
if ( upDown )
riStack->Push(actRouteId,sectMeas1,sectMeas2,riStack);
else
riStack->Push(actRouteId,sectMeas2,sectMeas1,riStack);
endSectId = pElem->sectID;
pElem = closeList->Find ( pElem->beforeSectId );
}
else
{
end = true;
pNetwork->GetAdjacentSectionsInfo(
startSectTID,true, adjSectionList);
size_t i = 0;
bool stsectfound = false;
while ( i < adjSectionList.size() && !stsectfound )
{
DirectedSectionInfo adjSection = adjSectionList[i];
if ( adjSection.GetSectionTid() == endSectId )
{
if (fabs(start->GetPosition()-sectMeas2 ) > 0.1)
{
stsectfound = true;
riStack->Push(
actRouteId,start->GetPosition(),
sectMeas2,riStack );
end = true;
}
}
i++;
}
adjSectionList.clear();
if ( !stsectfound )
{
pNetwork->
GetAdjacentSectionsInfo(
startSectTID,false,adjSectionList);
i = 0;
while ( i < adjSectionList.size() && !stsectfound )
{
DirectedSectionInfo adjSection = adjSectionList[i];
if ( adjSection.GetSectionTid() == endSectId )
{
if (fabs(start->GetPosition()-sectMeas1) > 0.1)
{
stsectfound = true;
riStack->Push (
actRouteId, start->GetPosition(),
sectMeas1,riStack );
end = true;
}
}
i++;
}
adjSectionList.clear();
}
}
if ( actSection )
{
actSection->DeleteIfAllowed();
actSection = 0;
}
}
// Cleanup and return result
riStack->StackToGLine ( result );
riStack->RemoveStack();
}
if ( actPQEntry )
{
delete actPQEntry;
actPQEntry = 0;
}
}// END ELSE shortesPath has been found
//clean up
if ( closeList != 0 ) closeList->Remove();
openList->Destroy();
delete openList;
}//END ELSE Calculate the shortes path with A*
//clean up
endSection->DeleteIfAllowed();
startSection->DeleteIfAllowed();
NetworkManager::CloseNetwork ( pNetwork );
result->SetSorted ( false );
result->SetDefined ( true );
result->TrimToSize();
start->DeleteIfAllowed();
end->DeleteIfAllowed();
return true;
}
/*
Returns the x,y point represented by gpoint.
*/
void GPoint::ToPoint ( Point *&res )
{
//Network *pNetwork = NetworkManager::GetNetwork(GetNetworkId());
Network* pNetwork = NetworkManager::GetNetworkNew ( GetNetworkId(), netList );
if ( pNetwork != 0 )
{
pNetwork->GetPointOnRoute ( this, res );
}
else
{
res->SetDefined ( false );
}
NetworkManager::CloseNetwork ( pNetwork );
};
Point* GPoint::ToPoint() const
{
Point *res = new Point ( false );
//Network *pNetwork = NetworkManager::GetNetwork(GetNetworkId());
Network* pNetwork = NetworkManager::GetNetworkNew ( GetNetworkId(), netList );
if ( pNetwork != 0 ) pNetwork->GetPointOnRoute ( this, res );
NetworkManager::CloseNetwork ( pNetwork );
return res;
};
Point* GPoint::ToPoint ( Network*& pNetwork ) const
{
Point *res = new Point ( false );
if ( pNetwork != 0 ) pNetwork->GetPointOnRoute ( this, res );
return res;
};
/*
Returns the bounding GPoints of the given GLine.
*/
GPoints* GLine::GetBGP ()
{
GPoints *result = new GPoints ( 0 );
if ( !IsDefined() || NoOfComponents() == 0 ) return result;
else
{
SectTree *sectionTree = 0;
RouteInterval ri;
DbArray<SectTreeEntry> *actSections = new DbArray<SectTreeEntry> ( 0 );
//Network *pNetwork = NetworkManager::GetNetwork(GetNetworkId());
Network* pNetwork = NetworkManager::GetNetworkNew ( GetNetworkId(), netList
);
bool first = true;
SectTreeEntry nEntry;
for ( int i = 0; i < Size(); i++ )
{
Get ( i,ri );
pNetwork->GetSectionsOfRouteInterval ( &ri, actSections );
for ( int j = 0; j < actSections->Size(); j++ )
{
actSections->Get ( j, nEntry );
if ( first )
{
first = false;
sectionTree = new SectTree ( &nEntry );
}
else
{
sectionTree->Insert ( &nEntry );
}
}
actSections->clean();
}
delete actSections;
sectionTree->WriteResult ( pNetwork, *result, *sectionTree );
sectionTree->Remove();
NetworkManager::CloseNetwork ( pNetwork );
result->TrimToSize();
return result;
}
};
/*
Secondo Type Constructor for class ~GPoint~
*/
TypeConstructor gpoint (
"gpoint", //name
GPoint::GPointProperty, //property function
GPoint::OutGPoint, GPoint::InGPoint, //Out and In functions
0, 0, //SaveToList and
//RestoreFromList functions
GPoint::CreateGPoint, GPoint::DeleteGPoint, //object creation/deletion
OpenAttribute<GPoint>,SaveAttribute<GPoint>,//open and save functions
GPoint::CloseGPoint, GPoint::CloneGPoint, //object close, and clone
GPoint::CastGPoint, //cast function
GPoint::SizeOfGPoint, //sizeof function
GPoint::CheckGPoint ); //kind checking function
/*
3.4 Class GPoints implemented by Jianqiu Xu
*/
string edistjoinpointlist = "(rel(tuple((pid int)(p point))))";
enum edistjoinpointlistrelation {POINTSID = 0,POINTSOBJECT};
/*
3.4.1 Constructors
*/
GPoints::GPoints():Attribute()
{}
GPoints::GPoints ( int in_iSize ) :Attribute(true),m_xGPoints ( in_iSize )
{}
GPoints::GPoints ( GPoints* in_xOther ) :
Attribute(in_xOther->IsDefined()),
m_xGPoints ( 0 )
{
GPoint pCurrentInterval;
for ( int i = 0; i < in_xOther->m_xGPoints.Size(); i++ )
{
// Get next Interval
in_xOther->m_xGPoints.Get ( i, pCurrentInterval );
m_xGPoints.Append ( pCurrentInterval );
}
SetDefined(in_xOther->IsDefined());
TrimToSize();
}
/*
3.4.2 Methods of class ~GPoints~
*/
bool GPoints::IsEmpty() const
{
return m_xGPoints.Size() == 0;
}
ostream& GPoints::Print ( ostream& os ) const
{
for ( int i = 0;i < m_xGPoints.Size();i++ )
{
GPoint pGP;
m_xGPoints.Get ( i,pGP );
os<<"GPoint:"<<i<<" rid "<<pGP.GetRouteId();
os<<" Position "<<pGP.GetPosition();
os<<" Side "<< ( int ) pGP.GetSide() <<endl;
}
return os;
}
GPoints& GPoints::operator= ( const GPoints& gps )
{
m_xGPoints.copyFrom(gps.m_xGPoints);
TrimToSize();
return *this;
}
int GPoints::NumOfFLOBs() const
{
return 1;
}
Flob* GPoints::GetFLOB ( const int i )
{
assert ( i >= 0 && i < NumOfFLOBs() );
return &m_xGPoints;
}
size_t GPoints::Sizeof() const
{
return sizeof ( *this );
}
int GPoints::SizeOf()
{
return sizeof ( GPoints );
}
int GPoints::Size() const
{
return m_xGPoints.Size();
}
GPoints& GPoints::operator+= ( const GPoint& gp )
{
m_xGPoints.Append ( gp );
TrimToSize();
return *this;
}
GPoints& GPoints::operator-= ( const GPoint& gp )
{
GPoints *nGPs = new GPoints ( 0 );
GPoint actGP;
for ( int i = 0; i < m_xGPoints.Size(); i++ )
{
m_xGPoints.Get ( i, actGP );
if ( gp != actGP ) nGPs->m_xGPoints.Append ( actGP );
}
nGPs->TrimToSize();
return *nGPs;
}
void GPoints::Get ( int i, GPoint& pgp ) const
{
assert ( i >= 0 && i < m_xGPoints.Size() );
m_xGPoints.Get ( i,pgp );
}
ListExpr GPoints:: Property()
{
return ( nl->TwoElemList (
nl->FourElemList ( nl->StringAtom ( "Signature" ),
nl->StringAtom ( "Example Type List" ),
nl->StringAtom ( "List Rep" ),
nl->StringAtom ( "Example List" ) ),
nl->FourElemList ( nl->StringAtom ( "-> DATA" ),
nl->StringAtom ( "gpoints" ),
nl->StringAtom (
"(<gpoint1><gpoint2>...<gpointN>))" ),
nl->StringAtom ( "((1 2.0 0)(2 3.0 0))" ) ) )
);
}
ListExpr GPoints::Out ( ListExpr in_xTypeInfo,
Word in_xValue )
{
GPoints *pGPS = ( GPoints* ) in_xValue.addr;
if ( pGPS->IsEmpty() )
{
return nl->TheEmptyList();
}
GPoint pgp;
pGPS->Get ( 0,pgp );
ListExpr result =
nl->OneElemList ( GPoint::OutGPoint ( nl->TheEmptyList(),SetWord ( ( void*
) &pgp ) ) );
ListExpr last = result;
for ( int i = 1; i < pGPS->Size();i++ )
{
pGPS->Get ( i,pgp );
last =
nl->Append ( last,GPoint::OutGPoint ( nl->TheEmptyList(),
SetWord ( ( void* ) &pgp ) ) );
}
return result;
}
Word GPoints::In ( const ListExpr typeInfo, const ListExpr instance,
const int errorPos, ListExpr& errorInfo, bool& correct )
{
if ( nl->ListLength ( instance ) == 0 )
{
correct = false;
cmsg.inFunError ( "Empty List" );
return SetWord ( Address ( 0 ) );
}
GPoints* pGPS = new GPoints ( nl->ListLength ( instance ) );
ListExpr rest = instance;
while ( !nl->IsEmpty ( rest ) )
{
ListExpr first = nl->First ( rest );
rest = nl->Rest ( rest );
if ( nl->ListLength ( first ) != 4 )
{
correct = false;
cmsg.inFunError ( "GPoint incorrect.Expected list of 4 Elements." );
return SetWord ( Address ( 0 ) );
}
GPoint* pgp =
( GPoint* ) GPoint::InGPoint (
nl->TheEmptyList(),first,0,errorInfo,correct ).addr;
if ( correct )
{
( *pGPS ) += ( *pgp );
pgp->DeleteIfAllowed();
}
else
{
pgp->DeleteIfAllowed();
return SetWord ( Address ( 0 ) );
}
}
correct = true;
pGPS->SetDefined ( true );
pGPS->TrimToSize();
return SetWord ( pGPS );
}
bool GPoints::OpenGPoints ( SmiRecord& valueRecord,size_t& offset,
const ListExpr typeInfo, Word& value )
{
GPoints* pGPS = ( GPoints* ) Attribute::Open ( valueRecord,offset,typeInfo );
value = SetWord ( pGPS );
pGPS->TrimToSize();
return true;
}
bool GPoints::SaveGPoints ( SmiRecord& valueRecord,size_t& offset,
const ListExpr typeInfo, Word& value )
{
GPoints* pGPS = ( GPoints* ) value.addr;
Attribute::Save ( valueRecord,offset,typeInfo,pGPS );
return true;
}
Word GPoints::Create ( const ListExpr typeInfo )
{
return SetWord ( new GPoints ( 0 ) );
}
void GPoints::Delete ( const ListExpr typeInfo,
Word& w )
{
GPoints *gp = ( GPoints * ) w.addr;
// if (l->del.refs == 1) { l->m_xRouteIntervals.Destroy();}
if ( gp->DeleteIfAllowed() == true )
w.addr = 0;
}
void GPoints::Close ( const ListExpr typeInfo,
Word& w )
{
if ( ( ( GPoints* ) w.addr )->DeleteIfAllowed() == true )
w.addr = 0;
}
Word GPoints::CloneGPoints ( const ListExpr typeInfo,
const Word& w )
{
return SetWord ( new GPoints ( * ( ( GPoints* ) w.addr ) ) );
}
void* GPoints::Cast ( void* addr )
{
return new ( addr ) GPoints();
}
bool GPoints::Check ( ListExpr type, ListExpr& errorInfo )
{
return ( nl->IsEqual ( type, "gpoints" ) );
}
int GPoints::Compare ( const Attribute* ) const
{
return false;
}
bool GPoints::Adjacent ( const Attribute* ) const
{
return false;
}
GPoints* GPoints::Clone() const
{
GPoints* res = new GPoints ( *this );
return res;
}
size_t GPoints::HashValue() const
{
size_t xHash = 0;
// Iterate over all GPoint objects
for ( int i = 0; i < m_xGPoints.Size(); ++i )
{
// Get next Interval
GPoint pCurrentInterval;
m_xGPoints.Get ( i, pCurrentInterval );
// Add something for each entry
int iNetworkId = pCurrentInterval.GetNetworkId();
int iRouteId = pCurrentInterval.GetRouteId();
double iPosition = pCurrentInterval.GetPosition();
int iSide = ( int ) pCurrentInterval.GetSide();
xHash += iNetworkId + iRouteId + ( size_t ) iPosition + iSide;
}
return xHash;
}
void GPoints::CopyFrom ( const Attribute* right )
{
*this = * ( ( const GPoints * ) right );
}
TypeConstructor gpoints ( "gpoints",
GPoints::Property,
GPoints::Out, GPoints::In,
0, 0,
GPoints::Create, GPoints::Delete,
GPoints::OpenGPoints, GPoints::SaveGPoints,
GPoints::Close, GPoints::CloneGPoints,
GPoints::Cast, GPoints::SizeOf,
GPoints::Check );
/*
4 Secondo Operators
4.1 Operator ~netdistance~
Returns the network distance between two ~Gpoints~ or two ~GLines~. Using
Dijkstras Algorithm for computation of the shortest paths.
*/
ListExpr OpNetNetdistanceTypeMap ( ListExpr args )
{
if ( nl->ListLength ( args ) != 2 )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr param1 = nl->First ( args );
ListExpr param2 = nl->Second ( args );
//ListExpr param3 = nl->Third(args);
if ( ( nl->IsAtom ( param1 ) && nl->AtomType ( param1 ) == SymbolType &&
nl->IsAtom ( param2 ) && nl->AtomType ( param2 ) == SymbolType &&
( ( nl->SymbolValue ( param1 ) == "gpoint" &&
nl->SymbolValue ( param2 ) == "gpoint" ) ||
( nl->SymbolValue ( param1 ) == "gline" &&
nl->SymbolValue ( param2 ) == "gline" ) ) ) )
{
return nl->SymbolAtom ( CcReal::BasicType() );
}
return nl->SymbolAtom ( Symbol::TYPEERROR() );
}
int OpNetNetdistance_gpgp ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
GPoint* pFromGPoint = ( GPoint* ) args[0].addr;
GPoint* pToGPoint = ( GPoint* ) args[1].addr;
result = qp->ResultStorage ( in_pSupplier );
CcReal* pResult = ( CcReal* ) result.addr;
if ( ! ( pFromGPoint->IsDefined() ) || ! ( pToGPoint->IsDefined() ) )
{
cmsg.inFunError ( "Both gpoint must be defined!" );
return 0;
};
double dist = pFromGPoint->Netdistance ( pToGPoint );
if ( dist != numeric_limits<double>::max() ) pResult->Set ( true,dist );
else pResult->Set ( false, dist );
return 1;
};
int OpNetNetdistance_glgl ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
GLine* pGLine1 = ( GLine* ) args[0].addr;
GLine* pGLine2 = ( GLine* ) args[1].addr;
CcReal* pResult = ( CcReal* ) qp->ResultStorage ( in_pSupplier ).addr;
result = SetWord ( pResult );
if ( ! ( pGLine1->IsDefined() ) || ! ( pGLine2->IsDefined() ) )
{
cmsg.inFunError ( "Both gpoint must be defined!" );
return 0;
};
double dist = pGLine1->Netdistance ( pGLine2 );
if ( dist != numeric_limits<double>::max() ) pResult->Set ( true, dist );
else pResult->Set ( false, dist );
return 1;
};
ValueMapping OpNetNetdistancemap[] =
{
OpNetNetdistance_gpgp,
OpNetNetdistance_glgl
};
int OpNetNetdistanceselect ( ListExpr args )
{
ListExpr arg1 = nl->First ( args );
ListExpr arg2 = nl->Second ( args );
if ( nl->SymbolValue ( arg1 ) == "gpoint" &&
nl->SymbolValue ( arg2 ) == "gpoint" )
return 0;
if ( nl->SymbolValue ( arg1 ) == "gline" &&
nl->SymbolValue ( arg2 ) == "gline" )
return 1;
return -1; // This point should never be reached
};
const string OpNetNetdistanceSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>A x A x network-> real with A = gpoint or gline" "</text--->"
"<text>netdistance(GPOINT1,GPOINT2, NETWORK)</text--->"
"<text>Calculates the network distance of two gpoints resp. glines.</text--->"
"<text>query netdistance(gp1,gp2, B_NETWORK)</text--->"
") )";
Operator networknetdistance (
"netdistance", // name
OpNetNetdistanceSpec, // specification
2,
OpNetNetdistancemap, // value mapping
OpNetNetdistanceselect, // selection function
OpNetNetdistanceTypeMap // type mapping
);
/*
4.2 Operator ~gpoint2rect~
Returns a rectangle degenerated to a point with coordinates rid, rid, pos, pos.
*/
ListExpr OpGPoint2RectTypeMap ( ListExpr in_xArgs )
{
if ( nl->ListLength ( in_xArgs ) != 1 )
{
sendMessage ( "Expects a list of length 1." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr xsource = nl->First ( in_xArgs );
if ( ( !nl->IsAtom ( xsource ) ) ||
!nl->IsEqual ( xsource, "gpoint" ) )
{
sendMessage ( "Element must be of type gpoint." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
return ( nl->SymbolAtom ( Rectangle<2>::BasicType() ) );
}
int OpGPoint2RectValueMapping ( Word* args,
Word& result,
int message,
Word& local,
Supplier in_xSupplier )
{
result = qp->ResultStorage ( in_xSupplier );
Rectangle<2>* box = static_cast<Rectangle<2>* > ( result.addr );
GPoint* arg = static_cast<GPoint*> ( args[0].addr );
if ( !arg->IsDefined() )
{
box->SetDefined ( false );
}
else
{
( *box ) = arg->NetBoundingBox();
}
return 0;
} //end ValueMapping
const string OpGPoint2RectSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>gpoint -> rect" "</text--->"
"<text>gpoint2rect(GPOINT)</text--->"
"<text>Returns a rectangle representing the gpoint.</text--->"
"<text> gpoint2rect (gpoint) </text--->"
") )";
Operator networkgpoint2rect (
"gpoint2rect", // name
OpGPoint2RectSpec, // specification
OpGPoint2RectValueMapping, // value mapping
Operator::SimpleSelect, // selection function
OpGPoint2RectTypeMap // type mapping
);
/*
4.3 Operator ~inside~
Returns true if ths ~GPoint~ is inside the ~GLine~ false elsewhere.
*/
ListExpr OpInsideTypeMap ( ListExpr args )
{
if ( nl->ListLength ( args ) != 2 )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr gpoint = nl->First ( args );
ListExpr gline = nl->Second ( args );
if ( !nl->IsAtom ( gpoint ) || nl->AtomType ( gpoint ) != SymbolType ||
nl->SymbolValue ( gpoint ) != "gpoint" || !nl->IsAtom ( gline ) ||
nl->AtomType ( gline ) != SymbolType || nl->SymbolValue ( gline ) !=
"gline" )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
return nl->SymbolAtom ( CcBool::BasicType() );
}
int OpInsideValueMap ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
GPoint* pGPoint = ( GPoint* ) args[0].addr;
GLine* pGLine = ( GLine* ) args[1].addr;
result = qp->ResultStorage ( in_pSupplier );
CcBool* pResult = ( CcBool* ) result.addr;
if ( pGPoint->GetNetworkId() != pGLine->GetNetworkId() ||
!pGLine->IsDefined() || !pGPoint->IsDefined() )
{
pResult->Set ( false, false );
}
pResult->Set ( true, pGPoint->Inside ( pGLine ) );
return 0;
}
const string OpInsideSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>gpoint x gline -> bool" "</text--->"
"<text> _ inside _</text--->"
"<text>Returns true if gpoint is inside gline false elsewhere.</text--->"
"<text>GPOINT inside GLINE</text--->"
") )";
Operator networkinside (
"inside", // name
OpInsideSpec, // specification
OpInsideValueMap, // value mapping
Operator::SimpleSelect, // selection function
OpInsideTypeMap // type mapping
);
/*
4.4 Operator ~length~
Returns the length of a ~GLine~.
*/
ListExpr OpLengthTypeMap ( ListExpr args )
{
if ( nl->ListLength ( args ) != 1 )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr gline = nl->First ( args );
if ( !nl->IsAtom ( gline ) || nl->AtomType ( gline ) != SymbolType ||
nl->SymbolValue ( gline ) != "gline" )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
return nl->SymbolAtom ( CcReal::BasicType() );
}
int OpLengthValueMap ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
GLine* pGline = ( GLine* ) args[0].addr;
result = qp->ResultStorage ( in_pSupplier );
CcReal* pResult = ( CcReal* ) result.addr;
if ( ! ( pGline->IsDefined() ) )
{
cmsg.inFunError ( "gline is not defined!" );
return 0;
};
pResult-> Set ( true, pGline->GetLength() );
return 1;
}
const string OpLengthSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>gline -> real" "</text--->"
"<text>length(_)</text--->"
"<text>Calculates the length of the gline.</text--->"
"<text>query length(gline)</text--->"
") )";
Operator networklength (
"length", // name
OpLengthSpec, // specification
OpLengthValueMap, // value mapping
Operator::SimpleSelect, // selection function
OpLengthTypeMap // type mapping
);
/*
4.5 Operator ~line2gline~
Translates a spatial ~line~ value into a network ~GLine~ value if possible.
*/
ListExpr OpLine2GLineTypeMap ( ListExpr in_xArgs )
{
if ( nl->ListLength ( in_xArgs ) != 2 )
{
sendMessage ( "Expects a list of length 2." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr xNetworkIdDesc = nl->First ( in_xArgs );
ListExpr xLineDesc = nl->Second ( in_xArgs );
if ( ( !nl->IsAtom ( xNetworkIdDesc ) ) ||
!nl->IsEqual ( xNetworkIdDesc, "network" ) )
{
sendMessage ( "First element must be of type network." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
if ( ( !nl->IsAtom ( xLineDesc ) ) ||
nl->AtomType ( xLineDesc ) != SymbolType ||
nl->SymbolValue ( xLineDesc ) != Line::BasicType() )
{
sendMessage ( "Second element must be of type sline." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
return nl->SymbolAtom ( "gline" );
}
int OpLine2GLineValueMapping ( Word* args,
Word& result,
int message,
Word& local,
Supplier in_xSupplier )
{
//Initialize return value
GLine* pGLine = ( GLine* ) qp->ResultStorage ( in_xSupplier ).addr;
result = SetWord ( pGLine );
// Get and check input values.
Network* pNetwork = ( Network* ) args[0].addr;
GLine *res = new GLine ( 0 );
if ( pNetwork == 0 || !pNetwork->IsDefined() )
{
string strMessage = "Network is not defined.";
cerr << strMessage << endl;
sendMessage ( strMessage );
res->SetDefined ( false );
pGLine->CopyFrom ( res );
res->DeleteIfAllowed();
return 0;
}
res->SetNetworkId ( pNetwork->GetId() );
Line* pLine = ( Line* ) args[1].addr;
if ( pLine == NULL || !pLine->IsDefined() )
{
string strMessage = "line does not exist.";
cerr << strMessage << endl;
sendMessage ( strMessage );
res->SetDefined ( false );
pGLine->CopyFrom ( res );
res->DeleteIfAllowed();
return 0;
}
if ( pLine->Size() <= 0 )
{
string strMessage = "line is empty";
cerr <<strMessage << endl;
sendMessage ( strMessage );
res->SetDefined ( true );
pGLine->CopyFrom ( res );
res->DeleteIfAllowed();
return 0;
}
HalfSegment hs;
pLine->Get ( 0,hs );
RouteInterval *ri =
pNetwork->Find ( hs.GetLeftPoint(), hs.GetRightPoint() );
if ( ri!= 0 )
{
RITree *riTree = new RITree ( ri->GetRouteId(), ri->GetStartPos(),
ri->GetEndPos() );
delete ri;
for ( int i = 1; i < pLine->Size();i++ )
{
pLine->Get ( i,hs );
ri = pNetwork->Find ( hs.GetLeftPoint(), hs.GetRightPoint() );
if ( ri!=0 )
{
riTree->Insert ( ri->GetRouteId(), ri->GetStartPos(), ri->GetEndPos() );
delete ri;
}
}
riTree->TreeToGLine ( res );
riTree->RemoveTree();
res->SetDefined ( true );
res->SetSorted ( true );
pGLine->CopyFrom ( res );
res->DeleteIfAllowed();
}
else
{
res->SetDefined ( false );
pGLine->CopyFrom ( res );
res->DeleteIfAllowed();
}
return 0;
} //end ValueMapping
const string OpLine2GLineSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>network x line -> gline" "</text--->"
"<text>sline2gline(_,_)</text--->"
"<text>Translates a line to a gline value.</text--->"
"<text>line2gline(B_NETWORK, sline)</text--->"
") )";
Operator sline2gline (
"line2gline", // name
OpLine2GLineSpec, // specification
OpLine2GLineValueMapping, // value mapping
Operator::SimpleSelect, // selection function
OpLine2GLineTypeMap // type mapping
);
/*
4.6 Operator ~=~
Returns true if two ~GPoint~s respectively ~GLine~s are identical false
elsewhere.
*/
ListExpr OpNetEqualTypeMap ( ListExpr args )
{
if ( nl->ListLength ( args ) != 2 )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr first = nl->First ( args );
ListExpr second = nl->Second ( args );
if ( ( nl->IsAtom ( first ) && nl->AtomType ( first ) == SymbolType &&
nl->IsAtom ( second ) && nl->AtomType ( second ) == SymbolType ) &&
( ( nl->SymbolValue ( first ) == "gpoint" &&
nl->SymbolValue ( second ) == "gpoint" ) ||
( nl->SymbolValue ( first ) == "gline" &&
nl->SymbolValue ( second ) == "gline" ) ) )
{
return nl->SymbolAtom ( CcBool::BasicType() );
}
return nl->SymbolAtom ( Symbol::TYPEERROR() );
}
int OpNetEqual_gpgp ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
GPoint* p1 = ( GPoint* ) args[0].addr;
GPoint* p2 = ( GPoint* ) args[1].addr;
result = qp->ResultStorage ( in_pSupplier );
CcBool* pResult = ( CcBool* ) result.addr;
if ( ! ( p1->IsDefined() ) || !p2->IsDefined() )
{
cmsg.inFunError ( "Both gpoints must be defined!" );
pResult->Set ( false, false );
return 0;
};
pResult-> Set ( true, *p1 == *p2 );
return 1;
}
int OpNetEqual_glgl ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
GLine* l1 = ( GLine* ) args[0].addr;
GLine* l2 = ( GLine* ) args[1].addr;
result = qp->ResultStorage ( in_pSupplier );
CcBool* pResult = ( CcBool* ) result.addr;
if ( ! ( l1->IsDefined() ) || !l2->IsDefined() )
{
cmsg.inFunError ( "Both glines must be defined!" );
pResult->Set ( false, false );
return 0;
};
pResult-> Set ( true, *l1 == *l2 );
return 1;
}
ValueMapping OpNetEqualmap[] =
{
OpNetEqual_gpgp,
OpNetEqual_glgl
};
int OpNetEqualselect ( ListExpr args )
{
ListExpr arg1 = nl->First ( args );
ListExpr arg2 = nl->Second ( args );
if ( nl->SymbolValue ( arg1 ) == "gpoint" &&
nl->SymbolValue ( arg2 ) == "gpoint" )
return 0;
if ( nl->SymbolValue ( arg1 ) == "gline" &&
nl->SymbolValue ( arg2 ) == "gline" )
return 1;
return -1; // This point should never be reached
};
const string OpNetEqualSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>A x A -> bool for GPoint and GLine" "</text--->"
"<text> _ = _</text--->"
"<text>Returns if two gpoints are equal.</text--->"
"<text>query gpoint1 = gpoint2</text--->"
") )";
Operator netgpequal (
"=", // name
OpNetEqualSpec, // specification
2,
OpNetEqualmap, // value mapping
OpNetEqualselect, // selection function
OpNetEqualTypeMap // type mapping
);
/*
4.7 Operator ~intersects~
Returns true if two ~Gline~ intersect false elsewhere.
*/
ListExpr OpNetIntersectsTypeMap ( ListExpr in_xArgs )
{
ListExpr arg1, arg2;
if ( nl->ListLength ( in_xArgs ) == 2 )
{
arg1 = nl->First ( in_xArgs );
arg2 = nl->Second ( in_xArgs );
if ( nl->IsAtom ( arg1 ) && nl->AtomType ( arg1 ) == SymbolType &&
nl->SymbolValue ( arg1 ) == "gline" && nl->IsAtom ( arg2 ) &&
nl->AtomType ( arg2 ) == SymbolType &&
nl->SymbolValue ( arg2 ) == "gline" )
{
return ( nl->SymbolAtom ( CcBool::BasicType() ) );
}
}
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
int OpNetIntersectsValueMapping ( Word* args,
Word& result,
int message,
Word& local,
Supplier in_xSupplier )
{
// Get (empty) return value
CcBool* pResult = ( CcBool* ) qp->ResultStorage ( in_xSupplier ).addr;
result = SetWord ( pResult );
pResult->Set ( false, false );
// Get input values
GLine* pGLine1 = ( GLine* ) args[0].addr;
if ( pGLine1 == NULL || !pGLine1->IsDefined() )
{
cerr << "First gline does not exist." << endl;
pResult->Set ( false, false );
return 0;
}
GLine* pGLine2 = ( GLine* ) args[1].addr;
if ( pGLine2 == NULL || !pGLine2->IsDefined() )
{
cerr << "Second gline does not exist." << endl;
pResult->Set ( false, false );
return 0;
}
// const RouteInterval *pRi1, *pRi2;
if ( pGLine1->GetNetworkId() != pGLine2->GetNetworkId() )
{
cerr << "glines belong to different networks." << endl;
pResult->Set ( true, false );
return 0;
}
pResult->Set ( true, pGLine1->Intersects ( pGLine2 ) );
return 0;
}
const string OpNetIntersectsSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" \"Example\" ) "
"( <text>gline x gline -> bool" "</text--->"
"<text>intersects(gline, gline)</text--->"
"<text>Returns true if the both glines intersects false elsewhere.</text--->"
"<text>intersects(gline, gline)</text--->"
") )";
Operator networkintersects (
"intersects", // name
OpNetIntersectsSpec, // specification
OpNetIntersectsValueMapping, // value mapping
Operator::SimpleSelect, // selection function
OpNetIntersectsTypeMap // type mapping
);
/*
4.8 Operator ~junctions~
Returns the junctions relation of the network.
*/
ListExpr OpNetworkJunctionsTypeMap ( ListExpr args )
{
ListExpr arg1;
if ( nl->ListLength ( args ) == 1 )
{
arg1 = nl->First ( args );
if ( nl->IsAtom ( arg1 ) &&
nl->AtomType ( arg1 ) == SymbolType &&
nl->SymbolValue ( arg1 ) == "network" )
{
ListExpr xType;
nl->ReadFromString ( Network::junctionsInternalTypeInfo, xType );
return xType;
}
}
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
int OpNetworkJunctionsValueMapping ( Word* args, Word& result, int message,
Word& local, Supplier s )
{
Network *network = ( Network* ) args[0].addr;
result = SetWord ( network->GetJunctions() );
Relation *resultSt = ( Relation* ) qp->ResultStorage ( s ).addr;
resultSt->Close();
qp->ChangeResultStorage ( s, result );
return 0;
}
const string OpNetworkJunctionsSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>network -> rel" "</text--->"
"<text>junctions(_)</text--->"
"<text>Return the junctions of a network.</text--->"
"<text>query junctions(network)</text--->"
") )";
Operator networkjunctions (
"junctions", // name
OpNetworkJunctionsSpec, // specification
OpNetworkJunctionsValueMapping, // value mapping
Operator::SimpleSelect, // trivial selection function
OpNetworkJunctionsTypeMap // type mapping
);
/*
4.9 Operator ~routes~
Returns the routes relation of the network.
*/
ListExpr OpNetworkRoutesTypeMap ( ListExpr args )
{
ListExpr arg1;
if ( nl->ListLength ( args ) == 1 )
{
arg1 = nl->First ( args );
if ( nl->IsAtom ( arg1 ) &&
nl->AtomType ( arg1 ) == SymbolType &&
nl->SymbolValue ( arg1 ) == "network" )
{
ListExpr xType;
nl->ReadFromString ( Network::routesInternalTypeInfo, xType );
return xType;
}
}
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
int OpNetworkRoutesValueMapping ( Word* args, Word& result, int message,
Word& local, Supplier s )
{
Network *network = ( Network* ) args[0].addr;
Relation* pRoute = network->GetRoutes();
result = SetWord ( pRoute->Clone() );
Relation *resultSt = ( Relation* ) qp->ResultStorage ( s ).addr;
resultSt->Close();
qp->ChangeResultStorage ( s, result );
return 0;
}
const string OpNetworkRoutesSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>network -> rel" "</text--->"
"<text>routes(_)</text--->"
"<text>Return the routes of a network.</text--->"
"<text>query routes(network)</text--->"
") )";
Operator networkroutes (
"routes", // name
OpNetworkRoutesSpec, // specification
OpNetworkRoutesValueMapping, // value mapping
Operator::SimpleSelect, // trivial selection function
OpNetworkRoutesTypeMap // type mapping
);
/*
4.10 Operator ~sections~
Returns the sections relation of the network.
*/
ListExpr OpNetworkSectionsTypeMap ( ListExpr args )
{
ListExpr arg1;
if ( nl->ListLength ( args ) == 1 )
{
arg1 = nl->First ( args );
if ( nl->IsAtom ( arg1 ) &&
nl->AtomType ( arg1 ) == SymbolType &&
nl->SymbolValue ( arg1 ) == "network" )
{
ListExpr xType;
nl->ReadFromString ( Network::sectionsInternalTypeInfo, xType );
return xType;
}
}
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
int OpNetworkSectionsValueMapping ( Word* args, Word& result, int message,
Word& local, Supplier s )
{
Network *network = ( Network* ) args[0].addr;
result = SetWord ( network->GetSections() );
Relation *resultSt = ( Relation* ) qp->ResultStorage ( s ).addr;
resultSt->Close();
qp->ChangeResultStorage ( s, result );
return 0;
}
const string OpNetworkSectionsSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>network -> rel" "</text--->"
"<text>sections(_)</text--->"
"<text>Return the sections of a network.</text--->"
"<text>query sections(network)</text--->"
") )";
Operator networksections (
"sections", // name
OpNetworkSectionsSpec, // specification
OpNetworkSectionsValueMapping, // value mapping
Operator::SimpleSelect, // trivial selection function
OpNetworkSectionsTypeMap // type mapping
);
/*
4.11 Operator ~thenetwork~
Creates a network with the given id, from the given routes and junctions
relations.
*/
ListExpr OpNetworkTheNetworkTypeMap ( ListExpr in_xArgs )
{
if ( nl->ListLength ( in_xArgs ) != 3 )
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
ListExpr xIdDesc = nl->First ( in_xArgs );
ListExpr xRoutesRelDesc = nl->Second ( in_xArgs );
ListExpr xJunctionsRelDesc = nl->Third ( in_xArgs );
if ( !nl->IsEqual ( xIdDesc, CcInt::BasicType() ) )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
if ( !IsRelDescription ( xRoutesRelDesc ) ||
!IsRelDescription ( xJunctionsRelDesc ) )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr xType;
nl->ReadFromString ( Network::routesTypeInfo, xType );
if ( !CompareSchemas ( xRoutesRelDesc, xType ) )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
nl->ReadFromString ( Network::junctionsTypeInfo, xType );
if ( !CompareSchemas ( xJunctionsRelDesc, xType ) )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
return nl->SymbolAtom ( "network" );
}
int OpNetworkTheNetworkValueMapping ( Word* args, Word& result,
int message, Word& local, Supplier s )
{
Network* pNetwork = ( Network* ) qp->ResultStorage ( s ).addr;
CcInt* pId = ( CcInt* ) args[0].addr;
int iId = pId->GetIntval();
map<int,string>::iterator it = netList->find ( iId );
if ( it != netList->end() )
{
cerr << "NetworkId used before" << iId << endl;
while ( it != netList->end() )
{
it = netList->find ( ++iId );
}
cerr << "NetworkId changed to: " << iId << endl;
}
netList->insert ( pair<int,string> ( iId, "" ) );
Relation* pRoutes = ( Relation* ) args[1].addr;
Relation* pJunctions = ( Relation* ) args[2].addr;
pNetwork->Load ( iId,
pRoutes,
pJunctions );
result = SetWord ( pNetwork );
return 0;
}
const string OpNetworkTheNetworkSpec =
"((\"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\") "
"(<text>int x rel x rel -> network" "</text--->"
"<text>thenetwork(_, _, _)</text--->"
"<text>Creates network with id or next free id.</text--->"
"<text>let n = thenetwork(int, routes, junctions)</text--->"
"))";
Operator networkthenetwork (
"thenetwork", // name
OpNetworkTheNetworkSpec, // specification
OpNetworkTheNetworkValueMapping, // value mapping
Operator::SimpleSelect, // trivial selection function
OpNetworkTheNetworkTypeMap // type mapping
);
/*
4.12 Operator ~no\_components~
Returns the number of ~RouteIntervals~ of the ~GLine~.
*/
ListExpr OpNoComponentsTypeMap ( ListExpr args )
{
if ( nl->ListLength ( args ) != 1 )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr gline = nl->First ( args );
if ( !nl->IsAtom ( gline ) || nl->AtomType ( gline ) != SymbolType ||
nl->SymbolValue ( gline ) != "gline" )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
return nl->SymbolAtom ( CcInt::BasicType() );
}
int OpNoComponentsValueMapping ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
GLine* pGline = ( GLine* ) args[0].addr;
result = qp->ResultStorage ( in_pSupplier );
CcInt* pResult = ( CcInt* ) result.addr;
if ( ! ( pGline->IsDefined() ) )
{
pResult->Set ( false, 0 );
return 0;
};
pResult-> Set ( true, pGline->NoOfComponents() );
return 1;
}
const string OpNoComponentsSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>gline -> int" "</text--->"
"<text>no_components(_)</text--->"
"<text>Returns the number of route intervals.</text--->"
"<text>query no_components(gline)</text--->"
") )";
Operator networknocomponents (
"no_components", // name
OpNoComponentsSpec, // specification
OpNoComponentsValueMapping, // value mapping
Operator::SimpleSelect, // selection function
OpNoComponentsTypeMap // type mapping
);
/*
4.13 Operator ~point2gpoint~
Translates a spatial ~Point~ value into a network ~GPoint~ value if possible.
*/
ListExpr OpPoint2GPointTypeMap ( ListExpr in_xArgs )
{
if ( nl->ListLength ( in_xArgs ) != 2 )
{
sendMessage ( "Expects a list of length 2." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr xNetworkIdDesc = nl->First ( in_xArgs );
ListExpr xMPointDesc = nl->Second ( in_xArgs );
if ( ( !nl->IsAtom ( xNetworkIdDesc ) ) ||
!nl->IsEqual ( xNetworkIdDesc, "network" ) )
{
sendMessage ( "First element must be of type network." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
if ( ( !nl->IsAtom ( xMPointDesc ) ) ||
nl->AtomType ( xMPointDesc ) != SymbolType ||
nl->SymbolValue ( xMPointDesc ) != Point::BasicType() )
{
sendMessage ( "Second element must be of type point." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
return nl->SymbolAtom ( "gpoint" );
}
int OpPoint2GPointValueMapping ( Word* args,
Word& result,
int message,
Word& local,
Supplier in_xSupplier )
{
GPoint* pGPoint = ( GPoint* ) qp->ResultStorage ( in_xSupplier ).addr;
result = SetWord ( pGPoint );
Network* pNetwork = ( Network* ) args[0].addr;
if ( pNetwork == 0 || !pNetwork->IsDefined() )
{
string strMessage = "Network is not defined.";
cerr << strMessage << endl;
sendMessage ( strMessage );
pGPoint->SetDefined ( false );
return 0;
}
Point* pPoint = ( Point* ) args[1].addr;
if ( pPoint == NULL || !pPoint->IsDefined() )
{
string strMessage = "Point does not exist.";
cerr << strMessage << endl;
sendMessage ( strMessage );
pGPoint->SetDefined ( false );
return 0;
}
GPoint *res = pNetwork->GetNetworkPosOfPoint ( *pPoint );
pGPoint->CopyFrom ( res );
res->DeleteIfAllowed();
/*GPoint *res = pNetwork->GetNetworkPosOfPoint(*pPoint);
qp->ChangeResultStorage(in_xSupplier, res);*/
return 0;
} //end ValueMapping
const string OpPoint2GPointSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>network x point -> gpoint" "</text--->"
"<text>point2gpoint(networkobject, point)</text--->"
"<text>Translates a point to a gpoint.</text--->"
"<text>point2gpoint(b_network, point)</text--->"
") )";
Operator point2gpoint (
"point2gpoint", // name
OpPoint2GPointSpec, // specification
OpPoint2GPointValueMapping, // value mapping
Operator::SimpleSelect, // selection function
OpPoint2GPointTypeMap // type mapping
);
/*
4.14 Operator ~gpoint2point~
Translates a ~gpoint~ into a spatial ~Point~ value.
*/
ListExpr OpGPoint2PointTypeMap ( ListExpr in_xArgs )
{
if ( nl->ListLength ( in_xArgs ) != 1 )
{
sendMessage ( "Expects a list of length 1." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr xMPointDesc = nl->First ( in_xArgs );
if ( ( !nl->IsAtom ( xMPointDesc ) ) ||
nl->AtomType ( xMPointDesc ) != SymbolType ||
nl->SymbolValue ( xMPointDesc ) != "gpoint" )
{
sendMessage ( "Element must be of type gpoint." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
return nl->SymbolAtom ( Point::BasicType() );
}
int OpGPoint2PointValueMapping ( Word* args,
Word& result,
int message,
Word& local,
Supplier in_xSupplier )
{
Point* pPoint = ( Point* ) qp->ResultStorage ( in_xSupplier ).addr;
result = SetWord ( pPoint );
GPoint* pGPoint = ( GPoint* ) args[0].addr;
if ( pGPoint == NULL || !pGPoint->IsDefined() )
{
string strMessage = "Point does not exist.";
cerr << strMessage << endl;
sendMessage ( strMessage );
pPoint->SetDefined ( false );
return 0;
}
pGPoint->ToPoint ( pPoint );
return 0;
} //end ValueMapping
const string OpGPoint2PointSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>gpoint -> point" "</text--->"
"<text>gpoint2point(gpoint)</text--->"
"<text>Translates a gpoint to a point.</text--->"
"<text>gpoint2point(gpoint)</text--->"
") )";
Operator gpoint2point (
"gpoint2point", // name
OpGPoint2PointSpec, // specification
OpGPoint2PointValueMapping, // value mapping
Operator::SimpleSelect, // selection function
OpGPoint2PointTypeMap // type mapping
);
/*
4.15 Operator ~polygpoint~
Returns a stream of all ~GPoint~ values which are at the same network position
as the given ~GPoint~. Including the given ~GPoint~.
*/
ListExpr OpPolyGPointTypeMap ( ListExpr in_xArgs )
{
if ( nl->ListLength ( in_xArgs ) != 2 )
{
sendMessage ( "Expects a list of length 1." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr xsource = nl->First ( in_xArgs );
ListExpr xnetwork = nl->Second ( in_xArgs );
if ( ( !nl->IsAtom ( xsource ) ) ||
!nl->IsEqual ( xsource, "gpoint" ) )
{
sendMessage ( "First Element must be of type gpoint." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
if ( ( !nl->IsAtom ( xnetwork ) ) ||
!nl->IsEqual ( xnetwork, "network" ) )
{
sendMessage ( "Second Element must be of type network." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
return nl->TwoElemList ( nl->SymbolAtom ( Symbol::STREAM() ),
nl->SymbolAtom ( "gpoint" ) );
}
int OpPolyGPointValueMapping ( Word* args,
Word& result,
int message,
Word& local,
Supplier in_xSupplier )
{
GPointList* localinfo;
GPoint res;
result = qp->ResultStorage ( in_xSupplier );
switch ( message )
{
case OPEN:
local = SetWord ( new GPointList ( ( GPoint* ) args[0].addr,
( Network* ) args[1].addr ) );
return 0;
case REQUEST:
localinfo = ( GPointList* ) local.addr;
res = localinfo->NextGPoint();
if ( !res.IsDefined() )
{
return CANCEL;
}
else
{
result = SetWord ( new GPoint ( res ) );
return YIELD;
}
case CLOSE:
if ( local.addr != 0 )
{
delete ( GPointList* ) local.addr;
local = SetWord ( Address ( 0 ) );
}
return 0;
}
return 0; // ignore unknown message
} //end ValueMapping
const string OpPolyGPointSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>gpoint x network -> stream(gpoint)" "</text--->"
"<text>gpoint polygpoint</text--->"
"<text>Returns the gpoint and gpoints with the same network position"
" if the gpoint is a junction.</text--->"
"<text> polygpoints (gpoint, network) </text--->"
") )";
Operator polygpoints (
"polygpoints", // name
OpPolyGPointSpec, // specification
OpPolyGPointValueMapping, // value mapping
Operator::SimpleSelect, // selection function
OpPolyGPointTypeMap // type mapping
);
/*
4.16 Operator ~routeintervals~
Returns a stream of rectangles representing the ~RouteIntervals~ of the ~GLine~.
*/
ListExpr OpRouteIntervalsTypeMap ( ListExpr in_xArgs )
{
if ( nl->ListLength ( in_xArgs ) != 1 )
{
sendMessage ( "Expects a list of length 1." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr xsource = nl->First ( in_xArgs );
if ( ( !nl->IsAtom ( xsource ) ) ||
!nl->IsEqual ( xsource, "gline" ) )
{
sendMessage ( "First Element must be of type gline." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
return nl->TwoElemList ( nl->SymbolAtom ( Symbol::STREAM() ),
nl->SymbolAtom ( Rectangle<2>::BasicType() ) );
}
int OpRouteIntervalsValueMapping ( Word* args,
Word& result,
int message,
Word& local,
Supplier in_xSupplier )
{
RectangleList* localinfo;
Rectangle<2> res;
result = qp->ResultStorage ( in_xSupplier );
switch ( message )
{
case OPEN:
local = SetWord ( new RectangleList ( ( GLine* ) args[0].addr ) );
return 0;
case REQUEST:
localinfo = ( RectangleList* ) local.addr;
res = localinfo->NextRectangle();
if ( !res.IsDefined() ) return CANCEL;
else
{
result = SetWord ( new Rectangle<2> ( res ) );
return YIELD;
}
case CLOSE:
if ( local.addr != 0 )
{
delete ( RectangleList* ) local.addr;
local = SetWord ( Address ( 0 ) );
}
return 0;
}
return 0; // ignore unknown message
} //end ValueMapping
const string OpRouteIntervalsSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>gline -> stream(rect)" "</text--->"
"<text>routeintervals(GLINE)</text--->"
"<text>Returns a stream of rectangles representing the route intervals of the"
" gline.</text--->"
"<text> routeintervals (gline) </text--->"
") )";
Operator networkrouteintervals (
"routeintervals", // name
OpRouteIntervalsSpec, // specification
OpRouteIntervalsValueMapping, // value mapping
Operator::SimpleSelect, // selection function
OpRouteIntervalsTypeMap // type mapping
);
/*
4.17 Operator ~shortest\_path~
Returns the shortest path in the ~Network~ between two ~GPoint~. Using Dijkstra
Algorithm to compute the shortest path.
*/
ListExpr OpShortestPathTypeMap ( ListExpr in_xArgs )
{
if ( nl->ListLength ( in_xArgs ) != 2 )
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
ListExpr xGPoint1Desc = nl->First ( in_xArgs );
ListExpr xGPoint2Desc = nl->Second ( in_xArgs );
// ListExpr xGPoint3Desc = nl->Third(in_xArgs);
if ( ( !nl->IsAtom ( xGPoint1Desc ) ) ||
nl->AtomType ( xGPoint1Desc ) != SymbolType ||
nl->SymbolValue ( xGPoint1Desc ) != "gpoint" )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
if ( ( !nl->IsAtom ( xGPoint2Desc ) ) ||
nl->AtomType ( xGPoint2Desc ) != SymbolType ||
nl->SymbolValue ( xGPoint2Desc ) != "gpoint" )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
//if((!nl->IsAtom(xGPoint3Desc))|| (!nl->IsEqual(xGPoint3Desc,"network"))) {
// return (nl->SymbolAtom(Symbol::TYPEERROR()));
//}
return nl->SymbolAtom ( "gline" );
}
int OpShortestPathValueMapping ( Word* args,
Word& result,
int message,
Word& local,
Supplier in_xSupplier )
{
GPoint *pFromGPoint = ( GPoint* ) args[0].addr;
GPoint *pToGPoint = ( GPoint* ) args[1].addr;
GLine* pGLine = ( GLine* ) qp->ResultStorage ( in_xSupplier ).addr;
result = SetWord ( pGLine );
pGLine->SetSorted ( false );
pGLine->SetDefined ( pFromGPoint->ShortestPath ( pToGPoint, pGLine ) );
return 0;
}
const string OpShortestPathSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>gpoint x gpoint -> gline" "</text--->"
"<text>shortest_path( _ , _)</text--->"
"<text>Calculates the shortest path between two gpoints.</text--->"
"<text>query shortest_path(x, y)</text--->"
") )";
Operator shortest_path (
"shortest_path", // name
OpShortestPathSpec, // specification
OpShortestPathValueMapping, // value mapping
Operator::SimpleSelect, // trivial selection function
OpShortestPathTypeMap // type mapping
);
/*
4.18 Operator ~gline2line~
Returns the ~line~ value of the given ~GLine~.
*/
ListExpr OpGLine2LineTypeMap ( ListExpr in_xArgs )
{
if ( nl->ListLength ( in_xArgs ) != 1 )
{
sendMessage ( "Expects a list of length 1." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr xsource = nl->First ( in_xArgs );
if ( ( !nl->IsAtom ( xsource ) ) ||
!nl->IsEqual ( xsource, "gline" ) )
{
sendMessage ( "Element must be of type gline." );
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
return nl->SymbolAtom ( Line::BasicType() );
}
int OpGLine2LineValueMapping ( Word* args,
Word& result,
int message,
Word& local,
Supplier in_xSupplier )
{
Line* pLine = ( Line* ) qp->ResultStorage ( in_xSupplier ).addr;
result = SetWord ( pLine );
GLine* pGLine = ( GLine* ) args[0].addr;
if ( pGLine == NULL || !pGLine->IsDefined() )
{
sendMessage ( "GLine must be defined!" );
pLine->SetDefined ( false );
return 0;
}
pGLine->Gline2line ( pLine );
return 0;
}
const string OpGLine2LineSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>gline -> line" "</text--->"
"<text>gline2line(GLINE)</text--->"
"<text>Returns the line value of the gline.</text--->"
"<text> gline2line(gline) </text--->"
") )";
Operator networkgline2line (
"gline2line", // name
OpGLine2LineSpec, // specification
OpGLine2LineValueMapping, // value mapping
Operator::SimpleSelect, // selection function
OpGLine2LineTypeMap // type mapping
);
/*
4.19 Operator ~isempty~
Returns if the ~GLine~. is empty.
*/
ListExpr OpNetIsEmptyTypeMap ( ListExpr args )
{
if ( nl->ListLength ( args ) != 1 )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr gline = nl->First ( args );
if ( !nl->IsAtom ( gline ) || nl->AtomType ( gline ) != SymbolType ||
nl->SymbolValue ( gline ) != "gline" )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
return nl->SymbolAtom ( CcBool::BasicType() );
}
int OpNetIsEmptyValueMap ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
GLine* pGline = ( GLine* ) args[0].addr;
result = qp->ResultStorage ( in_pSupplier );
CcBool* pResult = ( CcBool* ) result.addr;
if ( ( ! ( pGline->IsDefined() ) ) || pGline->NoOfComponents() == 0 )
{
pResult->Set ( true, true );
return 0;
}
else
{
pResult->Set ( true,false );
return 0;
}
}
const string OpNetIsEmptySpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>gline -> bool" "</text--->"
"<text>isemtpy(_)</text--->"
"<text>Returns true if the gline is empty.</text--->"
"<text>query isempty(gline)</text--->"
") )";
Operator networkisempty (
"isempty", // name
OpNetIsEmptySpec, // specification
OpNetIsEmptyValueMap, // value mapping
Operator::SimpleSelect, // selection function
OpNetIsEmptyTypeMap // type mapping
);
/*
4.20 Operator ~union~
Builds the union of the two given glines as sorted gline.
*/
ListExpr OpNetUnionTypeMap ( ListExpr args )
{
if ( nl->ListLength ( args ) != 2 )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr gline1 = nl->First ( args );
ListExpr gline2 = nl->Second ( args );
if ( !nl->IsAtom ( gline1 ) || nl->AtomType ( gline1 ) != SymbolType ||
nl->SymbolValue ( gline1 ) != "gline" )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
if ( !nl->IsAtom ( gline2 ) || nl->AtomType ( gline2 ) != SymbolType ||
nl->SymbolValue ( gline2 ) != "gline" )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
return nl->SymbolAtom ( "gline" );
}
int OpNetUnionValueMap ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
GLine *pGL1 = ( GLine* ) args[0].addr;
GLine *pGL2 = ( GLine* ) args[1].addr;
GLine *pGLine = ( GLine* ) qp->ResultStorage ( in_pSupplier ).addr;
result = SetWord ( pGLine );
pGL1->Uniongl ( pGL2, pGLine );
return 0;
}
const string OpNetUnionSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>gline x gline -> gline" "</text--->"
"<text>_ union _ </text--->"
"<text>Returns the sorted gline resulting of the union of both "
"gline.</text--->"
"<text>query gline1 union gline2</text--->"
") )";
Operator networkunion (
"union", // name
OpNetUnionSpec, // specification
OpNetUnionValueMap, // value mapping
Operator::SimpleSelect, // selection function
OpNetUnionTypeMap // type mapping
);
/*
4.21 Operator ~distance~
Returns the Euclidean Distance between two ~Gpoints~ or two ~GLines~.
*/
ListExpr OpNetDistanceTypeMap ( ListExpr args )
{
if ( nl->ListLength ( args ) != 2 )
{
return ( nl->SymbolAtom ( Symbol::TYPEERROR() ) );
}
ListExpr param1 = nl->First ( args );
ListExpr param2 = nl->Second ( args );
if ( ( nl->IsAtom ( param1 ) && nl->AtomType ( param1 ) == SymbolType &&
nl->IsAtom ( param2 ) && nl->AtomType ( param2 ) == SymbolType &&
( ( nl->SymbolValue ( param1 ) == "gpoint" &&
nl->SymbolValue ( param2 ) == "gpoint" ) ||
( nl->SymbolValue ( param1 ) == "gline" &&
nl->SymbolValue ( param2 ) == "gline" ) ) ) )
{
return nl->SymbolAtom ( CcReal::BasicType() );
}
return nl->SymbolAtom ( Symbol::TYPEERROR() );
}
int OpNetDistance_gpgp ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
GPoint* pFromGPoint = ( GPoint* ) args[0].addr;
GPoint* pToGPoint = ( GPoint* ) args[1].addr;
result = qp->ResultStorage ( in_pSupplier );
CcReal* pResult = ( CcReal* ) result.addr;
if ( ! ( pFromGPoint->IsDefined() ) || ! ( pToGPoint->IsDefined() ) )
{
cmsg.inFunError ( "Both gpoint must be defined!" );
return 0;
};
pResult-> Set ( true, pFromGPoint->Distance ( pToGPoint ) );
return 0;
};
int OpNetDistance_glgl ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
GLine* pGLine1 = ( GLine* ) args[0].addr;
GLine* pGLine2 = ( GLine* ) args[1].addr;
result = qp->ResultStorage ( in_pSupplier );
CcReal* pResult = ( CcReal* ) result.addr;
if ( ! ( pGLine1->IsDefined() ) || ! ( pGLine2->IsDefined() ) ||
pGLine1->NoOfComponents() == 0 || pGLine2->NoOfComponents() == 0 )
{
cmsg.inFunError ( "Both gline must be defined! And have at least 1 interval"
);
return 0;
};
pResult-> Set ( true, pGLine1->Distance ( pGLine2 ) );
return 1;
};
ValueMapping OpNetDistancemap[] =
{
OpNetDistance_gpgp,
OpNetDistance_glgl
};
int OpNetDistanceselect ( ListExpr args )
{
ListExpr arg1 = nl->First ( args );
ListExpr arg2 = nl->Second ( args );
if ( nl->SymbolValue ( arg1 ) == "gpoint" &&
nl->SymbolValue ( arg2 ) == "gpoint" )
return 0;
if ( nl->SymbolValue ( arg1 ) == "gline" &&
nl->SymbolValue ( arg2 ) == "gline" )
return 1;
return -1; // This point should never be reached
};
const string OpNetDistanceSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>A x A -> real with A = gpoint or gline" "</text--->"
"<text>distance(GPOINT1,GPOINT2)</text--->"
"<text>Calculates the Euclidean Distance of gpoints resp. glines.</text--->"
"<text>query distance(gp1,gp2)</text--->"
") )";
Operator networkdistance (
"distance", // name
OpNetDistanceSpec, // specification
2,
OpNetDistancemap, // value mapping
OpNetDistanceselect, // selection function
OpNetDistanceTypeMap // type mapping
);
/*
4.22 Operator ~update\_sectioncost~
Updates the costs of one or more sections.
The oprator expects two or three arguments. The first argument should be a
network. Is the number of arguments two. The second agument should be a relation
like (rel (tuple ((sid int) (cost real)))). If the number of arguments is three,
then the second argument should be an sectionid (int) and the third argument
should be the cost of the section (real).
*/
ListExpr OpUpdateSectionCostTypeMap ( ListExpr in_xArgs ){
NList param(in_xArgs);
//check the number of arguments
if(param.length() <2 || param.length() >3)
{
return listutils::typeError(
"update_sectioncost expects either 2 or 3 arguments.");
}
ListExpr xNetworkDesc = nl->First(in_xArgs);
//check the type of the first arguments
if ( ( !nl->IsAtom ( xNetworkDesc ) ) ||
!nl->IsEqual ( xNetworkDesc, "network" ) )
{
return listutils::typeError("1.argument should be a network");
}
if (param.length() == 2)
{ //read the arguments
ListExpr xRelDesc = nl->Second(in_xArgs);
if ( !IsRelDescription ( xRelDesc ) )
{
return listutils::typeError( "2.agument should be a relation" );
}
ListExpr xType;
string costsTypeInfo = "(rel (tuple ((sid int) (cost real))))";
nl->ReadFromString ( costsTypeInfo, xType );
if ( !CompareSchemas ( xRelDesc, xType ) )
{
return listutils::typeError("the pattern of the relation ist wrong");
}
}
if ( param.length() == 3 )
{ //read the arguments
ListExpr xIdDesc = nl->Second(in_xArgs);
ListExpr xCostDesc = nl->Third(in_xArgs);
if (!nl->IsEqual(xIdDesc, CcInt::BasicType()))
{
return listutils::typeError("2.argument should be an int.");
}
if(!nl->IsEqual (xCostDesc, CcReal::BasicType()))
{
return listutils::typeError("3.argument should be an real.");
}
}
return nl->SymbolAtom ( CcBool::BasicType() );
}
int OpUpdateSectionCost_One ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
Network* pNetwork = ( Network* ) args[0].addr;
int secId = (( CcInt* ) args[1].addr)->GetIntval();
double newCost = (( CcReal* ) args[2].addr)->GetRealval();
result = qp->ResultStorage ( in_pSupplier );
CcBool* pResult = ( CcBool* ) result.addr;
if ( pNetwork == 0 || !pNetwork->IsDefined() )
{
string strMessage = "Network is not defined.";
cerr << strMessage << endl;
sendMessage ( strMessage );
pResult->Set ( false, false );
return 0;
}
qp->SetModified(qp->GetSon(in_pSupplier,0));
pResult->Set ( true, pNetwork->UpdateSectionCost(secId,newCost));
return 0;
}
int OpUpdateSectionCost_More ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
Network* pNetwork = ( Network* ) args[0].addr;
Relation* pCosts = ( Relation* ) args[1].addr;
result = qp->ResultStorage ( in_pSupplier );
CcBool* pResult = ( CcBool* ) result.addr;
if ( pNetwork == 0 || !pNetwork->IsDefined() )
{
string strMessage = "Network is not defined.";
cerr << strMessage << endl;
sendMessage ( strMessage );
pResult->Set ( false, false );
return 0;
}
qp->SetModified(qp->GetSon(in_pSupplier,0));
pResult->Set ( true, pNetwork->UpdateMoreSectionCost(pCosts));
return 0;
}
ValueMapping OpUpdateSectionCostMap[]=
{ OpUpdateSectionCost_One,
OpUpdateSectionCost_More
};
int OpUpdateSectionCostSelect(ListExpr in_xArgs){
NList param(in_xArgs);
//check the number of arguments
if ( param.length() == 3 ){
return 0;
}
if(param.length() == 2){
return 1;
}
return -1;
}
const string OpUpdateSectionCostSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text> network x A [x real] -> bool with A as int or as rel </text--->"
"<text> update_sectioncost(_,_,_) </text--->"
"<text>Returns true, when the Update was successful.</text--->"
"<text>query update_sectioncost(B_NETWORK,1,5.0)</text--->"
") )";
Operator update_sectioncost (
"update_sectioncost", // name
OpUpdateSectionCostSpec, // specification
2,
OpUpdateSectionCostMap, // value mapping
OpUpdateSectionCostSelect, // selection function
OpUpdateSectionCostTypeMap // type mapping
);
/*
4.23 Operator ~update\_sectionduration~
Updates the duration of one or more sections.
The oprator expects two or three arguments. The first argument should be a
network. Is the number of arguments two. The second agument should be a relation
like (rel (tuple ((sid int) (duration real)))). If the number of arguments is
three, then the second argument should be an sectionid (int) and the third
argument should be the duration of the section (real).
*/
ListExpr OpUpdateSectionDurationTypeMap ( ListExpr in_xArgs ){
NList param(in_xArgs);
//check the number of arguments
if(param.length() <2 || param.length() >3){
return listutils::typeError(
"update_sectionduration expects either 2 or 3 arguments.");
}
ListExpr xNetworkDesc = nl->First(in_xArgs);
//check the type of the first arguments
if ( ( !nl->IsAtom ( xNetworkDesc ) ) ||
!nl->IsEqual ( xNetworkDesc, "network" ) )
{
return listutils::typeError("1.argument should be a network");
}
if (param.length() == 2)
{ //read the arguments
ListExpr xRelDesc = nl->Second(in_xArgs);
if ( !IsRelDescription ( xRelDesc ) )
{
return listutils::typeError( "2.agument should be a relation" );
}
ListExpr xType;
string durationsTypeInfo = "(rel (tuple ((sid int) (duration real))))";
nl->ReadFromString ( durationsTypeInfo, xType );
if ( !CompareSchemas ( xRelDesc, xType ) )
{
return listutils::typeError("the pattern of the relation ist wrong");
}
}
if ( param.length() == 3 )
{ //read the arguments
ListExpr xIdDesc = nl->Second(in_xArgs);
ListExpr xDurationDesc = nl->Third(in_xArgs);
if (!nl->IsEqual(xIdDesc, CcInt::BasicType()))
{
return listutils::typeError("2.argument should be an int.");
}
if(!nl->IsEqual (xDurationDesc, CcReal::BasicType()))
{
return listutils::typeError("3.argument should be an real.");
}
}
return nl->SymbolAtom ( CcBool::BasicType() );
}
int OpUpdateSectionDuration_One ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
Network* pNetwork = ( Network* ) args[0].addr;
int secId = (( CcInt* ) args[1].addr)->GetIntval();
double newDuration = (( CcReal* ) args[2].addr)->GetRealval();
result = qp->ResultStorage ( in_pSupplier );
CcBool* pResult = ( CcBool* ) result.addr;
if ( pNetwork == 0 || !pNetwork->IsDefined() )
{
string strMessage = "Network is not defined.";
cerr << strMessage << endl;
sendMessage ( strMessage );
pResult->Set ( false, false );
return 0;
}
qp->SetModified(qp->GetSon(in_pSupplier,0));
pResult->Set ( true, pNetwork->UpdateSectionDuration(secId,newDuration));
return 0;
}
int OpUpdateSectionDuration_More ( Word* args, Word& result, int message,
Word& local, Supplier in_pSupplier )
{
Network* pNetwork = ( Network* ) args[0].addr;
Relation* pDurations = ( Relation* ) args[1].addr;
result = qp->ResultStorage ( in_pSupplier );
CcBool* pResult = ( CcBool* ) result.addr;
if ( pNetwork == 0 || !pNetwork->IsDefined() )
{
string strMessage = "Network is not defined.";
cerr << strMessage << endl;
sendMessage ( strMessage );
pResult->Set ( false, false );
return 0;
}
qp->SetModified(qp->GetSon(in_pSupplier,0));
pResult->Set ( true, pNetwork->UpdateMoreSectionDuration(pDurations));
return 0;
}
ValueMapping OpUpdateSectionDurationMap[]=
{ OpUpdateSectionDuration_One,
OpUpdateSectionDuration_More
};
int OpUpdateSectionDurationSelect(ListExpr in_xArgs){
NList param(in_xArgs);
//check the number of arguments
if ( param.length() == 3 ){
return 0;
}
if(param.length() == 2){
return 1;
}
return -1;
}
const string OpUpdateSectionDurationSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text> network x A [x real] -> bool with A as int or as rel </text--->"
"<text> update_sectionduration(_,_,_) </text--->"
"<text>Returns true, when the Update was successful.</text--->"
"<text>query update_sectionduration(B_NETWORK,1,5.0)</text--->"
") )";
Operator update_sectionduration (
"update_sectionduration", // name
OpUpdateSectionDurationSpec, // specification
2,
OpUpdateSectionDurationMap, // value mapping
OpUpdateSectionDurationSelect, // selection function
OpUpdateSectionDurationTypeMap // type mapping
);
/*
4.24 Operator ~shortespath\_astarplus~
Returns the shortest path in the ~Network~ between two ~GPoint~. Using
AStar-Algorithm to compute the shortest path.
The operator expects either 2 or 3 arguments. The first and the second argument
should be a gpoint. If the number of arguments ist three, then the third
argument should be a function with three parameters.
*/
ListExpr OpShortestPathAStarPlusTypeMap ( ListExpr in_xArgs )
{
//check the number of arguments
if(nl->ListLength ( in_xArgs ) <2 || nl->ListLength ( in_xArgs ) >3){
return listutils::typeError(
"shortestpath_astarplus expects either 2 or 3 arguments.");
}
ListExpr xGPoint1Desc = nl->First (in_xArgs);
ListExpr xGPoint2Desc = nl->Second (in_xArgs);
if ( ( !nl->IsAtom ( xGPoint1Desc ) ) ||
nl->AtomType ( xGPoint1Desc ) != SymbolType ||
nl->SymbolValue ( xGPoint1Desc ) != "gpoint" )
{
return listutils::typeError("the first parameter should be a gpoint.");
}
if ( ( !nl->IsAtom ( xGPoint2Desc ) ) ||
nl->AtomType ( xGPoint2Desc ) != SymbolType ||
nl->SymbolValue ( xGPoint2Desc ) != "gpoint" )
{
return listutils::typeError("the second parameter should be a gpoint.");
}
if(nl->ListLength ( in_xArgs ) == 3)
{
ListExpr map = nl->Third(in_xArgs);
if ( nl->IsAtom( map ) || !( nl->IsEqual(nl->First(map),
Symbol::MAP()) ) )
{
return listutils::typeError(
"the third parameter should be a function.");
}
else
{
if ( nl->ListLength(map) != 5)
{
return NList::typeError(
"the third parameter should be a function with three parameter.");
}
if(!( nl->IsEqual(nl->Second(map), CcReal::BasicType()))
|| !( nl->IsEqual(nl->Third(map), CcReal::BasicType()))
|| !( nl->IsEqual(nl->Fourth(map), CcReal::BasicType())) ){
return listutils::typeError(
"one or more parameters has the wrong type, it should be a real.");
}
}
}
return nl->SymbolAtom ( "gline" );
}
int OpShortestPathAStarPlusValueMapping ( Word* args,
Word& result,
int message,
Word& local,
Supplier in_xSupplier )
{
GPoint *pFromGPoint = ( GPoint* ) args[0].addr;
GPoint *pToGPoint = ( GPoint* ) args[1].addr;
Word func = args[2].addr;
GLine* pGLine = ( GLine* ) qp->ResultStorage ( in_xSupplier ).addr;
result = SetWord ( pGLine );
pGLine->SetSorted ( false );
pGLine->SetDefined (
pFromGPoint->ShortestPathAStarPlus ( pToGPoint, pGLine, func ) );
return 0;
}
const string OpShortestPathAStarPlusSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>gpoint x gpoint [x A] -> gline with A as (map real real real real)"
"</text--->"
"<text>shortestpath_astarplus( _ , _ ,_)</t1ext--->"
"<text>Calculates the shortest path between two "
"gpoints with the astar-algorithm.</text--->"
"<text>query shortestpath_astarplus([const gpoint value(1 2 0.0 0)],"
"[const gpoint value(1 10 5.0 1)]);</text--->"
") )";
Operator shortestpath_astarplus (
"shortestpath_astarplus", // name
OpShortestPathAStarPlusSpec, // specification
OpShortestPathAStarPlusValueMapping, // value mapping
Operator::SimpleSelect, // trivial selection function
OpShortestPathAStarPlusTypeMap // type mapping
);
/*
4.25 Operator ~optimize\_network~
Optimizes the given ~network~ by all routes contained sorted by lexicographic
starting point and all sections are rearranged.
*/
ListExpr OpOptimizeNetworkTypeMap ( ListExpr in_xArgs )
{
//check the number of arguments
if(nl->ListLength ( in_xArgs ) !=1){
return listutils::typeError(
"optimize_network expects only one argument.");
}
ListExpr xNetworkDesc = nl->First(in_xArgs);
//check the type of the first arguments
if ( ( !nl->IsAtom ( xNetworkDesc ) ) ||
!nl->IsEqual ( xNetworkDesc, "network" ) )
{
return listutils::typeError("1.argument should be a network");
}
return nl->SymbolAtom ( CcBool::BasicType() );
}
int OpOptimizeNetworkValueMapping ( Word* args,
Word& result,
int message,
Word& local,
Supplier in_xSupplier )
{
Network* pNetwork = ( Network* ) args[0].addr;
result = qp->ResultStorage ( in_xSupplier );
CcBool* pResult = ( CcBool* ) result.addr;
if ( pNetwork == 0 || !pNetwork->IsDefined() )
{
string strMessage = "Network is not defined.";
cerr << strMessage << endl;
sendMessage ( strMessage );
pResult->Set ( false, false );
return 0;
}
qp->SetModified(qp->GetSon(in_xSupplier,0));
pResult->Set ( true, pNetwork->OptimizeNetwork());
return 0;
}
const string OpOptimizeNetworkSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>network -> bool)" "</text--->"
"<text>optimizenet( _ )</t1ext--->"
"<text>Optimized the storage of the sections.</text--->"
"<text>query optimize_network(B_NETWORK)]);</text--->"
") )";
Operator optimizenet (
"optimizenet", // name
OpOptimizeNetworkSpec, // specification
OpOptimizeNetworkValueMapping, // value mapping
Operator::SimpleSelect, // trivial selection function
OpOptimizeNetworkTypeMap // type mapping
);
/*
4.26 Operator ~print\_adjacencylist~
Prints infromations of routes, sections and their neighbours of the
given ~network~.
*/
ListExpr OpPrintAdjacencyListTypeMap ( ListExpr in_xArgs )
{
//check the number of arguments
if(nl->ListLength ( in_xArgs ) !=1){
return listutils::typeError(
"optimize_network expects only one argument.");
}
ListExpr xNetworkDesc = nl->First(in_xArgs);
//check the type of the first arguments
if ( ( !nl->IsAtom ( xNetworkDesc ) ) ||
!nl->IsEqual ( xNetworkDesc, "network" ) )
{
return listutils::typeError("1.argument should be a network");
}
return nl->SymbolAtom ( CcBool::BasicType() );
}
int OpPrintAdjacencyListValueMapping ( Word* args,
Word& result,
int message,
Word& local,
Supplier in_xSupplier )
{
Network* pNetwork = ( Network* ) args[0].addr;
result = qp->ResultStorage ( in_xSupplier );
CcBool* pResult = ( CcBool* ) result.addr;
if ( pNetwork == 0 || !pNetwork->IsDefined() )
{
string strMessage = "Network is not defined.";
cerr << strMessage << endl;
sendMessage ( strMessage );
pResult->Set ( false, false );
return 0;
}
pResult->Set ( true, pNetwork->PrintAdjacentSectionInfo());
return 0;
}
const string OpPrintAdjacencyListSpec =
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" ) "
"( <text>network -> bool)" "</text--->"
"<text>print_adjacencylist( _ )</t1ext--->"
"<text>print the informations about the adjacent sections.</text--->"
"<text>query print_adjacencylist(B_NETWORK)]);</text--->"
") )";
Operator print_adjacencylist (
"print_adjacencylist", // name
OpPrintAdjacencyListSpec, // specification
OpPrintAdjacencyListValueMapping, // value mapping
Operator::SimpleSelect, // trivial selection function
OpPrintAdjacencyListTypeMap // type mapping
);
/*
5 Creating the ~NetworkAlgebra~
*/
class NetworkAlgebra : public Algebra
{
public:
NetworkAlgebra() : Algebra()
{
AddTypeConstructor ( &network );
AddTypeConstructor ( &gpoint );
AddTypeConstructor ( &gline );
AddTypeConstructor ( &gpoints );
gpoint.AssociateKind ( Kind::DATA() );
gline.AssociateKind ( Kind::DATA() );
network.AssociateKind ( Kind::NETWORK() );
gpoints.AssociateKind ( Kind::DATA() );
AddOperator ( &networkthenetwork );
AddOperator ( &networkroutes );
AddOperator ( &networkjunctions );
AddOperator ( &networksections );
AddOperator ( &shortest_path );
AddOperator ( &networklength );
AddOperator ( &networknetdistance );
AddOperator ( &point2gpoint );
AddOperator ( &gpoint2point );
AddOperator ( &netgpequal );
AddOperator ( &sline2gline );
AddOperator ( &networkinside );
AddOperator ( &networknocomponents );
AddOperator ( &polygpoints );
AddOperator ( &networkrouteintervals );
AddOperator ( &networkintersects );
AddOperator ( &networkgpoint2rect );
AddOperator ( &networkgline2line );
AddOperator ( &networkisempty );
AddOperator ( &networkunion );
AddOperator ( &networkdistance );
AddOperator ( &update_sectioncost);
AddOperator ( &update_sectionduration);
AddOperator ( &shortestpath_astarplus);
AddOperator ( &optimizenet);
AddOperator ( &print_adjacencylist);
}
~NetworkAlgebra() {delete netList;};
};
/*
Initialization
Each algebra module needs an initialization function. The algebra manager
has a reference to this function if this algebra is included in the list
of required algebras, thus forcing the linker to include this module.
The algebra manager invokes this function to get a reference to the instance
of the algebra class and to provide references to the global nested list
container (used to store constructor, type, operator and object information)
and to the query processor.
The function has a C interface to make it possible to load the algebra
dynamically at runtime.
*/
extern "C"
Algebra*
InitializeNetwork2Algebra ( NestedList* nlRef,
QueryProcessor* qpRef )
{
nl = nlRef;
qp = qpRef;
netList = new map<int,string>();
return ( new NetworkAlgebra() );
}
Reference in New Issue View Git Blame Copy Permalink