300 lines
8.4 KiB
C++
300 lines
8.4 KiB
C++
/*
|
|
----
|
|
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}}]
|
|
//[TOC] [\tableofcontents]
|
|
|
|
[1] Header File for Creating Bus network::Network
|
|
|
|
July, 2011 Jianqiu xu
|
|
|
|
[TOC]
|
|
|
|
1 Overview
|
|
|
|
2 Defines and includes
|
|
|
|
*/
|
|
|
|
#ifndef Road_Network_H
|
|
#define Road_Network_H
|
|
|
|
|
|
#include "Algebra.h"
|
|
|
|
#include "NestedList.h"
|
|
|
|
#include "QueryProcessor.h"
|
|
#include "Algebras/RTree/RTreeAlgebra.h"
|
|
#include "Algebras/BTree/BTreeAlgebra.h"
|
|
#include "Algebras/Temporal/TemporalAlgebra.h"
|
|
#include "StandardTypes.h"
|
|
#include "LogMsg.h"
|
|
#include "NList.h"
|
|
#include "Algebras/Relation-C++/RelationAlgebra.h"
|
|
#include "ListUtils.h"
|
|
#include "Algebras/Network/NetworkAlgebra.h"
|
|
#include "Algebras/Spatial/SpatialAlgebra.h"
|
|
|
|
#include <fstream>
|
|
#include <stack>
|
|
#include <vector>
|
|
#include <queue>
|
|
#include "Attribute.h"
|
|
#include "Tools/Flob/DbArray.h"
|
|
#include "Tools/Flob/Flob.h"
|
|
#include "WinUnix.h"
|
|
#include "AvlTree.h"
|
|
#include "Symbols.h"
|
|
#include "Partition.h"
|
|
#include "PaveGraph.h"
|
|
#include "GeneralType.h"
|
|
|
|
struct GP_Point;
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
///////////////////road network::Network graph///////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
a node corresponds to a junction
|
|
two junctions are connected by
|
|
(1) the same location on space
|
|
(2) route segments of one route (the two junctions belong to one route)
|
|
|
|
at this movement (2011.7.26) we assume each road has both up and down directions
|
|
so that for a network::GPoint it can go either direction along the route.
|
|
but it is no problem to extend that if network::GPoint has up or down value,
|
|
then only
|
|
one direction is available
|
|
|
|
*/
|
|
class RoadGraph{
|
|
public:
|
|
RoadGraph();
|
|
RoadGraph(ListExpr in_xValue,int in_iErrorPos,
|
|
ListExpr& inout_xErrorInfo,
|
|
bool& inout_bCorrect);
|
|
|
|
RoadGraph(SmiRecord&, size_t&, const ListExpr);
|
|
|
|
~RoadGraph();
|
|
|
|
static std::string RGNodeTypeInfo;
|
|
static std::string RGBTreeNodeTypeInfo;
|
|
static std::string RGEdgeTypeInfo1;
|
|
static std::string RGEdgeTypeInfo2;
|
|
|
|
enum RG_NODE{RG_JUN_ID, RG_JUN_GP, RG_JUN_P, RG_ROAD_ID};
|
|
enum RG_EDGE1{RG_JUN1, RG_JUN2};
|
|
enum RG_EDGE2{RG_JUN_1, RG_JUN_2, RG_PATHA1, RG_PATH2};
|
|
|
|
static ListExpr RoadGraphProp();
|
|
static bool CheckRoadGraph(ListExpr type, ListExpr& errorInfo);
|
|
static int SizeOfRoadGraph();
|
|
static void* CastRoadGraph(void* addr);
|
|
static Word CloneRoadGraph(const ListExpr typeInfo, const Word& w);
|
|
static void CloseRoadGraph(const ListExpr typeInfo, Word& w);
|
|
static Word CreateRoadGraph(const ListExpr typeInfo);
|
|
static void DeleteRoadGraph(const ListExpr typeInfo, Word& w);
|
|
|
|
static bool SaveRoadGraph(SmiRecord& valueRecord, size_t& offset,
|
|
const ListExpr typeInfo, Word& value);
|
|
|
|
bool Save(SmiRecord& in_xValueRecord,size_t& inout_iOffset,
|
|
const ListExpr in_xTypeInfo);
|
|
|
|
static bool OpenRoadGraph(SmiRecord& valueRecord, size_t& offset,
|
|
const ListExpr typeInfo, Word& value);
|
|
static RoadGraph* Open(SmiRecord& valueRecord,size_t& offset,
|
|
const ListExpr typeInfo);
|
|
|
|
static Word InRoadGraph(ListExpr in_xTypeInfo,
|
|
ListExpr in_xValue,
|
|
int in_iErrorPos, ListExpr& inout_xErrorInfo,
|
|
bool& inout_bCorrect);
|
|
|
|
static ListExpr OutRoadGraph(ListExpr typeInfo, Word value);
|
|
ListExpr Out(ListExpr typeInfo);
|
|
|
|
unsigned int GetRG_ID(){return rg_id;}
|
|
void Load(int, Relation*, Relation*, Relation*);
|
|
void LoadEdge1(Relation* rel);
|
|
void LoadEdge2(Relation* rel);
|
|
|
|
Relation* GetNode_Rel(){return node_rel;}
|
|
Relation* GetEdge_Rel1(){return edge_rel1;}
|
|
Relation* GetEdge_Rel2(){return edge_rel2;}
|
|
|
|
|
|
void FindAdj1(int node_id, std::vector<int>& list);
|
|
void FindAdj2(int node_id, std::vector<int>& list);
|
|
|
|
void GetJunctionsNode(int rid, std::vector<GP_Point>& res_list);
|
|
|
|
|
|
private:
|
|
|
|
unsigned int rg_id;//road graph id
|
|
Relation* node_rel;//node relation
|
|
|
|
BTree* btree_node;
|
|
|
|
Relation* edge_rel1;
|
|
DbArray<int> adj_list1;
|
|
DbArray<ListEntry> entry_adj_list1;
|
|
|
|
Relation* edge_rel2;
|
|
DbArray<int> adj_list2;
|
|
DbArray<ListEntry> entry_adj_list2;
|
|
|
|
};
|
|
|
|
|
|
/*
|
|
for shortest path searching in road graph
|
|
|
|
*/
|
|
struct RNPath_elem:public Path_elem{
|
|
double weight;
|
|
double real_w;
|
|
network::RouteInterval ri;
|
|
|
|
bool len; //same spatial location or not
|
|
Point to_loc;
|
|
|
|
RNPath_elem(){}
|
|
RNPath_elem(int p, int c, int t, double w1, double w2,
|
|
network::RouteInterval& i,
|
|
bool b, Point loc):Path_elem(p, c, t), weight(w1), real_w(w2),
|
|
ri(i), len(b), to_loc(loc){}
|
|
RNPath_elem(const RNPath_elem& wp):Path_elem(wp),
|
|
weight(wp.weight),real_w(wp.real_w),
|
|
ri(wp.ri), len(wp.len), to_loc(wp.to_loc){}
|
|
RNPath_elem& operator=(const RNPath_elem& wp)
|
|
{
|
|
Path_elem::operator=(wp);
|
|
weight = wp.weight;
|
|
real_w = wp.real_w;
|
|
ri = wp.ri;
|
|
len = wp.len;
|
|
to_loc = wp.to_loc;
|
|
return *this;
|
|
}
|
|
bool operator<(const RNPath_elem& ip) const
|
|
{
|
|
return weight > ip.weight;
|
|
}
|
|
|
|
void Print()
|
|
{
|
|
cout<<" tri_index " <<tri_index<<" realweight "<<real_w
|
|
<<" weight "<<weight<<endl;
|
|
ri.Print(cout);
|
|
}
|
|
|
|
};
|
|
|
|
struct GPoint_Dist{
|
|
network::GPoint gp;
|
|
Point p;
|
|
double dist;
|
|
GPoint_Dist(){}
|
|
GPoint_Dist(network::GPoint& p1, Point& p2, double d):gp(p1), p(p2), dist(d){}
|
|
GPoint_Dist(const GPoint_Dist& gpd):gp(gpd.gp), p(gpd.p), dist(gpd.dist){}
|
|
GPoint_Dist& operator=(const GPoint_Dist& gpd)
|
|
{
|
|
gp = gpd.gp;
|
|
dist = gpd.dist;
|
|
p = gpd.p;
|
|
return *this;
|
|
}
|
|
|
|
bool operator<(const GPoint_Dist& gpd) const
|
|
{
|
|
return dist < gpd.dist;
|
|
}
|
|
void Print()
|
|
{
|
|
cout<<gp<<endl;
|
|
cout<<p<<" "<<dist<<endl;
|
|
}
|
|
|
|
};
|
|
|
|
/*
|
|
query processing on the road graph
|
|
|
|
*/
|
|
struct RoadNav{
|
|
|
|
|
|
std::vector<SimpleLine> path_list;
|
|
std::vector<network::GLine> gline_list;
|
|
|
|
std::vector<network::GPoint> jun_list1;
|
|
std::vector<network::GPoint> jun_list2;
|
|
std::vector<int> type_list;
|
|
|
|
|
|
unsigned int count;
|
|
TupleType* resulttype;
|
|
|
|
RoadNav(){count = 0; resulttype = NULL;}
|
|
|
|
|
|
~RoadNav(){if(resulttype != NULL) resulttype->DeleteIfAllowed();}
|
|
|
|
void GenerateRoadLoc(network::Network* rn, int no,
|
|
std::vector<network::GPoint>& gp_list,
|
|
std::vector<Point>& gp_loc_list);
|
|
void ShortestPath(network::GPoint*, network::GPoint*, RoadGraph*,
|
|
network::Network*, network::GLine* res);
|
|
|
|
void ShortestPathSub(network::GPoint*, network::GPoint*, RoadGraph*,
|
|
network::Network*, network::GLine* res);
|
|
|
|
void ShortestPath2(network::GPoint*, network::GPoint*, RoadGraph*,
|
|
network::Network*, network::GLine* res);
|
|
void ShortestPathSub2(network::GPoint*, network::GPoint*, RoadGraph*,
|
|
network::Network*, network::GLine* res);
|
|
void DFTraverse(network::Network* rn, R_Tree<2,TupleId>* rtree,
|
|
SmiRecordId adr,
|
|
SimpleLine* line, std::vector<GPoint_Dist>& id_list);
|
|
|
|
void ShortestPathSub3(network::GPoint*, network::GPoint*, RoadGraph*,
|
|
network::Network*, network::GLine* res);
|
|
void GetAdjNodeRG(RoadGraph* rg, int nodeid);
|
|
|
|
|
|
};
|
|
|
|
#define LOOP_PRINT1(s) for(unsigned int i = 0; i < s.size();i++){ \
|
|
cout<<i<<" "<<s[i]<<endl;\
|
|
}
|
|
|
|
#define LOOP_PRINT2(s) for(unsigned int i = 0; i < s.size();i++){ \
|
|
s[i].Print(); \
|
|
}
|
|
|
|
#endif
|