456 lines
17 KiB
Plaintext
456 lines
17 KiB
Plaintext
|
|
################################################################################
|
|
## File: CreateNetwork Objects #################################################
|
|
################################################################################
|
|
## This file is part of SECONDO. ##
|
|
## ##
|
|
## Copyright (C) 2010, University in Hagen, Faculty of Mathematics and ##
|
|
## 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 ##
|
|
################################################################################
|
|
|
|
# This file performs translates the spatial and spatio-temporal data objects #
|
|
# of the BerlinMOD benchmark in the Secondo DBMS into their network data #
|
|
# model representation and builds the aCCording indexes. #
|
|
# #
|
|
# It is assumed that there is a database berlinmod with the data objects #
|
|
# created by the BerlinMOD_DataGenerator.SEC script. #
|
|
# #
|
|
################################################################################
|
|
# #
|
|
# Open Database Berlinmod #
|
|
# #
|
|
################################################################################
|
|
|
|
open database berlinmod;
|
|
|
|
################################################################################
|
|
# #
|
|
# Build a JNetwork From Streets Data. #
|
|
# #
|
|
################################################################################
|
|
|
|
let RoadsTmp =
|
|
streets feed
|
|
projectextend[GeoData; VMax: ifthenelse(.Vmax > 0.0, .Vmax, 0.01)]
|
|
projectextendstream[VMax; RoadCurve: .GeoData polylines[FALSE]]
|
|
projectextend[VMax; RoadC: fromline(.RoadCurve)]
|
|
projectextend[VMax; Lenth: size(.RoadC), RoadCurve: .RoadC]
|
|
sortby[Lenth desc, VMax asc, RoadCurve asc]
|
|
addcounter[Rid, 1]
|
|
project[Rid, RoadCurve, VMax, Lenth]
|
|
consume;
|
|
|
|
let RoadEndPoints =
|
|
RoadsTmp feed
|
|
projectextend[Rid, RoadCurve; StartPoint: getstartpoint(.RoadCurve),
|
|
EndPoint: getendpoint(.RoadCurve)]
|
|
consume;
|
|
|
|
let RoadCrossings =
|
|
RoadsTmp feed project[Rid, RoadCurve] {r1}
|
|
RoadsTmp feed project[Rid, RoadCurve] {r2}
|
|
itSpatialJoin[RoadCurve_r1, RoadCurve_r2, 4,8]
|
|
filter [.Rid_r1 < .Rid_r2]
|
|
filter [.RoadCurve_r1 intersects .RoadCurve_r2]
|
|
projectextendstream[Rid_r1, Rid_r2, RoadCurve_r1,
|
|
RoadCurve_r2; CROSSING: components(crossings(.RoadCurve_r1, .RoadCurve_r2))]
|
|
projectextend[;R1id: .Rid_r1,
|
|
R1Pos: atpoint(.RoadCurve_r1, .CROSSING),
|
|
R2id: .Rid_r2,
|
|
R2Pos: atpoint(.RoadCurve_r2, .CROSSING),
|
|
SpatialPos: .CROSSING]
|
|
consume;
|
|
|
|
let JunctionsTmp =
|
|
( (RoadEndPoints feed
|
|
projectextend [; Pos: .StartPoint])
|
|
(RoadEndPoints feed
|
|
projectextend [; Pos: .EndPoint])
|
|
concat)
|
|
(RoadCrossings feed
|
|
projectextend[; Pos: .SpatialPos])
|
|
concat
|
|
sortby[Pos]
|
|
rdup
|
|
addcounter[Jid, 1]
|
|
project[Jid, Pos]
|
|
consume;
|
|
|
|
let RoadsTmp2 =
|
|
RoadsTmp feed
|
|
JunctionsTmp feed
|
|
itSpatialJoin[RoadCurve, Pos, 4,8]
|
|
filter[.Pos inside .RoadCurve]
|
|
projectextend[Rid, VMax, Lenth, RoadCurve, Jid; SpatialPos: .Pos,
|
|
RoadPos: atpoint(.RoadCurve,.Pos)]
|
|
consume;
|
|
|
|
let RoadsTmp3 =
|
|
RoadsTmp2 feed
|
|
filter [iscycle(.RoadCurve)]
|
|
filter [.RoadPos = 0.0]
|
|
projectextend[Rid, VMax, Lenth, RoadCurve, Jid, SpatialPos; RoadPos: size(.RoadCurve)]
|
|
consume;
|
|
|
|
let RoadsTmp4 =
|
|
RoadsTmp2 feed
|
|
filter [iscycle(.RoadCurve)]
|
|
filter [.RoadPos = size(.RoadCurve)]
|
|
projectextend[Rid, VMax, Lenth, RoadCurve, Jid, SpatialPos; RoadPos: 0.0]
|
|
consume;
|
|
|
|
let RoadsTmp5 =
|
|
((RoadsTmp3 feed)
|
|
(RoadsTmp4 feed)
|
|
concat)
|
|
(RoadsTmp2 feed)
|
|
concat
|
|
sortby[Rid, RoadPos, Jid, SpatialPos, VMax, Lenth, RoadCurve]
|
|
rdup
|
|
consume;
|
|
|
|
let RoadJuncList =
|
|
RoadsTmp5 feed
|
|
project[Rid, Jid]
|
|
sortby [Rid, Jid]
|
|
rdup
|
|
groupby[Rid; JuncList: group feed projecttransformstream[Jid] createlist]
|
|
consume;
|
|
|
|
let JuncRLocList =
|
|
RoadsTmp5 feed
|
|
projectextend[Jid; RLoc: createrloc(.Rid,.RoadPos,[const jdirection value(Both)])]
|
|
sortby[Jid, RLoc]
|
|
rdup
|
|
groupby[Jid; RLocList: group feed projecttransformstream[RLoc] createlist]
|
|
consume;
|
|
|
|
let SectTmp =
|
|
RoadsTmp5 feed
|
|
project[Rid, RoadCurve, SpatialPos]
|
|
sortby[Rid, RoadCurve, SpatialPos]
|
|
groupby[Rid, RoadCurve; SplitPoints: group feed projecttransformstream[SpatialPos] collect_points[TRUE]]
|
|
projectextendstream[Rid; SectCurve: splitslineatpoints(.RoadCurve,.SplitPoints)]
|
|
extend[StartPoint: getstartpoint(.SectCurve),
|
|
EndPoint: getendpoint(.SectCurve),
|
|
Lenth: size(.SectCurve),
|
|
JDir: [const jdirection value(Both)]]
|
|
JunctionsTmp feed {j1}
|
|
itSpatialJoin[StartPoint,Pos_j1,4,8]
|
|
filter[.StartPoint = .Pos_j1]
|
|
projectextend[Rid, SectCurve, EndPoint, Lenth, JDir; StartJid: .Jid_j1]
|
|
JunctionsTmp feed {j2}
|
|
itSpatialJoin[EndPoint,Pos_j2,4,8]
|
|
filter[.EndPoint = .Pos_j2]
|
|
projectextend[Rid, SectCurve, Lenth, JDir, StartJid; EndJid: .Jid_j2]
|
|
RoadsTmp5 feed {r1}
|
|
hashjoin[Rid, Rid_r1]
|
|
filter [.Rid = .Rid_r1]
|
|
filter [.StartJid = .Jid_r1]
|
|
projectextend[Rid, SectCurve, Lenth, JDir, StartJid, EndJid; VMax: .VMax_r1,
|
|
StartPos: .RoadPos_r1]
|
|
RoadsTmp5 feed {r2}
|
|
hashjoin[Rid, Rid_r2]
|
|
filter [.Rid = .Rid_r2]
|
|
filter [.EndJid = .Jid_r2]
|
|
projectextend[Rid, SectCurve, Lenth, JDir, StartJid, EndJid, VMax,
|
|
StartPos; EndPos: .RoadPos_r2]
|
|
sortby[Rid, StartJid, EndJid, Lenth, VMax, JDir, SectCurve, StartPos, EndPos]
|
|
filter[.StartPos < .EndPos]
|
|
rdup
|
|
addcounter[Sid,1]
|
|
consume;
|
|
|
|
let RoadSectList =
|
|
SectTmp feed
|
|
project[Rid, Sid]
|
|
sortby[Rid, Sid]
|
|
groupby[Rid; ListSect: group feed projecttransformstream[Sid] createlist]
|
|
consume;
|
|
|
|
let SectRouteIntervals =
|
|
SectTmp feed
|
|
projectextend [Sid; RInt: createrint(.Rid, .StartPos, .EndPos, .JDir)]
|
|
sortby [Sid, RInt]
|
|
groupby [Sid; ListRInt: group feed projecttransformstream[RInt] createlist]
|
|
consume;
|
|
|
|
let JuncInAndOutList =
|
|
(SectTmp feed
|
|
projectextend [Sid; Jid: .StartJid])
|
|
(SectTmp feed
|
|
projectextend [Sid; Jid: .EndJid])
|
|
concat
|
|
sortby [Jid, Sid]
|
|
rdup
|
|
groupby[Jid; ListInOutSect: group feed projecttransformstream[Sid] createlist]
|
|
consume;
|
|
|
|
let InJunc =
|
|
JunctionsTmp feed
|
|
JuncRLocList feed {r1}
|
|
hashjoin[Jid, Jid_r1]
|
|
filter [.Jid = .Jid_r1]
|
|
projectextend [Jid, Pos; ListRLoc: .RLocList_r1]
|
|
JuncInAndOutList feed {sl}
|
|
hashjoin[Jid, Jid_sl]
|
|
filter [.Jid = .Jid_sl]
|
|
projectextend[Jid, Pos, ListRLoc; ListInSect: .ListInOutSect_sl,
|
|
ListOutSect: .ListInOutSect_sl]
|
|
sortby[Jid, Pos, ListRLoc, ListInSect, ListOutSect]
|
|
rdup
|
|
consume;
|
|
|
|
let InSect =
|
|
SectTmp feed
|
|
SectRouteIntervals feed {ri}
|
|
hashjoin[Sid, Sid_ri]
|
|
filter [.Sid = .Sid_ri]
|
|
projectextend[Sid, SectCurve, StartJid, EndJid, JDir, VMax, Lenth; ListRint: .ListRInt_ri]
|
|
InJunc feed {j1}
|
|
hashjoin[StartJid, Jid_j1]
|
|
filter[.StartJid = .Jid_j1]
|
|
projectextend[Sid, SectCurve, StartJid, EndJid, JDir, VMax, Lenth,
|
|
ListRint; ListAdjSectDown: .ListOutSect_j1,
|
|
ListRevAdjSectUp: .ListInSect_j1]
|
|
InJunc feed {j2}
|
|
hashjoin[EndJid, Jid_j2]
|
|
filter[.EndJid = .Jid_j2]
|
|
projectextend[Sid, SectCurve, StartJid, EndJid, JDir, VMax, Lenth,
|
|
ListRint, ListAdjSectDown,
|
|
ListRevAdjSectUp; ListAdjSectUp: .ListOutSect_j2,
|
|
ListRevAdjSectDown: .ListInSect_j2]
|
|
project[Sid, SectCurve, StartJid, EndJid, JDir, VMax, Lenth, ListRint, ListAdjSectUp,
|
|
ListAdjSectDown, ListRevAdjSectUp, ListRevAdjSectDown]
|
|
sortby [Sid, StartJid, EndJid, SectCurve, JDir, VMax, Lenth, ListRint, ListAdjSectUp, ListAdjSectDown, ListRevAdjSectUp, ListRevAdjSectDown]
|
|
rdup
|
|
consume;
|
|
|
|
let InRoad =
|
|
RoadsTmp feed
|
|
RoadJuncList feed {j1}
|
|
hashjoin[Rid, Rid_j1]
|
|
filter [.Rid = .Rid_j1]
|
|
projectextend[Rid, Lenth; ListJunc: .JuncList_j1]
|
|
RoadSectList feed {s1}
|
|
hashjoin[Rid, Rid_s1]
|
|
projectextend[Rid, ListJunc, Lenth; ListSect: .ListSect_s1]
|
|
project[Rid, ListJunc, ListSect, Lenth]
|
|
sortby [Rid, ListJunc, ListSect, Lenth]
|
|
rdup
|
|
consume;
|
|
|
|
query createjnet("JBNet", 1.0, InJunc, InSect, InRoad);
|
|
|
|
################################################################################
|
|
# #
|
|
# Translate QueryPoint Set into Newtork Representation #
|
|
# #
|
|
################################################################################
|
|
|
|
|
|
let QueryPointsJNet =
|
|
QueryPoints feed
|
|
projectextend[Id; Pos: tonetwork(JBNet, .Pos)]
|
|
consume;
|
|
|
|
let QueryPointsJNetAll =
|
|
QueryPointsJNet feed
|
|
projectextendstream[Id; NPos: altrlocs(.Pos)]
|
|
projectextend[Id; Pos: .NPos]
|
|
consume;
|
|
|
|
let QueryPoints1JNet =
|
|
QueryPoints feed head[10]
|
|
projectextend[Id; Pos: tonetwork(JBNet, .Pos)]
|
|
consume;
|
|
|
|
let QueryPoints1JNetAll =
|
|
QueryPoints1JNet feed
|
|
projectextendstream[Id; NPos: altrlocs(.Pos)]
|
|
projectextend[Id; Pos: .NPos]
|
|
consume;
|
|
|
|
################################################################################
|
|
# #
|
|
# Translate QueryRegions into Network Representation #
|
|
# #
|
|
################################################################################
|
|
|
|
let routeslinej =
|
|
components(sections(JBNet) feed
|
|
projectextend[;Curve: toline(.Curve)]
|
|
aggregateB[Curve; fun(L1: line, L2: line) union_new(L1, L2); [const line value()]])
|
|
transformstream
|
|
extend[NoSeg: no_segments(.Elem)]
|
|
sortby [NoSeg desc]
|
|
extract [Elem];
|
|
|
|
let QRlinesj =
|
|
QueryRegions feed
|
|
projectextend [Id; Lr: intersection_new(.Region, routeslinej)]
|
|
consume;
|
|
|
|
let QueryRegionsJNet =
|
|
QRlinesj feed
|
|
projectextend[Id; Region: tonetwork(JBNet, .Lr)]
|
|
consume;
|
|
|
|
################################################################################
|
|
# #
|
|
# Translate Trips into Network Representation #
|
|
# #
|
|
################################################################################
|
|
|
|
let dataSJcar = dataScar feed
|
|
projectextend[Licence, Model, Type; Trip: tonetwork(JBNet, .Trip)]
|
|
consume;
|
|
|
|
let dataMJtrip =
|
|
dataMtrip feed
|
|
projectextend [Moid; Trip: tonetwork(JBNet, .Trip)]
|
|
consume;
|
|
|
|
|
|
################################################################################
|
|
# #
|
|
# Build Network Indexes #
|
|
# #
|
|
################################################################################
|
|
# #
|
|
# B-Tree indexes for licences in dataScar, and dataMtrip, and for moIds in #
|
|
# dataMcar and dataMNtrip. #
|
|
# #
|
|
################################################################################
|
|
|
|
derive dataSJcar_Licence_btree = dataSJcar createbtree[Licence];
|
|
|
|
derive dataMcar_Licence_btree = dataMcar createbtree[Licence];
|
|
|
|
derive dataMcar_Moid_btree = dataMcar createbtree[Moid];
|
|
|
|
derive dataMJtrip_Moid_btree = dataMJtrip createbtree[Moid];
|
|
|
|
################################################################################
|
|
# #
|
|
# Temporal Network Position Indexes (TNPI) and Network Position Indexes (NPI) #
|
|
# for dataMNtrip and dataSNcar #
|
|
# #
|
|
################################################################################
|
|
|
|
derive dataSJcar_BoxNet_timespace =
|
|
dataSJcar feed
|
|
extend[TID: tupleid(.)]
|
|
projectextendstream[TID; UTrip: units(.Trip)]
|
|
extend[Box: tempnetbox(.UTrip)]
|
|
sortby[Box asc]
|
|
bulkloadrtree[Box];
|
|
|
|
derive dataMJtrip_BoxNet_timespace =
|
|
dataMJtrip feed
|
|
extend[TID: tupleid(.)]
|
|
projectextendstream[TID; UTrip: units(.Trip)]
|
|
extend[Box: tempnetbox(.UTrip)]
|
|
sortby[Box asc]
|
|
bulkloadrtree[Box];
|
|
|
|
derive dataSJcar_BoxNet =
|
|
dataSJcar feed
|
|
extend[TID: tupleid(.)]
|
|
projectextendstream[TID; UTrip: units(.Trip)]
|
|
extend[Box: netbox(.UTrip)]
|
|
sortby [Box asc]
|
|
bulkloadrtree[Box];
|
|
|
|
derive dataMJtrip_BoxNet =
|
|
dataMJtrip feed
|
|
extend[TID: tupleid(.)]
|
|
projectextendstream[TID; UTrip: units(.Trip)]
|
|
extend[Box: netbox(.UTrip)]
|
|
sortby [Box asc]
|
|
bulkloadrtree[Box];
|
|
|
|
derive dataSJcar_TrajBoxNet =
|
|
dataSJcar feed
|
|
extend[TID: tupleid(.)]
|
|
projectextendstream[TID; RInt: units(trajectory(.Trip))]
|
|
projectextend[TID; Box: netbox(.RInt)]
|
|
sortby[Box asc]
|
|
bulkloadrtree[Box];
|
|
|
|
derive dataMJtrip_TrajBoxNet =
|
|
dataMJtrip feed
|
|
extend[TID: tupleid(.)]
|
|
projectextendstream[TID; RInt: units(trajectory(.Trip))]
|
|
projectextend[TID; Box: netbox(.RInt)]
|
|
sortby[Box asc]
|
|
bulkloadrtree[Box];
|
|
|
|
################################################################################
|
|
# #
|
|
# Spatio-Temporal Index for dataMNtrip #
|
|
# #
|
|
################################################################################
|
|
|
|
derive dataMJtrip_SpatioTemp =
|
|
dataMJtrip feed
|
|
extend[TID: tupleid(.)]
|
|
projectextend[TID; Box: bbox(.Trip)]
|
|
sortby [Box asc]
|
|
bulkloadrtree[Box];
|
|
|
|
#derive dataMJtrip_SpatioTemp_Units =
|
|
# dataMJtrip feed
|
|
# extend[TID: tupleid(.)]
|
|
# projectextendstream[TID; UTrip: units(.Trip)]
|
|
# extend[Box: bbox(.UTrip)]
|
|
# sortby[Box asc]
|
|
#bulkloadrtree[Box];
|
|
|
|
#derive dataSJtrip_SpatioTemp_units =
|
|
# dataSJcar feed
|
|
# extend[TID: tupleid(.)]
|
|
# projectextendstream[TID; UTrip: units(.Trip)]
|
|
# extend[Box: bbox(.UTrip)]
|
|
# sortby[Box asc]
|
|
#bulkloadrtree[Box];
|
|
|
|
################################################################################
|
|
# #
|
|
# Often used Query Object Relations #
|
|
# #
|
|
################################################################################
|
|
|
|
let QueryLicences1 = QueryLicences feed head[10] consume;
|
|
|
|
let QueryLicences2 = QueryLicences feed head[20] filter [.Id > 10] consume;
|
|
|
|
let QueryPeriods1 = QueryPeriods feed head[10] consume;
|
|
|
|
let QueryInstant1 = QueryInstants feed head[10] consume;
|
|
|
|
let QueryRegions1JNet = QueryRegionsJNet feed head[10] consume;
|
|
|
|
################################################################################
|
|
# #
|
|
# Finished Close Database #
|
|
# #
|
|
################################################################################
|
|
|
|
close database;
|
|
|