-
Contents lists available at ScienceDirectInformation Systems
Information Systems 38 (2013) 126912840306-43
doi:10.1
n Corr
E-m
gereon.
monika1 Tejournal homepage:
www.elsevier.com/locate/infosysEfficient tracking of moving objects
using arelational databaseAndreas Behrend a,1, Gereon Schuller b,n,
Monika Wieneke b
a University of Bonn, Romerstrae 164, 53117 Bonn, Germanyb
Fraunhofer FKIE, Neuenahrer Strae 20, 53343 Wachtberg, Germanya r t
i c l e i n f o
Available online 21 January 2012
Keywords:
Moving objects
Data streams
Sensor data
Incremental evaluation
Update propagation79/$ - see front matter & 2012 Elsevier
Ltd. A
016/j.is.2012.01.001
esponding author. Tel.: 49 228 9435 484; fax:ail addresses:
[email protected] (A. Be
[email protected] (G. Schuller),
[email protected] (M. Wieneke).
l.: 49 228 73 4533; fax: 49 228 73 4382a b s t r a c t
Tracking uncooperative moving objects by means of radar is a
complex task due to
clutter and association problems in multi-target scenarios. An
approach to solve this
problem is probabilistic multiple hypothesis tracking (PMHT).
This method combines
classical track filtering with a likelihood ratio test for the
estimation of the plot-to-track
association. The basics of PMHT and similar algorithms have
gained much attention
recently. However, the efficient implementation of real world
applications of this
technique still represents a challenging task. Since a common
requirement in this
context is the reliable storage of track data in a database, an
implementation of the
trackers calculation inside a database management system (DBMS)
using SQL views is
desirable. A naive implementation of PMHT using a commercial
DBMS, however,
usually leads to performance problems because of the high
frequency of measurement
updates. In this paper, we propose possible optimizations for
solving these performance
problems. Their usage leads to a dramatic run-time improvement
in our sample case
and makes the implementation of PMHT in a database context
feasible.
& 2012 Elsevier Ltd. All rights reserved.1. Introduction
Monitoring moving objects is a task that has a widespectrum of
applications and becomes more and moreimportant nowadays. Many
kinds of sensors for detectingmoving objects have been developed,
e.g., GPS, radarsensors or laser scanners and various tracking
algorithmshave been developed in order to follow object motions.The
research area of moving object databases has emerged,investigating
how to store and access the vast amount ofdata gained in such
tracking scenarios.
Tracking represents a complicated task because ofmeasurement
errors and association problems which arell rights reserved.
49 228 9435 685.hrend),
.
generally solved by using stochastic methods. The under-lying
probabilistic calculations are usually implementedoutside the
database system where the underlying sensorinformation is actually
stored. The reason for this istwofold: first, SQL queries seem to
be inappropriate forimplementing probabilistic computations
occurring intracking algorithms based on hypothesis testing.
Second,tracking algorithms are usually applied to fast
changingsensor data. This implies costly reevaluations of
SQLqueries employed for track analysis.
In the following, we consider a military scenario wherean
unknown number of uncooperative moving objects hasto be detected
and monitored. In a military context, theprovenance of all
derivations as well as the reliablestorage of all measured and
derived data is of crucialimportance. The usage of a database
management system(DBMS) and the application of SQL views to the
stream ofsensor data is a possible solution to this task. However,
anefficient solution is necessary for implementing a tracking
www.elsevier.com/locate/infosyswww.elsevier.com/locate/infosysdx.doi.org/10.1016/j.is.2012.01.001http://crossmark.dyndns.org/dialog/?doi=10.1016/j.is.2012.01.001&domain=pdfhttp://crossmark.dyndns.org/dialog/?doi=10.1016/j.is.2012.01.001&domain=pdfhttp://crossmark.dyndns.org/dialog/?doi=10.1016/j.is.2012.01.001&domain=pdfmailto:[email protected]:[email protected]:[email protected]:[email protected]/10.1016/j.is.2012.01.001
-
A. Behrend et al. / Information Systems 38 (2013)
126912841270algorithm using SQL views. To show how an
optimizedtracking algorithm can be implemented in SQL, we use
theprobabilistic multiple hypothesis tracking approach(PMHT) [40].
The task of PMHT is to determine the tracksof multiple objects from
a cluttered area by using a time-series of (potentially
inaccurately) measured positionscoming from a radar system. Another
issue is distinguish-ing false from true tracks while number of
moving targetsis unknown. This is why we consider an extended
versionof the PMHT framework with an integrated
sequentiallikelihood test for estimating the number of objects
asproposed in [44,45].
Aside from transaction control, this solution evenallows to
enhance the tracking process by additionalcontext information. For
instance, an internal DBMSsolution can predict the occurrence of a
landing airplaneby combining tracks with stored information about
air-port locations. In addition, it is possible to
classifymonitored objects with respect to their velocity
andmovement history: objects moving at high speed withhigh turning
angles can be classified as unarmed fighterjets whereas low turning
angles may indicate armed jetsor civil aircrafts. In ground
scenarios, this database solu-tion allows for combining track data
with geographicinformation to enhance tracking quality.
Conversely,tracking information can excel the knowledge
aboutterrain data. For instance, the position of roads
(whereobjects accumulate) or tunnels (where objects are sha-dowed)
can be derived from the occurrence of tracks.
In this paper, we show how the PMHT approach can beimplemented
using SQL views. The resulting statementscan be considered
continuous queries of considerablecomplexity which have to be
re-evaluated as soon as newdata arrive. However, these expensive
recomputations leadto an impractical solution with superlinear
runtime. There-fore, we propose to materialize the results of the
underlyingcontinuous queries and to recompute the respective
prob-ability values by means of specialized update statements.To
this end, these statements are activated by triggerswhich refer to
the changes in the underlying tables (cf.Section 5). Since a great
portion of the materialized tuplesremains unchanged, the
application of delta views allowedto considerably enhance the
runtime of this type of viewmaintenance. The performance gain
achieved using thisincremental approach is shown in Section 5.3. It
fully scaleswith the amount of data processed and led to a
PMHTimplementation that runs in linear time.
The underlying update propagation (UP) technique hasbeen
intensively studied for many years mainly in thecontext of
integrity checking and materialized view main-tenance [11,23,32].
The application of UP for analyzingdata streams, however, has not
attracted much attentionso far but there is first practical
evidence for its feasibilityin this context [7,8]. In a continuous
query extensionproposal for Oracle [41], UP is used for query
optimiza-tion, underlining the importance of this approach.
Thespecial feature of our update propagation method is thatit even
allows for incrementally maintaining recursiveview specifications
[6].
Methods to update propagation are already availablein commercial
systems such as DB2 or Oracle. The latteroffers the so-called fast
refresh, working with snapshots oftables for updating materialized
views. The current imple-mentations of fast refresh, however,
impose so manyrestrictions on the definitions of SQL views (e.g.,
it is notpossible to apply it to various aggregate queries or
joins)that a PMHT implementation could not be realized thatway.
Another possibility is the direct application ofspecialized data
stream systems (such as StreamBase[39]). However, these systems
currently provide neithertransaction control nor persistent
storage. In addition, ourexperiments indicate that special
optimizations arenecessary in order to obtain an efficient PMHT
imple-mentation in specialized stream systems, too.
The goal of this paper is to demonstrate the feasibilityof an
SQL-based implementation of probabilistic hypoth-esis testing. In
contrast to external approaches, ourflexible declarative solution
is easily modifiable andextendible. It allows for synchronized
multi-user access,and it is robust against system failures because
of theintegrated transaction management. Another contributionof
this paper is the investigation of the possible perfor-mance gain
which can be achieved by using incrementaltechniques for analyzing
data streams. We show that thecombination of conventional database
techniques repre-sents an elegant and feasible way towards solving
aconsiderable spectrum of practical stream analysis pro-blems. The
achieved performance gain, shown in Section5, fully scales with the
amount of data stored and allowedto considerably increase the
updating frequency.
This paper summarizes and extends previous works ofthe authors
presented in [9,44,45]. To this end, a compre-hensive presentation
of intrinsic PMHT methods and theircorresponding implementations
using SQL views is pro-vided, showing our systematic procedure. In
addition, amore elaborate technique for rewriting SQL views
ispresented by means of Magic Updates [6]. This techniqueallows for
optimizing recursive view specifications andhas proven to be
valuable to incrementally evaluate theKalman smother directly
within the underlying databasesystem.
The remainder of the paper is organized as follows: inSection 2
an overview of tracking principles and a deriva-tion of the PMHT
algorithm is given. In Section 3 it isshown how the PMHT algorithm
can be expressed via SQLviews in a first naive approach. Section 4
provides thebasics of the employed incremental calculus for
specializ-ing the naive view definitions from the previous
section.Afterwards, in Section 5 it is shown how the
incrementalcalculus can be applied to the PMHT
implementation.Additionally, performance results are given showing
theimprovements of the refined PMHT implementation.Finally, related
work is presented in Section 6.
2. Tracking
In general, the notion tracking refers to techniques
forfollowing object movements by processing a set of sensorsignals.
A concise example of tracking is following themovement of a person
using our eyes. Unconsciously, weinternally apply a method that,
e.g., allows distinguishingthe person to be followed from a
stationary background
-
A. Behrend et al. / Information Systems 38 (2013) 12691284
1271using optical sensor data. From a technical point of view,there
are plenty of different sensors available such assonar, tactile, or
radar sensors. In this paper we considerradar sensors which provide
positional data, only. Theactual number of moving objects is
assumed to beunknown.
Radar sensors use the reflection of electromagneticwaves from
surfaces to detect stationary or movingobjects. In general, two
kinds of radar mechanisms aredistinguished: primary and secondary.
The so-called sec-ondary radar systems send signals to objects that
answerby sending an own signal in response. Thus, these
systemsestablish a communication between the sensor and
themonitored object, which simplifies its identification andthe
determination of its position. In contrast, primaryradar is usually
employed when the objects to be mon-itored are uncooperative, i.e.,
they do not want or cannotsend signals. In a military scenario
moving persons,driving cars or planes are examples of
uncooperativeobjects for which a track detection is interesting.
Inprimary radar several problems occur: first of all, thenumber of
measured reflections (called plots) is notnecessarily identical to
the number of objects in our fieldof view (FoV). On the one hand,
objects that are in fact inour field of view can remain undetected
because of lowreflectivity or shadowing. On the other hand, there
maybe plots which are not caused by an object of interest.
Forinstance, icy clouds, wind turbines or simply the groundsurface
asperity can reflect radar signals. Plots that do notrepresent
moving objects are called false alerts or (espe-cially if many such
false alerts occur) clutter. The falsealert rate and the
non-detection rate are inversely related,as both depend on a given
detection threshold: if a lowerthreshold is chosen, we get a lower
non-detection prob-ability but a higher false alert rate and vice
versa.
Another problem when analyzing radar data consistsin
inaccuracies of the returned positional measurements.Typically,
radar systems measure the azimuth angle andthe distance to an
object (i.e., given by polar coordinates).Both values may be
distorted and the absolute errorincreases over distance.
Additionally, the merging effectmay occur which means that several
objects closetogether may be detected as a single one by the
radarsystem.
All these effects complicate the tracking process.Instead of
some smoothly moving plots, a radar operatorwatching a graphical
representation on screen sees acloud of plots with some moving
points, probably flashingand trembling. In the past, specially
trained operatorsvisually identified and tracked real objects.
Today,computer programs are employed for detecting movingtargets
and tracking their movements. In this context, twomain problems
have to be solved: inaccurate measure-ments must be corrected as
fast as possible and a justifiedassignment between measurements and
objects has to beestablished.
2.1. State of the art
The problem of automatically tracking multiple objectshas been
subject to research for a long time. There exists amultitude of
applications, in which moving objects areobserved and tracked on
the basis of incoming sensorreports. Typically, those sensor
measurements can beassigned to the constructed and successively
updatedtracks in many ways. Therefore, solving the data assign-ment
problem is the central task for every multi-objecttracking
algorithm. The traditional approaches to multiplehypothesis
tracking (MHT) rely on the complete enumera-tion of all possible
association interpretations of a seriesof measurements [10,36],
which leads to an exponentialgrowth of data. This problem is
avoided by pruning,gating and combining techniques that lead to an
approx-imation of an optimal tracking solution. In any type ofMHT
approximation, the aim is to drastically limit thenumber of
hypotheses by retaining only the most likelyones. The main risk is
to eliminate correct measurementsequences.
Another traditional approach is realized by the
JointProbabilistic Data Association Filter (JPDAF) [5]. TheJPDAF is
an extension of the simple PDAF for the case ofmultiple targets. At
each scan, PDAF combines all possiblehypotheses to one synthetic
hypothesis (Global Combin-ing). It is an efficient technique
because the tracker workson synthetic measurements calculated as
the weightedsum of all single measurements. Hence, it does not
havethe burden of building and managing large hypothesistrees.
However, PDAF models the belief over the targetstates as a single
Gaussian and ignores the multi-modalityof the distribution over the
target states.
A powerful, alternative approach is represented by
Prob-abilistic Multi-Hypothesis Tracking (PMHT)
[17,40,4446].Essentially, PMHT is based on Expectation-Maximization
fordealing with data assignment conflicts. For each trackedobject,
it iteratively applies a Kalman smoother to a slidingdata window,
and thus exploits the information of previousand following scans in
the kinematic state estimation. In amemory efficient manner, PMHT
works on the basis ofsynthetic measurements and therefore. This
avoids the con-struction of a hypothesis branch for every single
measure-ment. From an algorithmic perspective, the
multi-scanproperty and the calculation of synthetic
measurementscould lead to the conclusion that PMHT is a union
ofbeneficial properties of traditional MHT and PDAF. However,the
fundamental difference between PMHT and all otherapproaches is that
PMHT assumes the measurement-to-object assignments to be
stochastically independent randomvariables.
2.2. The PMHT algorithm
To solve the assignment problem, we use the well-established
probabilistic multi-hypothesis approach.Before describing the
respective algorithm, we have toformalize the assignment
problem.
During a tracking scenario the radar sensor periodi-cally
generates an output set zt of measurementst 2 0;1, . . . ,T. As the
number of measurements variesfor each set, we model the measured
data as a pair znt ,Ntwhere Nt denotes the number of measurements
at time t.Each plot znt 2 R
2 with n 2 1 : Nt. For the sake of simpli-city, we assume
Cartesian coordinates, but tracking
-
Fig. 1. Visualization of the uncertainty in object position: the
object islocated somewhere in the 2D-plane while the exact position
is Gaussian
distributed. The z-axis gives the probability for each position,
forming a
bell-shaped curve. While the position at time tk1 can be
estimated with
a low variance, the uncertainty increases over time and
dissipates for the
predicted values tk1 ,tk2.
A. Behrend et al. / Information Systems 38 (2013)
126912841272directly on polar data is straight forward. We denote
thearea observed by the sensor as the Field of View 9FoV9,
thenumber of targets is denoted by S and the kinematic stateof each
target at time t by xst x,y, _x, _y
> 2 R4, the lattercomprising position and velocity data in a
2D-plane.
We assume that the targets move according to thediscrete linear
model
xst1 Fxstv
st 1
while the measurements can be transformed using theequation
yst Hxstw
st 2
where vst and wst denote random sequences that are white,
zero-mean, Gaussian, and mutually independent. In thefollowing
the covariance matrices for the randomsequences are denoted by Q
Efvst ,vs Tt g and R Efwst ,ws Tt g. F is called the state
transition matrix and H is theobservation matrix describing how the
real position xst istransformed to the observation yst . Note that
these trans-formations are linear since our measurements are
Carte-sian. The PMHT algorithm finds the assignments A1:T fat9t 2
0;1, . . . ,Tg where each ant s maps the measure-ment znt to the
target s. By convention, the target s0 is afictitious target
representing clutter. As we do not knowthe correct associations, we
can only estimate whichassociation set fits best, i.e., given a
known series ofmeasurement sets, we have to find the target states
basedon the set of associations that has the highest
probability.Mathematically expressed, we have to solve the
problem
arg maxX
pX9Z 3
To this end, PMHT employs the Expectation-Maximiza-tion (EM)
method. The EM algorithm estimates theunknown object parameters not
given, the so-calledhidden variables [18]. The EM algorithm
alternatesbetween the expectation step (E-step) and the
maximiza-tion step (M-step). Both steps are repeated until the
stateestimates converge, i.e., they do not considerably
changeanymore. The convergence of the algorithm has beenproven,
e.g., in [47].
Let l be the number of the current iteration. First, in
theE-step, we calculate posterior assignment weights wnst l : pant
s9znt ,xst l representing the probability that ameasurement znt
refers to a target s:
wnst l pnst N znt ;Hx
st l,RPS
s0 0 pns0
t N znt ;Hxs0
t l,R4
The weights are calculated for all scans of the current
datawindow at time point t and for all targets s 2 S withrespect to
all measurements zt
nof a certain scan. The
expression N y;m,S denotes the multivariate Gaussiandensity with
random variable y, expectation value m andcovariance S. R again
represents the expectation of therandom sequence wst which
corresponds to the errorcovariance of the measurements. Hence, each
weight isgoverned by the distance between a particular measure-ment
znt and the current state estimate x
st l. The value
pnst : pant s denotes the prior probability that a mea-surement
belongs to a target.Subsequently, the weights are used to form the
weightedsum zstl of all measurements which leads to one
syntheticmeasurement per target and a corresponding
syntheticcovariance R
s
t l at each scan t:
zstl PNt
n 1 wnst lzntPNt
n 1 wnst l
, Rs
tl RPNt
n 1 wnst l
5
After the E-step, the maximization step is applied forenhancing
the state estimates xs1:T l1: during the M-step each track is
updated by means of a KalmanSmoother that processes the synthetic
values. The Kalmansmoother, a filter invented by Rudolf Emil Kalman
in1960, recursively estimates the state of a system givennoisy
measurements. This leads to new, improved stateestimates xs1:T l1
for each target s. After the maximiza-tion step, the E-step is
applied again to the alreadysmoothed state until the parameters of
the probabilitydensity function converge. A representation of the
evolu-tion of the uncertainty in object position is shown inFig.
1.
2.3. Sequential likelihood-ratio testing in PMHT
A disadvantage of the original PMHT algorithm is thatit relies
on the knowledge of the number of targets in theFoV. However, the
number of targets is unknown, incontrast to the number of
measurements. In a recentpaper of our group [45], a sequential
likelihood ratiotesting has been proposed to solve this problem. In
thefollowing we define hypotheses HS as S objects are in thefield
of view and use a sequential likelihood ratio test tofind the most
likely hypothesis. For the sake of simplicity,we consider two
hypotheses H0 (no objects) and H1 (onetarget) only, but the
technique can be applied to anyarbitrary number of hypothesis as
well.
A sequential likelihood test is performed by succes-sively
updating the ratio LR1t between the likelihood ofboth
hypotheses:
LR1t PZ1:T9H1PZ1:T9H0
Pzt9Z1:T ,H1Pzt9Z1:T ,H0
LRt1 6
At each scan t the value LR1t is compared with twothresholds A
and B. If LR1trA holds then hypothesis H0
-
A. Behrend et al. / Information Systems 38 (2013) 12691284
1273is accepted to be true, if LR1tZB holds then hypothesisH1 is
accepted. If the likelihood ratio is somewhere inbetween, then no
decision can be made yet. In thatcase, the algorithm repeats the
test for the next scanon LR1t1. The thresholds A and B have to
bechosen in relation to a acceptable decision error. Thedependency
between decision error and thresholds is asfollows:
A 1P11P0
, B P1P0
7
with
P1 : Probaccept H19H1 8
P0 : Probaccept H19H0 9
The smaller the permitted error is chosen, the moreiteration
rounds are needed for the algorithm to cometo a decision.
A straightforward approach for combining the PMHTand LR test is
to perform the LR test outside the PMHTalgorithm. However, the LR
test can be directly integratedinto the PMHT framework as proposed
in [45].
To this end, the equation for the likelihood ratio
isreformulated as follows:
LRSt pZ1:T9HSpZ1:T9H0
pzt9Nt ,Z1:t1,HSpzt9Nt
,Z1:t1,H0|fflfflfflfflfflfflfflfflfflfflfflfflfflfflffl{zfflfflfflfflfflfflfflfflfflfflfflfflfflfflffl}
F1
pNt9HSpNt9H0|fflfflfflfflffl{zfflfflfflfflffl}
F2
pZ1:t19HSpZ1:t19H0
10
First, it is irrelevant for the tracking problem if an object
isnot present or if it is invisible under all circumstances,i.e.,
that there was no possibility of detecting it using aradar system.
This is why in [26], van Keuk reformulatedthe hypotheses as:
HS HS4PDb0
H0 HS4PD 0 11
where PD denotes the detection probability. This trans-formation
simplifies our computations as the hypothesescan now be tested by
calculating PD. This leads to amodified nominator resulting from
the original term F1in Eq. (10):
F1 pzt9Nt ,Z1:t1,HS,PDb0pzt9Nt ,Z1:t1,HS,PD 0
YSs 1
pdst N zst ;Hx
st9t1,S
s
tp:dst 1=9FoV9
pdst,PD 0|fflfflfflffl{zfflfflfflffl} 0
N zst ;Hxst9t1,S
s
t pt,PD 0|fflfflfflffl{zfflfflfflffl}:ds 1
1=9FoV9
12Second, the factor F2 can be reformulated because itsnumerator
can be written as
pNt9ant s
0 if Nt 0
PsDD 1PDS1sD
XNt1SD 0
pF NtsD1
S1sD
!if Nt 2 1 : S
PsDD 1PDS1sD
XS1SD 0
pF NtsD1
S1sD
!if Nt4S
8>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>:
13
The denominator of F2 represents the probability thatwe have Nt
false measurements. This probability can bemodelled as a
Poisson-distribution pF Nt. Taking theseconsiderations into
account, we get
LRSt pzt9Nt ,Z1:t1,HS,PDb0pzt9Nt ,Z1:t1,HS,PD 0
pNt9HSpF Nt
LRSt1 14
Due to the EM-step, the PMHT-algorithm works onsynthetic
measurements which approximate the realmeasurements, only. So we
replace the measurement ztin the formula above with its synthetic
counterparts zt:
LRSt pzt9Nt ,Z1:t1,HS,PDb0pzt9Nt ,Z1:t1,HS,PD 0
pNt9HSpF Nt
LRSt1 15
Thus, we can calculate the likelihood ratio by solely
usingalready known values, namely the two simplified factorsF1 and
F2 as well as the likelihood ratio from the previousiteration round
t1. The factor F1 uses the detectionprobabilities pdst and p:dst
provided by the sensor andthe density function N zst ;Hx
st9t1,S
s
t referring to thecomputed synthetic measurement values zst . F2
uses theknown visibility weight pNt9HS and the Poisson
distri-bution pF Nt.
Eq. (15) serves as the basic formula for sequentiallycomputing
the likelihood ratios for each iteration round.It represents the
probabilities whether there is a target ornot. The calculated
probability values are only propor-tional to the real LRSt values
with S 1, . . . ,n. However,this is sufficient since we are solely
interested in compar-ing the different ratios and selecting the
most likely one.For example, if the likelihood ratio LR3t is the
largestvalue, the PMHT algorithm assumes for the next
iterationround t that there are three targets in the FoV.
In Fig. 2, our approach is applied to radar data acquiredduring
the observation of an aircraft in the FoV. Theobservation comprises
17 scans of an aircraft movingalong a straight line. The time
between two consecutivescans is 4 s (radar rotation time). For the
aircraft weassumed a detection probability PD0.8 which has
beenstored in the table PMHT. The distances on the axes in Fig.
2are given in multiples of 104 m. The plot shows estima-tions of
the aircraft position as plus symbols (). Radarmeasurements are
divided into true and false detections.True detections are depicted
as filled dots () and confirmour estimations (hypotheses). False
detections are shownas crosses ( ) representing clutter, i.e.,
measurementswhich are not confirmed by subsequent measurements
-
3 3.05 3.1 3.15 3.2 3.25 3.3 3.35 3.4 3.45x 104
3
3.05
3.1
3.15
3.2
3.25
3.3
3.35
3.4
3.45
x 104
Fig. 2. Sample aircraft movement along a straight line.
A. Behrend et al. / Information Systems 38 (2013)
126912841274such that the computed likelihood ratio falls below
0.5.Note that estimations no. 3, 13 and 14 are not confirmedby
their respective scans such that corresponding filleddots are
missing. In these situations the radar system wasunable to detect
the aircraft. An in-depth derivation of thePMHT-formulas can be
found in [44].2.4. The Kalman filter
The Kalman filter was invented in 1960 by Kalman[25,43]. It
estimates the state of a system where ameasurement value xt has to
be estimated using apotentially disturbed measurement value yt .
The connec-tion between both sizes is seen as a stochastic
processcombined with a deterministic linear dependence.Briefly
said, the Kalman filter reduces (or in best caseremoves) the noise
that was added during the measure-ment process.
The dependence between the state at time point t withrespect to
the previous point t1 is assumed to be linear,formally written
xt Ft1xt1Bt1ut1vt1 16
The matrix Ft1 denotes the transition matrix, Bt1ut1 isthe term
that denotes the known deterministic part of thedisturbance and vt1
is a vector of random numbers thatare assumed to follow a Gaussian
distribution withpv N 0,Q . So Eq. (16) gives us the intrinsic
dynamicof motion in the observed system, e.g., a plane that doesnot
fly on an exactly straight path.
Another error stems from the measurement processitself, in our
case from the error of the sensor. Thedependency between
measurement and the observedvalue is modelled as
yt Htxtwt 17
Ht is called the observation matrix an wt is again a vectorof
random values that are also assumed to be Gaussiandistributed
according to pw N 0,R. It is assumed thatu and w are stochastically
independent.The filtering process for estimating xt from yt is
nowdone in two steps. The first step is called prediction. Let xtbe
the a priori estimate of xt , i.e., the estimated value attime t
before including the new measurement, and x
t the
a posteriori estimate of xt , including the new knowledge
ofmeasurement yt . Then the state at time point t1 can bepredicted
by
xt Fxt1But1 18
A measure for the quality of our estimation are the
errorcovariances
Pt Extxt xtx
t
> 19
Pt Extxtxtxt> 20
The a posteriori estimation xt can be written as a weightedsum
of a priori estimation and the innovation ytHx
t ,
i.e., the difference between the actual measurement andthe
measurement expected in an ideal case (so a perfectmeasurement
leads to a difference of zero):
xt xt KytHx
t 21
The weighing factor K is called the Kalman-gain. As wewant to
have the best estimation, we have to minimizethe a posteriori
covariance Pt . Inserting (21) into (20),deriving the trace of Pt
and setting the result to zero leadsto an optimal solution of
Kt Pt H>HPt H
>R1 22
The only term missing is the prediction of Pt and xt . The
latter follows directly from definition:
xt1 Fxt 23
and the prediction of the covariance Pt follows byinserting (16)
into (19). The last step follows from thefact that expectation and
noise are uncorrelated:
Pt EFxtxt vtFxtx
t vt
>
EFxtxt Fxtx
t
>Evtv>t FPtF>Q 24
-
A. Behrend et al. / Information Systems 38 (2013) 12691284
1275In the same way follows the formula for updating Pt byinserting
(17) into (21) and using the fact that priorestimation and
measurement are uncorrelated. We getthat the covariance is updated
according to
Pt IKtHPt 25
(I is the unity matrix).In order to use recursive SQL views for
specifying the
Kalman filter, we need to unfold the above equations forthe a
priori covariance Pt and for the state xt . To this end,we insert
Eq. (22) into Eq. (25) which yields
Pt IPt H>HPt H
>R1HPt 26
Consequently, this equation is inserted into Eq. (24) to geta
formulation of the prior covariance error Pt1 thatdirectly depends
upon the previous covariance error Ptat time point t
Pt1 FtIPt H
>HPt H>R1HPt F
>t Q 27
while all other terms represent constant values. In thesame way
we get a formulation of the smoothed state xtby inserting Eq. (22)
into Eq. (21):
xt xt Pt H
>HPt H>R1ytHx
t 28
Both, Eqs. (27) and (28) can be employed for implement-ing the
Kalman filter using linear recursive SQL views.
3. PMHT in a relational database
In the previous section we have recapitulated theprinciples of
tracking using an extended version of thePMHT algorithm. Our goal
is to find an efficient PMHTimplementation using a relational
database system. In thefirst subsection, we explain why such an
implementationis worthwhile. In the second part of this section, a
firstand rather naive implementation of the PMHT algorithmis
presented using SQL views. From this basis we developan efficient
implementation using incremental hypothesistesting in Section
5.
3.1. Motivation
At a first glance, it seems to be an unusual idea toemploy a
conventional database system for implementingPMHT. However, there
are many good reasons for proces-sing radar data directly in a
database system: first, theamount of data to be processed must be
taken intoconsideration. The amount of clutter typically exceedsthe
amount of true measurements and may becomeoverwhelming. Therefore,
our radar data is usually storedwithin a database which
additionally provides a historycontrol and recovery mechanism. In
addition, trackingalgorithms require the frequent retrieval of
certain sub-sets of radar data. This can be efficiently realized
using theindex mechanisms of a database.
Security aspects also have to be taken into account. Asany
computer system, our tracker may be subject tosystem failures, due
to hardware or software problems.In a military scenario it is
important that the completetracking history can be reconstructed
after a systemfailure. This is automatically provided by the
recoverycomponent of a database system.
Another issue which becomes more and more impor-tant is the
connection of multiple sensors, multiple plat-forms and multiple
users. Data acquired from multiplesensors enhance the tracking
results as multiple viewangles can be combined and false alerts are
more easilydistinguished. It is also possible to combine sensors
ofdifferent types, e.g., optical and radar sensors. Synchro-nizing
these data streams is a difficult task, as theremay be access
violations, delays, etc. This becomes evenmore likely if sensors
are mounted on a mobile platformand the distribution of data is
done using a wirelessconnection.
Another aspect is that multiple users have to be able toretrieve
the track data. As database systems providetechniques for handling
multiple user access and resultdistribution, they are well-suited
for solving these syn-chronization problems. However, it is widely
believed bynow that conventional relational database systems arenot
well-suited for dynamically processing fast changingdata.
Therefore, various SQL extensions [21,42] andstream processing
engines have been proposed [13,30]some of them even designed as
full-fledged commercialproducts (e.g., StreamBase [38]). We show,
however,that even conventional SQL queries can be
efficientlyemployed for analyzing a high frequent stream of
radardata streams [9]. In particular, we show that the applica-tion
of incremental update propagation considerablyimproves the
efficiency of computing answers to contin-uous queries. Finally, UP
allows for efficiently combininghigh frequent stream data with
static context data whichis essential for building higher-level
fusion systems [29].
3.2. Implementing PMHT using SQL views
We now describe how the PMHT algorithm, as pre-sented in Section
2.3, can be implemented using SQLviews. If virtual views are
employed, their results have tobe completely re-computed each time
the underlying datachange. We show that this naive approach leads
toperformance problems as the runtime increases in eachiteration
round. However, the employed naive view defi-nitions serve as a
base for developing their incrementalversions in Section 5.
3.2.1. Base relations
The measured sensor data are stored in the base tableplots. It
provides the parameters of our plots, i.e.,position and velocity
values of the moving objects (orthe respective measured values of
false alerts). In thedescription above, these values were provided
by thevector ~x which can be decomposed into its componentsx,y, _x,
_y where x,y denote the Cartesian position (e.g.,given in m) and
_x, _y denote the velocity (e.g., in m/s). Eachscan is performed at
a given iteration step t. For simplicityreasons, every measurement
process begins with t0. Aseach scan may result in several
measurements, an addi-tional plot number n is used to distinguish
the differentmeasurements in every iteration round. A
possibleinstance of the employed relation plots is given in
-
A. Behrend et al. / Information Systems 38 (2013)
126912841276Table 1. In the first iteration round (t0) only
onemeasurement is returned by the scan indicating a poten-tial
moving object at position /0:00464,49:99179S. Thenext scan returns
the two measurements n0 and n1 atposition /165:00612,215:00303S and
/329:97203,379:99141S, respectively. The aim of our PMHT
algorithmis to determine which of these measurements
probablyrepresent real moving objects and which are false
alerts.
In addition to the plot data, so-called master data hasto be
stored in the database which comprises the char-acteristic values
of the employed sensor. We use therelation master for storing the
attributes PD (detectionprobability), PF (false alert rate) and FOV
(size of the fieldof view) corresponding to the values pF, PD and
9FoV9respectively which are employed, e.g., in Eq. (13).
Thisrelation contains only one tuple which remains unmodi-fied
during a tracking process. A typical instance ofmaster for
specifying the sensor characteristics is shownin Table 2.
Note that the given instance of Table 1 is solelyexemplary.
Usually, several hundred clutter points aremeasured during each
scan. Since we consider a rotatingradar system, nearly every 2 s
new plot data is stored inrelation plots. Given the more realistic
sensor character-istics as shown in the master Table 2, there are
500 clutterplots (resulting from the false alert rate PF and the
size ofthe field of view FOV) which have to be taken into
accountfor each scan instead of one clutter point, only. Under
theassumption that a moving object is tracked for around60 min, the
relation plots may finally contain up to900 000 tuples.
3.2.2. Views
The application of SQL views for implementing PMHTallows the
efficient computation of tracking valuesdirectly within the
database. In this way, a flexible andTable 1Relation plots captures
the stream of continuously pulled radar data.
Usually, every 2 s a new scan t is performed returning a number
of new
measurements distinguished by the value of n.
t n x vx y vy
0 0 0.00464 5.51584 49.99179 5.554541 0 165.00612 5.58467
215.00303 5.53110
1 1 329.97203 5.55485 379.99141 5.50254
2 0 495.00646 5.53123 545.00264 5.55647
2 1 659.99490 5.56875 709.99285 5.53156
2 2 824.98990 5.52547 875.01430 5.52315
3 0 990.00791 5.55456 1039.9843 5.53182
^
Table 2Relation master stores the invariant sensor
characteristics, i.e., the
detection probability PD, the false alert rate PF and the size
of the field of
view FOV.
PD PF (1/km2) FOV (km2)
0.912 0.05 10 000extensible tracking system can be realized
using adeclarative language such as SQL. For implementingPMHT, it
is crucial to implement the likelihood ratio testas given by Eq.
(10). To this end, we need to calculate thefactors F1 and F2 while
the first includes the Gaussiandistribution as well as the prior
probabilities pdt and p:dt .For determining prior probabilities, we
first need to knowthe number of plots for each scan. These numbers
can bedetermined by using the following aggregate query:CREATE VIEW
plotCount AS
SELECT t, COUNT(n) AS nt FROM plots
GROUP BY tThe aggregated values correspond to the value Nt
whichhas been employed, e.g., in Eqs. (15) and (13). Employingthe
master data and plotCount, we can now calculatethe prior
probabilities pdt and p:dt from Eq. (13) whosevalues for each scan
t are stored using the followingattributes pNtH1 and pNtH0,
respectively:CREATE VIEW pNt AS
SELECT pct.t,
CASE WHEN pct.nt0THEN poisson(pct.nt, pfnfov)n(1-pd)
ELSE poisson(pct.nt, pfnfov)n(1-pd)poisson(pct.nt-1,
pct.ntnpf)
END AS pNtH1,
poisson(pct.nt, pfnfov) AS pNtH0
FROM plotcount AS pc, piNote that the above view employs a
simple cross-productof plotCount and pi as the latter relation
contains onetuple only.
We can now calculate the Gaussian distribution of theestimation
batch which is the first factor F1 of Eq. (10):CREATE VIEW LR
AS
SELECT
plots.t, (plotCount.NTnp11/(p01ntnp11))
ngauss(synmsr.x,plots.x,synmsr.vx,plots.vx,
synmsr.y,plots.y,synmsr.vy,plots.vy)
n fov p01/(p01p11) AS LR
FROM pi, plotCount, plots, synmsrWHERE plotCount.tplots.t
AND synmsr.tplots.tView LR calculates the expectation weight
andemploys the user-defined function GAUSS which is ashortening of
the complete multivariate distribution asdescribed in Eq. (A.1) in
Appendix. For implementingN x,x,V, we can calculate the scalar
function. For exam-ple, given the values for the covariance matrix
V and thevectors x and x:
V
12dt3
6dt2
0 0
6dt2
4dt 0 0
0 0 12dt3
6dt2
0 0 6dt2
4dt
26666664
37777775, x
x
_x
y
_y
266664
377775, x
x
_x
y
_y
26664
3777529
we can calculate that 9V9 dt8=144 and get the followingscalar
form:
N x,x,V 1ffiffiffiffiffiffi2p
pdt4=12
exp 12n _y _y
-
Table 3Relation SYN_H1vsH0 stores the likelihood of hypothesis
H1 which states
there is exactly one target in the field of view. As the value
of lr increases
over time hypothesis H1 becomes more and more probable
indicating
that the measurements indeed reflect one moving object.
Relation
SYN_H1vsH0_pNt stores the normalized likelihood w.r.t. the
number
of expected plots in the field of view. (a) SYN_H1vsH0. (b)
SYN_H1vsH0_pNt.
t LR
(a)
0 0.56596809519416
1 0.60193619038831
2 0.62790428558247
3 0.69790428558247
4 0.81790428558247
5 0.90790428558247
(b)
t LR_Result
A. Behrend et al. / Information Systems 38 (2013) 12691284 1277
4_y _y dt
6dt_y _y yy
dt2
!
dt _y _y yy 12dt_y _y yydt3
6_y _y dt2
! _x _x 4
_x _x dt
6dt_x _x xx
dt2
!dt _x _x
xx 12dt_x _x xxdt3
6_x _x dt2
!#
30
We have implemented this equation in the following userdefined
function GAUSS:0 1.56596809519416
1 3.13193619038831
2 4.69790428558247
3 4.69790428558247
4 4.69790428558247
5 4.69790428558247CREATE FUNCTION
GAUSS(x, mx, y, my, vx, mvx, vy, mvy, dt)
RETURNS DOUBLE
BEGIN
RETURN 1/(SQRT(2nPI()npow(dt,4)/12))n
exp(-1/2n(vy-mvy)n((4n(xy-vmy)/dt -
6ndtn((vy-mvy)(y-mv))/pow(dt,2)))?);END;where x, vx, y, vy
denote the components of themeasured vector x while mx, mvx, my,
mvy denote thecomponents of the synthetic vector x, respectively.
Notethat a user-defined function is solely employed as
anabbreviation because we want to keep our view defini-tions
readable. The enhanced expressiveness of user-defined functions,
however, is not needed in ourimplementation.
A problem arises when we want to calculate theproduct of the
likelihood-ratio function which requires acorresponding aggregate
function in SQL. To our knowl-edge, no SQL system supports a
function like PROD so farnor does the current SQL:2008 standard
provide a corre-sponding function specification. A possible work
around isto sum up the logarithm of the factors. The product
canthen be obtained by exponentiating the sum. It is clearthat this
does not work if one factor is non-positive(guaranteed here by the
Kolmogorov axioms). However,our incremental solution allows for a
direct implementa-tion of the product function, as described in
Section 5.1.The following view SYN_H1vsH0 is employed for
comput-ing the factor F1 of the likelihood ratio LRS(t) from Eq.
(12)based on the determined expectation weight in LR:CREATE VIEW
SYN_H1vsH0 AS
SELECT LR.t, SUM(LR2.LR) AS LR
FROM LR, LR AS LR2
WHERELR2:to LR:tGROUP BY LR.tA possible instance of SYN_H1vsH0
is given in Table 3a.The attribute lr represents the numerator
value of thelikelihood ratio function for each scan t. It
corresponds tothe maximum probability of an observed outcome
underthe hypothesis H1 which states that there is exactly onetarget
in the FOV. The increasing values of lr indicate thathypothesis H1
becomes more and more probably than H0over time.CREATE VIEW pNtVS
AS
SELECT pNt.t,
SUM(log(pNt2.pNtH1)log(pNt2.pNtH0))AS pNt_H1vsH0,
SUM(log(pNt2.pNtH0)log(pNt2.pNtH1))AS pNt_H0vsH1
FROMpNt;pNtASpNt2WHEREpNt2:to pNt:tGROUP BY pNt.tBased on these
values, finally the view SYN_H1vsH0_pNt can be computed which
finally representsthe likelihood ratio between hypothesis H1 and H0
asgiven in Eq. (10).CREATE VIEW SYN_H1vsH0_pNt AS
SELECT pNtVS.pNt_H1vsH0 SYN_H1vsH0.LR AS LR_ResultFROM pNtVS,
SYN_H1vsH0.LR
WHERE pNtVS.tSYN_H1vsH0.LR.tA possible instance of
SYN_H1vsH0_pNt is given inTable 3b. The value t represents the time
index whereasthe attribute lr represents the normalized
likelihood-ratio of H1 vs. H0 as given in Eq. (15).
A crucial point here is the self-join that allows run-ning over
all previous factors. This solution has thedisadvantage of an
intermediate square-sized result setand thus leads to quadratic
computation time.
The rest of the view hierarchy consists of scalarcomputations.
An overview of the view hierarchy andthe employed operations is
given in Fig. 3.4. Incremental update propagation
Update Propagation (UP) is a well-established researchtopic
which has been intensively studied for many yearsmainly in the
context of integrity checking and materializedview maintenance
[11,28,32,34]. Nowadays, UP plays animportant role in the context
of the view-based analysis of
-
C
S
F
Fig. 3. View hierarchy of our non-incremental solution to PMHT.
Theedges are labelled with the aggregation functions used for
computing
the dependent views. The label Kalman abbreviates our view
hierarchy
for the calculation of the Kalman filter.
A. Behrend et al. / Information Systems 38 (2013)
126912841278data streams [8,20] and forms the basis for the
incrementalevaluation of continuous queries (e.g., in Oracle
[41]).The aim of UP is the computation of implicit changes
ofderived relations resulting from explicitly performed updatesof
the extensional fact base. As in most cases an update onlyaffects a
small portion of the database, it is rarely reasonableto compute
the induced changes by comparing the entire oldand new database
states. Instead, the implicit modificationscan be iteratively
computed by propagating the individualupdates through the possibly
affected views and computingtheir consequences.
4.1. Normalized basis-SQL
In the following, we introduce a simplified and nor-malized
version of SQL, called normalized SQL (NSQL). It isnot as
expressive as standard SQL but allows for a clearand accessible
discussion of how to perform updatepropagation. To this end, we
consider a so-called BasisSQL which can be directly transformed to
RelationalAlgebra (RA) expressions and to Datalog expressions
[33].
NSQL-queries are restricted to simple Select-From-Where
statements without aggregation and nesting. TheFROM part may only
contain cross-products. We restrictthe formulas in the WHERE-clause
to NOT, AND andEXISTS. Nested NSQL-formulas are prohibited.
TwoNSQL-queries can be combined using UNION. INTERSECT,EXCEPT, etc.
can be expressed by equi-joins or NOTEXISTS subqueries. An NSQL
view is a view that containsan NSQL-query. Additionally, we exclude
duplicates andNULL/UNKNOWN values. For shorthand, we write TABLET
instead of SELECT n FROM T.
The usage of NSQL limits the expressiveness slightly,due to the
exclusion of NULL values and duplicates. Apartfrom that, Date and
Darw show in [16] that nested SQLviews can be transformed into NSQL
views without theloss of expressiveness.4.2. Differential
calculus
The idea of incrementally updating data in databasesreaches back
almost 30 years ago; Koenig and Paige wereone of the first authors
who suggested to avoid costlycalculation of derived expressions by
using incrementalcounterparts instead [27]. Since then, many
methods forincremental re-computation of relational expressionshave
been proposed in the literature. Although mostapproaches
essentially apply the same techniques, theymainly differ in the way
they have been implemented andin the granularity of the computed
induced updates. Withrespect to implementation, e.g., authors used
the databaselanguages SQL (including triggers) [11], Datalog [28]
andrelational algebra [19,23] for specifying their deltarulesjust
to mention a few. In the following, we recalltransformations for
deriving specialized delta rules from agiven set of RA rules. In
order to achieve completeness,so-called transition rules are
considered afterwards whichallow to simulate the old and new state
of a relation.
4.2.1. Delta rules
Various authors introduced delta views, but not alwaysin an
identical manner. Rather than presenting laws foriteratively
transforming a complex expression into itsdelta version (as [35]
does), we use a style similar to thatof [31,37] where delta views
are directly defined. Weassume that key columns exists in all
tables, so no bagsneed to be considered (as [11,23] do).
In the following, for each relation name P, two deltarelations
P_ins, P_del are used for representing theinsertions and deletions
induced on P by an update ofthe underlying database. The delta
relations defined for arelation P have the same schema and type as
P, i.e., if P isextensional respectively derived, then P_ins and
P_delare extensional respectively derived as well. The state of
arelation P before the changes given in the delta relationshave
been applied is denoted by P_old whereas the newstate is
represented by P_new. The delta sets can bedefined as
follows:CREATE VIEW P_ins AS
SELECT n FROM P_new
WHERE NOT EXISTS
(SELECT n FROM P_old
WHERE P_old.keyP_new.key)
CREATE VIEW P_del AS
SELECT n FROM P_old
WHERE NOT EXISTS
(SELECT n FROM P_new
WHERE P_old.keyP_new.key)The most common expressions in SQL are
of the simpleformREATE VIEW P ASELECT xROM Q JOIN RHERE cW
They can be transformed to the incremental versionCREATE VIEW
p_ins ASSELECT x FROM Q_ins JOIN R_0 WHERE cUNION
-
S
U
S
C
S
U
S
U
A. Behrend et al. / Information Systems 38 (2013) 12691284
1279ELECT x FROM R_ins JOIN Q_0 WHERE cNIONELECT x FROM R_ins JOIN
Q_ins WHERE cREATE VIEW p_del ASELECT x FROM Q_del JOIN R_0 WHERE
cNIONELECT x FROM R_del JOIN Q_0 WHERE cNIONELECT x FROM R_del JOIN
Q_del WHERE cS
In general, a residue expression has to be included in bothrules
in order to eliminate induced insertions for which adifferent
derivation already existed in the old state, or toeliminate induced
deletions for which another derivationexists in the new state,
respectively [31]. This type ofeffectiveness test is normally also
required for the unionoperator because of duplicate derivations
generated. Sincewe assume that we have key columns, this
effectiveness testis not necessary and we can use the more simple
incrementalexpression instead. Nevertheless, omitting the
effectivenesstest results in an overestimation of delta sets. The
computedsets correspond to safe updates instead of true ones [22].
Forexample, a safe insertion is given if the corresponding tuple
isindeed a new derivation or already present within theunderlying
database. In order to compute true updates for agiven view set, a
data change capture operation can beadditionally used at the
end.
The transformation for the INTERSECT operator lookssimilar to
that for can be derived from JOIN.
For the set union, the transformation ofCREATE VIEW P AS
TABLE Q UNION TABLE Ris given byCREATE VIEW P_ins AS
TABLE Q_ins UNION TABLE R_ins
CREATE VIEW P_del AS
((TABLE Q_del EXCEPT TABLE R_0)
EXCEPT TABLE R_ins)
UNION
((TABLE R_del EXCEPT TABLE Q_0)
EXCEPT TABLE Q_ins)The most complicated version is the
incremental ver-sion of the set difference, as the second argument
is anegative one and can lead to deletions upon insertion,so the
transformation ofCREATE VIEW P AS TABLE Q EXCEPT TABLE Ris defined
asCREATE VIEW P_ins AS
((TABLE Q_ins EXCEPT R_0) EXCEPT R_ins)
UNION
(R_ins INTERSECT Q_0)
UNION
(R_del INTERSECT Q_ins)
CREATE VIEW P_del AS
TABLE Q_del
UNION
(TABLE R_ins INTERSECT Q_0)
2 Operational data sources often assign time stamps to tuples
that
indicate the time of the last modification. These time stamps
may be
used to select and extract the preserved tuples, i.e., tuples
that have not
been updated during the last loading interval.Note that the
delta rules are transformed from a set ofnormalized rules with no
implicit union. Implicit union isgiven if several rules exist for
defining the same relation.As several rules may influence the
effectiveness ofinduced deletions for safe updates, this case is
avoidedby introducing more auxiliary relations during
normal-ization and using explicit union instead.
4.2.2. Transition rules
Generally, for computing safe update references to theold, the
new or the preserved database state is necessary.In [24] it is
assumed that all derived relations arematerialized which simplifies
the state evaluation processbut seems to be unrealistic in
practice. Therefore, thepossibility has been investigated of
dropping the explicitreferences to one of the states by deriving it
from theother one and the given updates. The benefit of such astate
simulation is that the database system is notrequired to store
intermediate results explicitly but maywork on one state only.
Rules for state simulation arecalled transition rules according to
the naming in [34].
We have defined our delta rules in a way that onlyreferences to
preserved relation states occur. Therefore,we concentrate on their
simulation given the changes ofthe underlying data sources although
new and old rela-tion states can be simulated in a similar way. In
thefollowing, we assume that the preserved state of a
sourcerelation is provided by the data source (together with
therespective delta relations).2 Consequently, the relationstates
Q_0 and R_0 in the expression above are and canbe seen as base
tables. The remaining preserved states ofthe derived views, e.g.,
P_0, however, have to be simu-lated. A straightforward approach is
to use so-called naivetransition rules which employ the preserved
relation stateof the data source for simulating derived ones.CREATE
VIEW P_0
SELECT n FROM
Q_0 JOIN R_0The disadvantage of these transition rules, however,
isthat each derivation with respect to a derived state of
apreserved relation has to go back to the preserved baserelations
and hence makes no use of the implicit updatesalready derived
during the course of propagation. What ismore, the expensive
projections implementing datatransformation and cleansing
operations are againapplied to very large relations and no
optimization effectis achieved for them.
It is easy to see that an incremental set of viewdefinitions
obtained this way continues to be hierarchicaland thus,
stratifiable. Consequently, Magic Sets can beapplied to this set
without changing its semantics.
5. Incremental hypothesis testing
Since we propose to materialize derived data, thequestion arises
how to apply the derived propagation
-
A. Behrend et al. / Information Systems 38 (2013)
126912841280rules. A possible way is the employment of triggers
whichuse corresponding specialized update statements in itsaction
parts as proposed in [11]. Before updating amaterialized view this
way, all underlying tables have tobe already maintained in advance.
For example, the viewLR in Fig. 3 directly depends on the table
plots and theviews synMsr, plotCount and prior. In order to be
ableto apply a trigger for incrementally updating LR, the tableand
the materialized views have to be already updated.
A possible solution to this problem is to stratify a givenview
hierarchy and to use a control trigger which ensuresthe successive
evaluation of consecutive strata. In ourapproach, however,
cascading triggers are used to ensurethat the various update
statements are executed in thecorrect order.
5.1. Trigger-based implementation of PMHT
Since the materialized view concept is still heavilyrestricted
in commercial database systems and not trans-parent to the user, we
implemented our own approach.This even allowed us to simulate the
missing aggregatefunction PROD. In our scenario, there are frequent
inser-tions (e.g., every second) into table plots leading toinduced
updates in the view hierarchy of Fig. 3. Toincrementally update the
view plotCount that containsa SUM-aggregate, we observe
thatXt2R[R
t:aXt12R
t1:aXt22R
t2:a 31
so the SUM-function can be incrementally maintained byadding the
values of the inserted tuples and subtractingthe deleted ones.
Accordingly, the view measCount canbe incrementally maintained
using the specialized updatestatement of trigger new_plots:CREATE
TRIGGER new_plotCount
BEFORE INSERT ON plots FOR EACH ROW
BEGIN
IF EXISTS(SELECT n FROM plots AS m
WHERE m.tNEW.t) THENUPDATE TBLplotCount SET NtNt1WHERE
TBLplotCount.tNEW.t;
ELSE
INSERT INTO TBLplotCount VALUES(NEW.t, 1);
END IF;
INSERT INTO LRy (see below)END;The state variable NEW refers to
the inserted tuple(s) ofplots. Before updating the dependent
materialized viewplotCount, it is checked whether a group
containing theattribute t already exists or not. In the first case,
thecounter is simply incremented whereas in the latter case anew
group is inserted. The same trigger is employed forupdating tblLR
by additionally considering the updatestatementF
W
A
INSERT INTO tblLR
SELECT NEW.t,
(pCt.NTnp11/(p01ntnp11))ngauss(synmsr_p.x,NEW.x,synmsr_p.vx,NEW.vx,
synmsr_p.y,NEW.y,synmsr_p.vy,NEW.vy)
n fov p01/(p01p11) AS LR
ROM prior, plotCount AS pct, NEW, synmsr_pHERE pCt.tNEW.t
ND synmsr_p.tNEW.twhich is again specialized with respect to the
newly
inserted tuples given in NEW and synmsr_p. Before thisupdate is
executed, however, the following triggernew_pNt is activated by the
modification of plotCountfor incrementally maintaining the prior
probabilities inpNt:
CREATE TRIGGER new_pNt
AFTER INSERT ON TBLplotCount
REFERENCING NEW AS NEW
FOR EACH ROW
BEGIN
INSERT INTO pNt
SELECT NEW.t,
poisson(NEW.nt, prior.pfnprior.fovn(1-prior.pd)
FROM NEW, prior
END
Since we have to consider both inserts and updates withrespect
to relation pNt, the following trigger upd_pNt hasto be introduced
in addition:CREATE TRIGGER upd_prior
AFTER UPDATE ON TBLmeasCount
FOR EACH ROW REFERENCING NEW AS NEW
BEGIN
UPDATE pNt SET
pNTH1poisson(NEW.nt,prior.pfnprior.fovn(1-prior.pd)
poisson(NEW.nt-1, NEW.ntnprior.pf)FROM NEW, prior
WHERE pNt.tNEW.t;END;In the last step, the aggregated table
SYN_H1vsH0 hasto be updated, which means to calculate the product
ofthe given probabilistic values. It is more simple to
directlycalculate the product instead of using the
logarithmicfunction as workaround. Note that a product can
bedecomposed according toYr2R[R \R
r:tYr2R
r:t Y
r 2Rr :t
Yr2R
r:t 32
if no elements equal 0 in R are permitted. In our approach,this
special case is avoided by prohibiting zero probabilisticvalues.
Following these considerations, the following triggercan be used
for incrementally updating SYN_H1vsH0, in casethere is already a
value for time step t:CREATE TRIGGER upd_SYN_H1vsH0
AFTER INSERT ON synMsr
FOR EACH ROW REFERENCING NEW AS NEW
WHEN EXISTS(SELECT n
FROM SYN_H1vsH0
WHERE SYN_H1vsH0.tNEW.t)BEGIN
UPDATE SYN_H1vsH0, LR
SET SYN_H1vsH0.lrSYN_H1vsH0.lrnNEW.lrWHERELR:t
NEW:tANDNEW:t4GLRmsrH1:t 3ANDNEW:to GLRmsrH1:t;
END;In case there is no entry for time step t yet, we have todo
an insert instead of an update:CREATE TRIGGER ins_SYN_H1vsH0
AFTER INSERT ON synMsr
FOR EACH ROW
WHEN NOT EXISTS(SELECT n
FROM SYN_H1vsH0
WHERE SYN_H1vsH0.tNEW.t)
-
A. Behrend et al. / Information Systems 38 (2013) 12691284
1281BEGIN
INSERT INTO SYN_H1vsH0
SELECT NEW.t,
SYN_H1vsH0.lrnNEW.lr/LR2.lr AS lr
FROM prior, NEW, tblLR, GLR_msrH1
WHERE NEW-t-3-1.tLR2.t AND LR2.nNEW.nAND LR2.tNEW.t-1 AND
prior.tNEW.t
GROUP BY NEW.t
END;The trigger uses a decomposition of Eq. (15) into twoparts:
the factor LRt1 given in variable SYN_H1vsH0represents the old
likelihood-ratio whereas the new knowl-edge is given in NEW.lr. The
condition NEW.t-3-1tblLR.t within the subsequent insert-statement
identi-fies the tuple that falls off the sliding window and thus
hasto be excluded from the calculated value. In our approach,the
sliding window at time t contains the three scans at timest2, t1,
and t. Each of them comprises N radar measure-ments (cf. Eqs. (5)
and (4)). In order to accumulate allmeasurements of the last three
scans, the clause GROUP BYNEW.t is applied within the insert
statement.
5.2. The recursive Kalman-filter in SQL
The Kalman filter is, as described above, recursive, as
ititeratively updates the states and the covariances. Inclassical
imperative program, one might simply use afunction such asvoid
update() {
x_estFnx_est;PFnPnF Q;y
}
using no classical recursion. However, in relationalcalculus, we
have to use recursive expressions of the formPP,F to implement the
Kalman filter. We now presentthe formulation for the prediction
error (Pt and x
t . The
following considerations are given for an one-dimensionalproblem
for clarity. The fact that SQL does not allow theusage of matrices
is one big withdraw of the practicalrealization of our approach. To
this end, we used acomputer algebra system to decompose the matrix
equa-tions into its components and copied the results into
theresult list of queries.
Suppose we have the following relations, storing themaster data,
i.e., evolution and measurement model, anda relation storing the
measurement together with a time-stamp k:
Master fA,B,U,Cg
Measurement fY ,Kg
We can then calculate the prediction error using ourupdate
Formula (26):CREATE VIEW qryPredError
AS WITH predError(k,P) AS
((SELECT 0,0 FROM master)
UNION ALL
(SELECT p.k1, m.An((1(p.Pnm.C/(m.Cnp.Pnm.Cm.A)/m.C)np.P))
AS PFROM master AS m, predError AS p
WHEREk4 SELECTMAXkFROMmeasurement 20SELECT k,P FROM
predError;and calculate the prediction:CREATE VIEW qryPrediction
(k,x)
AS WITH prediction(k,x) AS
((SELECT 1,1 FROM master)
UNION ALL
(SELECT p.k1,m.An(p.x(q.Pnm.C/(m.Cnq.Pnm.Cm.A)
n(meas.Ynm.Cnp.X)))m.Bnm.U AS xFROM prediction AS p, master AS
m,
qryPredError AS q,
measurement AS meas
WHERE meas.kp.kAND prediction.k1qryPredError.k))
SELECT k,x FROM prediction;the interesting fact about this is
that we need magic setsin order to maintain the recursive view
incrementally.After a magic sets transformation w.r.t. insertions
intomeasurement, the views take the formCREATE VIEW
m_bf_qryPrediction_pp
AS WITH prediction(k,x) AS
((SELECT 1,1 FROM master)
UNION ALL
(SELECT p.k1,m.An(p.x(q.Pnm.C/(m.Cnq.Pnm.Cm.A)
n(meas.Ynm.Cnp.X)))m.Bnm.U AS xFROM prediction AS p, master AS
m,
qryPredError_bf_new AS q,
measurement_p AS meas
WHERE meas.kp.kAND prediction.k1qryPredError.k))CREATE VIEW
qryPredError_bf_new AS
AS WITH predError(k,P) AS
((SELECT 0,0 FROM master)
UNION ALL
(SELECT p.k1, m.An((1(p.Pnm.C/(m.Cnp.Pnm.Cm.A)/m.C)np.P))
AS P
FROM master AS m, predError AS p,
measurement_p
WHERE predError.kmeasurement_p.k))SELECT k,P FROM predError;The
magic update transformation is only done w.r.t.insertions into the
measurement table as no other changeoperations (updates or
deletions) are performed on thistable. Magic updates reduce the
size of intermediate joinsby dynamically generating selection
conditions. Thismethod is especially suited for optimizing
recursive viewdefinitions (like prediction error). Even
non-recursiveviews may benefit from this transformation but as
theperformance gain in our case remains small we refrainfrom
that.5.3. Performance issues
In order to process data streams in real-time, it isnecessary to
guarantee that each update step in thesystem can be processed in a
reasonable time. In addition,for continuous usage, it is necessary
that the system doesnot change over time, which requires the
runtime to belinear with respect to the update number n, i.e.,
-
Fig. 4. Comparison of the two evaluation approaches. While the
naivere-computation shows super-linear runtime, our incremental
approach
has linear runtime. Note the different scales of the time axis.
(a) Native.
(b) Incremental.
A. Behrend et al. / Information Systems 38 (2013) 126912841282Tn
On. A lower bound for the run-time can bederived as follows: let mi
be the size of data to beprocessed in a time step. Then the overall
run-time ofeach algorithm processing all data has a lower bound
ofTimi omi in each time step. In practical sensorapplications, the
output of each sensor is physicallybounded by a constant throughput
number. We note thisnumber with C and get, that for n update steps,
theminimal overall run-time is
Tn on C on 33
so an ideal stream processing has a runtime behavior ofTn Yn.
The original PMHT algorithm was alreadyoptimized to be linear in m
and n (cf. [44,45]), fulfillingthis condition.
In a first step, we tested the behavior of the
naiveimplementation, using complete re-computation of allviews. The
tests were run by continuously ingesting pre-recorded data into the
database system. We used opendatabase connectivity (ODBC) for data
ingestion and mea-sured the complete time from the first ingestion
till thelast one. The number of tuples ingested in each step
waskept constant, following the considerations of
sensorcharacteristics above. The implementation of the naiveand the
incremental approach were done in MySQL.
In order to compare our approach with the materiali-zation
capabilities of a commercial DBMS, we used Oracle11g to implement a
system of materialized views. Unfor-tunately, it is not possible to
use fast refresh on joins, sowe could only test the refresh with
ROWID. The tablestructures and view definitions were identical to
that ofthe naive MySQL implementation and the tests wereconducted
analogously. All tests were run under Win-dows XP on a computer
equipped with an Intel Core 2Duo E6600 processor and 2 GB of
RAM.
The performance results for n1, 100, 1000, 1500 and2000 updates
are shown in Fig. 4a and b. Subfigure ashows the runtimes for the
naive approach and theROWID updates in Oracle. The superlinear
runtime beha-vior is obvious. The relation between the number
ofupdate steps and the overall runtime for the naive re-computation
of ewGauss can be fitted well witht 0:00034 log 10n n2, giving
reason to believe thatTnaiven On2 log n.
The Oracle runtime behavior can be fitted well with apolynomial
of third degree. This indicates an asymptoticalrun-time of Toraclen
On3.
On the other hand, the run-time of the incrementalmethod can be
fitted via a linear model (t 0:0024N0:107), showing linear runtime
behavior with respectto the number of updates. This is much more
thansufficient for our practical scenario where we have toprocess
400 measurements every 4 s due to the physicalscan rate.
The difference in asymptotic behavior can be inter-preted as
follows: in both cases, the views have to bemaintained n times. The
naive algorithm completelyrecalculates the views, leading to a
second factor n. Inorder to investigate the reasons for the
performancedifferences more deeply, we compared the naive
andincremental re-computation of tblLR and prior. In theview tblLR,
an expensive three-way join is computedinvolving the views estimate
and prior as well as thetable measurement. In our incremental
approach, theGaussian distribution is computed for the newly
insertedmeasurement tuple, only. Thus, the redundant
re-compu-tation of the previous Gaussian values is avoided.
Inaddition, the join computation in tblLR is acceleratedby using an
indexation of the materialized view values.This way, the search for
join partners can be done inconstant time, for example, by using
hashing. In contrastto this, the view prior computes a simple join
of tablePMHT and view measCount. The former contains only onetuple
comprising the underlying sensor characteristics.Consequently, the
speed up using our incrementalapproach remains relatively
small.
6. Related work
Dealing with uncertainty is an important aspect in thefield of
moving object databases. However, an SQL-basedimplementation for
detecting unknown moving objectsusing hypothesis testing
[5,10,40,44,45] has not been pub-lished so far. A higher-level
approach for efficiently OLAPingmultidimensional data streams has
been presented in
-
A. Behrend et al. / Information Systems 38 (2013) 12691284
1283[1315]. Incremental update propagation has
undergoneinvestigations for almost 30 years, e.g., [32,35], and an
SQL-based approach using triggers has been already proposed in[11].
A method for incrementally maintaining views withaggregate
functions has been proposed in [24], although noexact rules are
given. An algorithm and performance analy-sis for incremental UP
for aggregate functions in a databasesystem is given in [12]
showing the feasibility of UP in thiscontext. These results support
the claim that the incremen-tal evaluation of SQL views provides a
suitable approach forthe efficient analysis of data streams which
is necessary inthe context of moving object detection. Our own
streamingsystem [7,8] and results from [20] showed indeed
thefeasibility of incremental UP in a streaming context. It isone
result of this paper that our approach to the incre-mental
evaluation of continuous queries can be also effi-ciently applied
to the specific context of hypothesis testing.
7. Conclusion
In this paper we presented a solution how to seam-lessly
integrate a tracking algorithm into a moving objectdatabase system.
We have shown how a conventionaltracking algorithm can be
transformed into a view hier-archy and how this view hierarchy can
be optimized in away that linear run-time behavior w.r.t. the input
size canbe achieved. Our performance results support the claimthat
the presented technique is suitable for real-timeprocessing of a
realistic stream scenario. This is contra-dictory to the common
belief that conventional databasesystems are not well-suited for
dynamically processingcontinuous queries [4,21,38] and that
dedicated streamprocessing systems such as STREAM [3] are
necessary.
In contrast to other PMHT implementations, the
proposedrealization directly within a database system offers
variousadvantages. The employed declarative SQL views provide
aflexible implementation of the underlying PMHT functionswhich can
be easily extended by new tracking functionalitieswhile the system
is running. In this way, our approach canform the basis for
building high-level fusion systems [29]which take context data into
account (such as road or tunnelinformation) for improving tracking
quality and situationawareness. In addition, security aspects are
directlyaddressed by the incorporated transaction managementand
persistent data storage. Finally, our approach directlysupports
multi-user access and multi-sensor input by theincorporated
synchronization capabilities of the underlyingdatabase system.
Appendix A. The multivariate Gauss density
The multivariate Gauss density is the extension of thewell-known
bell curve to the multi-dimensional room. Inthe two-dimensional
case, the plotted function has the formof a bell shaped hill. In
the general case, it is defined as
N x;x,V 1ffiffiffiffiffiffiffiffiffiffiffiffiffi92pV9
q e1=2xxV1xx> A:1where the expectation vector is given by Ex
x and the co-variation matrix by Covx Exxxx> V.Appendix B. The
product formula for Gaussians
The product formula transforms a product of Gaus-sians into
another product of Gaussians:
N x;Xy,YN y; z,Z N x; a,AN y;b,B B:1
with
aXz
AXZX>Y
b zWxXz
B ZWAW>
W ZX>A1: B:2
Appendix C. Derivation of the Kalman gain
The Kalman gain can be derived in the following way.First, the
covariance Pt is defined by
Pt Exxxx> C:1
(in the following the time indices on the right-hand sideare
omitted). The prediction x is defined by
x xKyHx xKHxvHx C:2
Inserting (C.2) into (C.1) yields
Pt EIKHxxKvIKHxxKv> C:3
As the prior estimation error xx is uncorrelated to
themeasurement error, we can split (C.3) and get
Pt IKHExxxx>IKHKEvv>K>
IKHPIKH>KRK>
PKHPPH>K>KHPH>RK> C:4
As the main diagonal of Pt contains the mean squareerrors, it
suffices to minimize the trace TPt (the sum ofthe main diagonal) of
Pt . P is symmetric and it holds thatTAB TATB and TA TA>, so we
have
TPt TPTKHPTPH>K>TKHPHP>RK> TP2TKHPTKHPH>RK>
C:5
Now we derive (C.5) w.r.t. K. Applying the rules@tAC=@A C>
and @tABA>=@A 2AB,B symmetric weget
@TPk@K
2HP>2KHPH>R C:6
setting the derivative to zero yields the final result
02HP>2KHPH>R
3KPH>HPH>R1 & C:7
References
[1] D. Abadi, D. Carney, U. C- etintemel, M. Cherniack, et al.,
Aurora: adata stream management system, in: SIGMOD, 2003, p.
666.
[2] D.J. Abadi, W. Lindner, S. Madden, J. Schuler, An
integration frame-work for sensor networks and data stream
management systems,in: VLDB, 2004, pp. 13611364.
-
A. Behrend et al. / Information Systems 38 (2013)
126912841284[3] A. Arasu, B. Babcock, S. Babu, M. Datar, et al.,
Stream: the stanfordstream data manager, in: SIGMOD, 2003, p.
665.
[4] B. Babcock, S. Babu, M. Datar, R. Motwani, et al., Models
and issuesin data stream systems, in: PODS, 2002, pp. 116.
[5] Y. Bar-Shalom, T.E. Fortmann, Tracking and Data
Association,Academic Press, NY, USA, 1988.
[6] A. Behrend, R. Manthey, Update propagation in deductive
databasesusing soft stratification, in: ADBIS, 2004, pp. 2236.
[7] A. Behrend, C. Dorau, R. Manthey, Tinto: a tool for the
view-basedanalysis of streams of stock market data, in: DASFAA,
2007,pp. 11101114.
[8] A. Behrend, C. Dorau, R. Manthey, G. Schuller, Incremental
view-based analysis of stock market data streams, in: IDEAS,
2008,pp. 269275.
[9] A. Behrend, R. Manthey, G. Schuller, M. Wieneke, Detecting
movingobjects in noisy radar data, in: ADBIS, 2009, pp. 286300.
[10] S.S. Blackmann, R. Populi, Design and Analysis of Modern
TrackingSystems, Artech House, 1999.
[11] S. Ceri, J. Widom, Deriving production rules for
incremental viewmaintenance, in: VLDB, 1991, pp. 577589.
[12] M. Chan, H.V. Leong, A. Si, Incremental update to
aggregatedinformation for data warehouses over internet, in: DOLAP,
2000,pp. 5764.
[13] A. Cuzzocrea, CAMS: OLAPing multidimensional data
streamsefficiently, in: DaWaK, 2009, pp. 4862.
[14] A. Cuzzocrea, Retrieving accurate estimates to OLAP queries
overuncertain and imprecise multidimensional data streams,
in:SSDBM, 2011, pp. 575576.
[15] A. Cuzzocrea, P. Serafino, LCS-hist: taming massive
high-dimen-sional data cube compression, in: EDBT, 2009, pp.
768779.
[16] C.J. Date, H. Darwen, A Guide to SQL Standard, 4th ed.,
Addison-Wesley Professional, 1996.
[17] S.J. Davey, Extensions to the Probabilistic
Multi-Hypothesis Trackerfor Improved Data Association, Ph.D.
Thesis, University of Adelaide,2003.
[18] A.P. Dempster, N.M. Laird, D.B. Rubin, Maximum likelihood
fromincomplete data via the EM Algorithm, Journal of the
RoyalStatistical Society, Series B 39 (1977) 138.
[19] G. Dong, J. Su, Incremental maintenance of recursive views
usingrelational calculus/SQL, in: SIGMOD, 2000, pp. 4451.
[20] T.M. Ghanem, M.A. Hammad, M.F. Mokbel, W.G. Aref, et al.,
Incre-mental evaluation of sliding-window queries over data
streams,IEEE Transactions on Knowledge and Data Engineering 19
(2007)5772.
[21] L. Golab, M.T. Ozsu, Issues in data stream management,
SIGMODRecord 32 (2003) 514.
[22] U. Griefahn, T. Lemke, R. Manthey, Tools for chimera: an
environ-ment for designing and prototyping advanced applications in
anactive DOOD model, in: ADBIS, 1997, pp. 346355.
[23] T. Griffin, L. Libkin, Incremental maintenance of views
withduplicates, in: ACM SIGMOD, 1995, pp. 328339.
[24] A. Gupta, I.S. Mumick, V.S. Subrahmanian, Maintaining
viewsincrementally, in: SIGMOD, 1993, pp. 157166.
[25] R.E. Kalman, A new approach to linear filtering and
predictionproblems, Transactions of the ASMEJournal of Basic
Engineering82 (1960) 3545.[26] G. Van Keuk, MHT extraction and
track maintenance of a targetformation, IEEE Transactions on
Aerospace and Electronic Systems
38 (2002) 288295.[27] S. Koenig, R. Paige, A transformational
framework for the automatic
control of derived data, in: VLDB, 1981, pp. 306318.[28] V.
Kuchenhoff, On the efficient computation of the difference
between consecutive database states, in: DOOD, 1991,pp.
478502.
[29] M.E. Liggins, D.L. Hall, J. Llinas, Handbook of Multisensor
DataFusion: Theory and Practice, Electrical Engineering and
AppliedSignal Processing, 2nd ed., CRC, Boca Raton, FL, 2008.
[30] S. Madden, M.J. Franklin, Fjording the stream: an
architecture forqueries over streaming sensor data, in: ICDE, 2002,
pp. 555566.
[31] R. Manthey, Beyond data dictionaries: towards a reflective
archi-tecture of intelligent database systems, in: DOOD, 1993,
pp. 328339.[32] R. Manthey, Reflections on some fundamental
issues of rule-based
incremental update propagation, in: DAISD, 1994, pp. 255276.[33]
I.S. Mumick, S.J. Finkelstein, H. Pirahesh, R. Ramakrishnan, Magic
is
relevant, in: SIGMOD, 1990, pp. 247258.[34] A. Olive, Integrity
constraints checking in deductive databases, in:
VLDB, 1991, pp. 513523.[35] X. Qian, G. Wiederhold, Incremental
computations of active rela-
tional expressions, IEEE Transactions on Knowledge and Data
Engineering 3 (1991) 337341.[36] D. Reid, An algorithm for
tracking multiple targets, IEEE Transac-
tions on Automatic Control 24 (1979) 843854.[37] M. Skold, T.
Risch, Using partial differencing for efficient monitor-
ing of deferred complex rule conditions, in: ICDE, 1996,pp.
392401.
[38] M. Stonebraker, U. Cetintemel, One Size Fits All: an idea
whosetime has come and gone, in: ICDE, 2005, pp. 211.
[39] StreamBase Systems, Inc., /http://www.streambase.com
OnlineS,retrieved December 2010.
[40] R. Streit, T. Luginbuhl, Probabilistic Multihypothesis
Tracking,Technical Report NUWC-NPT/10/428, 1995.
[41] S. Subramanian, S. Bellamkonda, H.-G. Li, V. Liang, et al.,
Continuousqueries in oracle, in: VLDB, 2007, pp. 11731184.
[42] H. Wang, C. Zaniolo, C.R. Luo, Atlas: a small but complete
SQLextension for data mining and data streams, in: VLDB, 2003,pp.
11131116.
[43] G. Welch, G. Bishop, An Introduction to the Kalman Filter,
Siggraph,2001.
[44] M. Wieneke, W. Koch, The PMHT: solutions for some of
itsproblems, in: Society of Photo-Optical Instrumentation
Engineers
(SPIE 2007), 2007, pp. 112.[45] M. Wieneke, W. Koch, On
sequential track extraction within the
PMHT framework, EURASIP Journal on Advances in Signal
Proces-
sing (2008) 113.[46] P. Willett, Y. Ruan, R. Streit, PMHT:
problems and some solutions,
IEEE Transactions on Aerospace and Electronic Systems 38
(2002)738754.
[47] J.F.J. Wu, On the convergence properties of the EM
algorithm, TheAnnals of Statistics 11 (1983) 95103.
http://www.streambase.com Online
Efficient tracking of moving objects using a relational
databaseIntroductionTrackingState of the artThe PMHT
algorithmSequential likelihood-ratio testing in PMHTThe Kalman
filter
PMHT in a relational databaseMotivationImplementing PMHT using
SQL viewsBase relationsViews
Incremental update propagationNormalized basis-SQLDifferential
calculusDelta rulesTransition rules
Incremental hypothesis testingTrigger-based implementation of
PMHTThe recursive Kalman-filter in SQLPerformance issues
Related workConclusionThe multivariate Gauss densityThe product
formula for GaussiansDerivation of the Kalman gainReferences
