Handling GPS Data with Python
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Part Number | 145 | |
| Number of Parts | 169 | |
| Author | ||
| License | CC Attribution - NonCommercial - ShareAlike 3.0 Unported: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal and non-commercial purpose as long as the work is attributed to the author in the manner specified by the author or licensor and the work or content is shared also in adapted form only under the conditions of this | |
| Identifiers | 10.5446/21141 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
EuroPython 2016145 / 169
1
5
6
7
10
11
12
13
18
20
24
26
29
30
31
32
33
36
39
41
44
48
51
52
53
59
60
62
68
69
71
79
82
83
84
85
90
91
98
99
101
102
106
110
113
114
115
118
122
123
124
125
132
133
135
136
137
140
143
144
145
147
148
149
151
153
154
155
156
158
162
163
166
167
169
00:00
InformationNP-hardDomain-specific languageAlgorithmData structureDataflowChemical polarityParsingReading (process)StatisticsGenetic programmingPoint (geometry)NumberRadio-frequency identificationContinuous trackBit rateUniform convergenceSampling (music)Computer filePlot (narrative)Interactive televisionWorld Wide Web ConsortiumZoom lensLevel (video gaming)Surjective functionComputer iconDigital filterState of matterNichtlineares GleichungssystemMeasurementVector spaceControl flowMatrix (mathematics)outputAutocovarianceNoiseProcess (computing)Software development kitEstimationError messageMathematical optimizationAverageMaxima and minimaLoop (music)PredictionArithmetic mean3 (number)Position operatorData modelVelocityPositional notationSummierbarkeitPrice indexInsertion lossData conversionRecursionLibrary (computing)Genetic programmingPresentation of a groupVelocityCASE <Informatik>Process (computing)Position operatorNoise (electronics)Computer filePoint (geometry)Subject indexingMeasurementDifferent (Kate Ryan album)Instance (computer science)Goodness of fitMultiplication signMetreObject (grammar)Profil (magazine)RecursionWebsiteNichtlineares GleichungssystemPlotterMappingState of matterLaptopSmoothingClient (computing)Integrated development environmentCodeLine (geometry)PlanningRight angleBitQuicksortMatrix (mathematics)AlgorithmBit rateFile formatData structureError messageFrame problemDistanceLibrary (computing)Endliche ModelltheorieVector spaceNP-hardPositional notationElectric generatorBeta functionGeometryExtension (kinesiology)Group actionNumberMathematical optimizationArithmetic meanAutocovarianceOrder (biology)CurveComputer-assisted translationCondition numberTask (computing)Field (computer science)Cartesian coordinate systemInterface (computing)Ocean currentWritingEstimatorInsertion lossUniformer RaumAuditory maskingTheory of relativityService (economics)Self-organization2 (number)MereologyVariable (mathematics)Projective planePredictabilityHeegaard splittingElectronic mailing listWindowNatural languageWordRootFigurate numberElectronic visual displayWeb pageSigned measureImplementationLimit of a functionAttribute grammarOperator (mathematics)GoogolTerm (mathematics)Shared memoryFilm editingIdentity managementExpected valueBinary codeDirection (geometry)Source codePhysicalismPhysical systemData conversionArrow of timeVarianceTraffic reportingCore dumpAreaDatabaseProduct (business)Latent heatAnalytic continuationFunctional (mathematics)Online helpCircleSound effectLevel (video gaming)IterationAverageMaxima and minimaGame theoryRepetitionSemiconductor memoryRow (database)Design by contractType theoryGenetic programmingPiComputer programmingMetropolitan area networkAbstractionForm (programming)GravitationCopyright infringementSpeech synthesisPermutationMathematicianDiscrete groupBlock (periodic table)Exterior algebraInclusion mapSlide ruleHypermediaPower (physics)Kalman-FilterInitial value problemInformationData typeDiagonalList of unsolved problems in mathematicsState observerReading (process)Tournament (medieval)ParsingSummierbarkeitSoftwareEntire functionCellular automatonCovariance matrixDisk read-and-write headParsingStandard deviationFitness functionThermische ZustandsgleichungPairwise comparisonOpen setUniform resource locatorPosterior probabilityHeat transferTotal S.A.Sampling (statistics)Installation artGame controllerPolarization (waves)DataflowStatisticsSocial classLipschitz-StetigkeitSinc functionDot productRoutingReduction of orderArray data structureResampling (statistics)Set (mathematics)Function (mathematics)Interpreter (computing)GUI widgetMathematicsData recoveryDifferenz <Mathematik>Flow separationLinearizationAffine spaceComputer animation
Transcript: English(auto-generated)
00:01
Okay. Hello, our next presenter is Florian Vilgen. He's data scientist at InnoVEX and the title of his presentation is handling GPS data with Python. Thank you, Florian. Yeah, thank you everyone. Welcome to my talk, handling GPS data with Python.
00:24
My name is Florian Vilgen and I'm a data scientist at InnoVEX. InnoVEX is a technology consulting company based in Germany in all the major cities. So I once had a project where the task was to relate the
00:42
brake pad wear of trucks to the route they're driving and how much they're driving and where they are driving. So this was the time when I first had to like deal with GPS data because what we had from this those trucks were GPS data and of course the current condition of the of the brake pads and
01:03
so this is how I came to that and when I try to find information about libraries about what kind of libraries I could use to in order to fulfill this task I found it quite hard actually because normally you're used to that whatever
01:22
Python libraries you're searching you get a lot of good tutorials and so on but it was kind of hard for GPS and so this is the reason for this talk that I want to share a little bit about information about things I found out during this task and of course, I'm also as a mathematician interested in the algorithm and
01:44
the mathematical algorithms in that domain on and it's always good to to have a talk right when you're going to a cool conference like the Euro Python. So first of all When you're starting to to deal with GPS data there it needs to be stored in a way, right? So
02:02
the typical format for GPS is the so-called GPX the GPS exchange format and It's based on XML. It describes three different points. So we have here three different things we have waypoints we have a root so root is
02:23
Yeah, the the way you actually want to go if you for instance using it for hiking and then the actual track that's the route you then actually took because maybe there was some kind of mountain in between and This is basically what this format is describing. So to give you a little bit of an idea how the general structure looks like
02:46
We have here The the waypoints as shown before we have the route and the route is just a lit the list of different route points and we have to track the track is composed of several segments and
03:03
You're using segments For instance when when you lose your GPS signal you start a new segment or when when you're hitting pause for instance on your on your running sensor, then you start a new segment and Each segment contains many track points which build up then the track you actually took
03:23
and for this presentation I will use not the customer data, of course, but data I took from my for my watch from from Polar Flow it's called and This contains only a track because if you go for run you don't normally don't plan the route
03:40
You just go for run and it tracks your points and we have here the latitude and the longitude The elevation and of course the time when this measurement was taken So, how do we now deal with those kinds of files? So there's one library called GPX pie It's a chibi X file parser for reading and you can even write a chibi X files
04:04
It's licensed and there the Apache 2.0 It contains a nice small a command-line tool chibi X info that gives you some basic stats about your files So if you're just interested in okay, what was my average? Velocity then you can just use it. It's Python 3 compatible. What is always important with small levels like this
04:25
It's written by Tomo Carina and it's used on his website track profile up dot-com So, how do you actually use this? So it's really really easy. You just import it you open You open the file as a file handle and you just pass it and basically that's it
04:46
So what you get back is an object and you can then use the tracks attribute to yeah to access the different tracks in this case, we only have one track and
05:00
the segments this case I also had only one segment and Then normally what we do right if we want to deal somehow with this information we Make a data frame a data frame a pandas data frame out of it and that's exactly what I did here and I set the index time and That's the data frame so so far so simple
05:24
So, of course size since Chibi X is something really visual. We want to plot it and just to give you an idea So this was one of a run I did in in Hamburg So this is if I just plot the longitude and the latitude with the help of my plot lip
05:42
exactly and This was just so just to track such as the line what happens if we plot? Not only the line but the actual points with Dots then we see that we have a lot of points. We have more than 10,000 points actually So at this point I might think okay maybe
06:03
10,000 point for a small run is not it's way too much. So, how can we reduce it? How can we reduce the number of points that we have to deal with less data without actually destroying the geometry of? the of the track
06:22
So a really simple trick is we use only every 105th point and in that case it works because I was running with about always the same speed But this would not work if I had done this with a car or we also see that On straight lines like here, of course
06:43
You would need less points to describe a straight line only two points actually, but in a curve you would need more Information to describe the curve so you see there's the need to somehow use some cool algorithm to to simplify a GPS track and one algorithm that is quite often used is the so-called comma to class polka algorithm and
07:07
I think it's best explained in Yeah in how it works. So let's assume we have this GPS track and We want to simplify it and what I simplify means so we have to give some kind of of
07:22
Epsilon some kind of error that we say that's okay to make that kind of error, but not Any more not not more than a certain epsilon So the algorithm just works taking the first point to the last drawing a straight line and this this epsilon
07:41
Surroundings this epsilon environment around that straight line and The algorithm goes if now all points would be inside this Epsilon environment then we could just reduce all points in between if it's not the case then take the point which is the furthest away with from this line, which is that one and
08:04
Apply the same algorithm recursively on the two Segments that Are by splitting at that point. So one segment is that one here and the other will later be that one So we start with inspecting that one. We see okay, all points are in this epsilon environment
08:24
we can just remove that and Now we do the same here. We have the problem. Not all points are included We take the one that is the furthest away So that one we're gonna split up from here to there and then from there to there
08:41
So first this one we can remove that point Here we have the same problem again. And this is how this algorithm recursively works and we see that we have simplified the track which we reduce the number of points and If we go back and forth you see just even better and this is an algorithm
09:03
We can use in which is quite often actually used To simplify and GPS track and we will later make use of this so In this case, I just use this this algorithm and Yeah, and that point one should also make it
09:24
Yeah, one word of caution. So never ever use recursion in Python. You will always run into problems If you go if the your recursion is too deep, so if you have more than Recursion the depth of more than one hundred one thousand then you will get into trouble
09:44
So it's better to reformulate this algorithm iteratively, which makes it more complicated but this is what I did here and Yeah, so I used an implementation that is iterative and I just run it on the long and latitude and I can reduce
10:02
Number of points for more than twelve thousand to less than two hundred and we see here the outcome we see as expected straight lines are really straight lines and here for instance during a curve more dots are actually used and
10:21
Yeah, that's it about the simplification so When I was doing this project with the with the trucks, I had only longitude and latitude Of course, I was interested in kind of finding out. Okay What was the height the uphill and downhill distance since the car was actually doing but okay
10:40
Where do I get the elevation from so was I was looking around in in my track? so this is the track from from a bicycle ride I did in in Italy and There I have the elevation but I will now Just remove it so that it is like it was in the project that I don't have it in that case
11:07
There's a really good cool extension to GP x pi called SRT m pi and s RTM pi stands for shuttle radar topography mission elevation data for Python and
11:21
That was I think maybe some of you remember in the year 2000. There was this huge Yeah, NASA mission where they were Using radar to find out the elevation almost everywhere on earth and this data is publicly available and this is just Yeah an interface for it and you can really easily use it to get
11:44
the elevation data So you just import it you say s RTM get data and you say at elevation to the gbx file To this object we opened before and what s RTM will do it will just start
12:00
downloading partial files with the with this data and Add it to your gbx file and additionally we can say at least smooth the elevation So two neighboring elevations are averaged in that case and Yeah
12:21
So if I just plot it to see to compare the elevation that my my sensor Took or measured and to compare it to the s RTM data. We see that it's yeah, basically Almost the same so this works always great if you don't have the elevation data, but you somehow need it
12:44
So, of course If you do a project in the end, you want to present something to the customer and the customer always likes nice pictures So I was also facing the problem of how can I now visualize the data in a in a nice?
13:00
customer friendly way and I found out about the library called MPL leaflet and nice thing about this is it can just use any matplotlib plot and Put it into a pannable zoomable slippy map So all this maps you see in web pages where you have open street map or Google
13:21
Directly embedded in a in a web page. It's extremely easy to use also new bsd license it integrates fantastically well with the Jupiter notebook and Python 3 compatible and the word of caution You should definitely simplify your tracks with the Rama to class polka algorithm first because if you started
13:43
Using it with the 10,000 points then it will not work Okay, so how does it work as I said, it's really simple we start with a matplotlib plot that one we have seen before And now we just projected on to open street map
14:01
We just import MPL leaflet and say display the figure we created before And this will interpreter Embed it into them into the output widget or if we would say it would have said show Then it would just open a new window and this is fully interactive and zoomable and it's two lines of code to actually embed this somewhere and
14:25
This is as well. I really really like this that it that is so easy and another track That I want to talk about a little bit more now is Yeah, this this bicycle
14:43
ride I did in Austria and Italy here and When I was looking at the data of the track I found out that there are some some curious things so If I call the get uphill downhill
15:00
method of GBX PI it tells me that I was actually doing height meters of 4446 and Yeah, and downhill about the same and was wondering okay, I mean sounds good That's a lot of height meters to do actually by bike
15:21
But the organizer they told me or it said it's on the website that it's roughly 2700 height meters so strange So somehow my sensor must have measured something strange or maybe I'm doing something wrong so was I was trying to start investigating and
15:41
If I looked when I looked closer at the the elevation I realized that they are just bumps here and This bumps are quite unreal unrealistic. So We directly see that the elevation sensor measures in accuracy or precision of one meter and
16:02
Sometimes it jumps up and it jumps down and it jumps up and down and if you do that a lot Of course if you measure the uphill distance on that side you gain uphill Meters, although this seems quite unrealistic, right? So we have to somehow smooth the data because this is an artifact of the sensor
16:22
That's not the actual position I was at that time and also when I was looking at the speed it was quite Yeah Feeling strange that I was sometimes doing 230 kilometers per hour, which is on a on a bicycle I mean, I mean it was going downhill sometimes but even downhill that's way too much and
16:45
This was also I mean I was using the gbx file at missing speeds function which basically takes the time and the distances and calculates the speed So it shouldn't be a mathematical problem. It's more like the problem got to be somewhere in the data and
17:02
We directly see that this peak is extremely unrealistic But why how do we know that this is unrealistic? I mean, it's like okay we have the picture of a bike in our head and we say a Bike has a position in some kind of velocity and if we know the velocity then the position will be
17:22
The next position will be somehow based on the current position and on the speed vector we did we have or if you see someone like Walking if you see me walking then you know in the next second I'm gonna be there because this was my direction I was going and
17:42
So we have this kind of model in our head and this is exactly what the Kalman filter is all about so Kalman Actually, he passed away just three weeks ago. So really beautiful mind and he came up with this idea of describing
18:00
giving a model to some to all kind of physical things and in this case we have we want to describe like my bicycle ride and The idea is that you have that you have states states you can't really directly observe not like that the real states and I can think of my
18:23
of my bicycle like having or me on my bicycle of having a position and some velocities or this is this state and state acts and Somehow I want to project this into the next state
18:40
so if I have like I said before it the position and the velocity I can just use the velocity and Edit Times the time to the position and I will get a rough idea of the next position and then we have in the in the general Form of course, he's a mathematician. He made it as general as possible We also have a control vector this in this case
19:00
We would not need but for instance if you're looking at a falling apple or falling ball, then this could be the Acceleration due to gravity to the gravitation and of course, we always have an error term So the error term is when I'm walking and slowly changing my direction
19:20
then this is part of the ever term and Then besides the state equation. We also have the measurement measurement equation So this is what we had a GPS idea comes into Into play so the state I said we cannot Directly observe it but we observe a measurement and the measurement is somehow
19:46
generated from the state plus an additional Arrow and this is basically the main idea and now that I kind of have a model how I think
20:00
Something physical some process behaves Like my ride on a bicycle and on the other hand I get measurements and those will never be exactly the same I Somehow need a method to to bring them both together and this is so the the main idea behind the Kalman filter so I
20:22
Take everything I know up to a certain point about the process and about all prior Measurements this is called here X hat minus so it's kind of a priori state estimation and Then in the next step I get the measurement. This is to set K and
20:44
Then I want to somehow Get an a posterior state estimation, which is better than my a priori knowledge I had before and this I do by taking my a priori let knowledge plus some residual between the the measurement and
21:03
The state like mapped on to the measurement. I would get directly from my a priori state and This is multiplied with the K to so called Kalman gain and finding an optimal Kalman gain is Now the hard part so optimal in the sense that you want to minimize
21:25
the error covariance and if we had something like this and Actually we have we can just use this to to predict and to correct and do this iteratively with each new measurement and
21:41
Then we have the basic idea of the then we do we not the basic idea that but then we have the Kalman filter so what happens is that we use our our Transition equation our About our model about our physical process and
22:00
make a prediction with the a priori knowledge also with the error covariance and Then the measurement comes in we can now correct it we calculate the optimal Kalman gain So this is the formula, but it just ignored for now then we do this optimal averaging of our a priori knowledge and the measurement and
22:22
we get an update and Can go back and Start doing this for the next time step And for instance if you if you're looking at some if you're looking on Google Maps, and if you're losing this Measurement update because you're losing your GPS signal you see that this there's always a circle around your point
22:42
Which is starting to increase and this is exactly what happens in that Part in the prediction part if you're losing GPS signal for five Six seconds and the circle starts increasing and then some more measurements come in and the circle goes down again And this is directly what you see in many many GPS applications
23:05
So for our Kalman field and our concrete case The model state equation is just the next position is the current position plus the velocity times DT so velocity times the time step plus
23:21
some noise and The current velocity the next velocity is the current velocity plus some error term so that means I'm not Accelerating or de-accelerating so fast or it's it should be something a smooth process and If I write this in vector notation, I just get this matrix, so this is more or less just transcribing this down to
23:45
To this matrix here in our case assembling rate of This of this watch is one second. So DT is just one second and
24:01
The the measurement equation is also really really easy we are measuring only the GPS Position so with the help of GPS. We only have to position and only implicitly We somehow know something about the velocity. So that means that our state which
24:20
includes the position and the velocity vector gets mapped to only a measurement of the position plus some Yeah plus some error. So this is like a like a really easy equation and What we also know in this case, we know something about the precision error of GPS. I mean you can look that up
24:48
It's something like 10 to 30 meters and this relates to 10 to the power of minus 4 in longitude and latitude and I assumed an error of the elevation of
25:02
100 meters so the the elevation with GPS so never trust it. It's really extremely imprecise and This I take for a recovery covariance So far everything about the math and
25:20
Yeah, I hope you get a you got a good understanding of the basic idea of Kalman So as I said before maybe as a small summary you have some model Some model equation some measurement you somehow optimally average those two to get a better idea of the the current state and
25:42
It really cool library for this is PI Kalman. It's a Kalman filter is smoother and and Yeah expectation maximization Library, it's that simple to use and really powerful comes with many examples and a good documentation besides
26:01
affine or yeah linear Transition matrices you can also define nonlinear and non affine states models It's licensed under a new BSD license and it's written by Daniel Tucker Now we're going to use it To actually help with the curiosities we found in the data
26:24
But before that of course we have to do some some some data wrangling so again, we start up with pandas data frame of our data and yeah, we start looking a bit around and By looking at the tail I realized okay, it's not really one second the sampling rate
26:44
It's it's sometimes less than a second so the difference is not always exactly one second And it's really important that the time interval is uniform for this discrete Kalman filter So what we have to do here is
27:01
that I was just rounding the The Yeah to the next to the next full second the time but what about signal loss so maybe I had signal lost during my bike ride and Yeah, how can we check that easily for instance? We could just use the numpy function diff and just
27:23
Do this over the time index and then we see if the difference of two entries is not one then we know okay, that's got to be some kind of Signal loss and we have here we see we have three times we have a signal loss And we can fix this we need to fix this as I said, we need a uniform time interval
27:46
We can fix this by just using the pandas resample Functionality and this we do with resample one second and we get some additional Rows, which of course not available
28:01
Because yeah, that's the data that I bought and during the time of the of the signal loss But yeah, we needed this we're gonna fill this well use later or Kalman fill that's gonna help us fill this well use Now since the Kalman filter works with numpy arrays we have to go back now we have
28:24
We have our pandas dataframe with a longitude latitude and elevation and we take the value so we Convert it to or we take the the pandas the numpy array from it But we don't use a normal numpy array We use a masked array because PI Kalman expect us and that the the real measurements are
28:46
Yeah, so note the missing values that they are masked and this is exactly what I'm doing here and so the non values are directly masked and Additionally, I just plotted
29:01
the the signal loss points to to get an idea where the signal loss was here was a tunnel for instance and Yeah to to just double check So now basically we are all set and fine for using the Kalman filter So we have our state transition equation F
29:23
This is just the matrix of we've seen before DT is one second Here we have our measurement matrix so just three across six matrix and we have our covariance here covariance area ever and
29:45
We need to define an initial state mean and initial state covariance So like an initial condition that I just take the the first measurement and we give all that to the Kalman filter from the PI Kalman package and Say what we don't know is actually the transition covariance matrix. So how fast I'm
30:07
Like for instance changing my direction on the bike. So this is something we don't really know but we can estimate it and This is what I'm saying here, so my expectation maximization variables
30:21
Variables should be this transition covariance matrix And then we can just fit it and fit it is just call it calling Kf EM so expectation maximization again on the measuring and a number of iterations So this I took to 1000 iterations just to be sure it really converged. This takes a very long time
30:44
Like a few hours and Now that our model is fit we can use it to actually smooth Our measurements and we get in return Mean estimation of the states. I really had at that point
31:04
so now we're going from the measurement to the real to the X to the to the to the states I described before and If I plot now this States, so this is on the right side and to the left are the the measurements
31:23
We see that actually it's it's it's looking much much smoother. So we got rid of all those little bumps you saw and It's it's looking fine and of course we can write it back the smooth track and
31:42
This just basically is we iterate over all the segment points and Yeah, we we fill it back in and then we call the get uphill downhill distance again and we end up with 2677 height meters and this is roughly the about the
32:05
2700 height meters that organizer told me about or told us about in the webpage and So yeah, we are fine. We used the Kalman filter without actually Yeah coming up with some cool smoothing tricks
32:21
I mean I talked to other people I said yeah Why didn't you just like take two or three points and took the average somehow? But then you have a lot of variables you need to fit and here with the Kalman filter We actually only described the physical process The relation between velocity and the position and it turned out to be just fine
32:46
and of course if we do this with the speed speed was a little bit more involved since you we have one had to be careful with the With the points where the signal was lost so the problem is most
33:02
Most sensors GPS sensors already have some kind of Kalman filter inside that means if you're losing the GPS signal and then for instance you go in a tunnel and then you Start getting your first measurements at the end of the tunnel and what this sensor then does it
33:22
still things you're still in front of the tunnel because this measurement is way off what it's Expect what it expects it to be and then it starts like Yeah, going after the real measurement So it realizes okay the measurements are really so I'm really somewhere else and then you get like chumps
33:43
We're really really fast and this is what's what happened here So I had to delete a few points and use the Kalman filter to fill in the more realistic points, but in the end It turned out really good. So I was
34:02
driving according to this about 77 kilometers per hours, which is still fast, but I mean downhill and was checking on my tachometer and there it said something about 70 so the maximum speed so there's still a little bit off and
34:22
What's cool about a Kalman filter you could even now use the data for instance of your tachometer from your bike to actually Yeah to to average The measurements from different sensors to get it even more precise estimation of your of your state
34:42
but this is beyond this talk, but it's possible All right, so this is About about the libraries I used so I want to give a short summary of all the libraries We have seen right now up to that point GPX PI for reading and writing GPS files
35:04
as well as imputing missing values like the elevation which you can do with SI and then as RTM PI and We have visualized our GPS tracks with MPL leaflet which uses internally the leaflet map which is a JavaScript library and
35:24
We've talked about ramadupras polka algorithm there is Actually, there's really an implementation of it RDP which you can just pip install. But as I said be careful with this it's it's programmed recursively and for my tracks it just didn't work and
35:43
Then there's PI Kalman the dead sample Kalman filter I have a few more notebooks that I created during We are chewing I made this talk during the creation of the talk and You can find it here. It's it's total of four notebooks where you can play around with it and I
36:06
Left several parts out but there you have to you can get the full pictures and just play with it Of course credits where credit is due. So The RDP example so this nice animation I took from Mario's cut house the waypoint track graphic from Wikipedia
36:22
The logo on the first slide is from no maps. So if you haven't used this app, it's really really cool So for all the Linux user It's a really nice open street map tool Yeah similar to yet Google alternatives the common prediction correction graphic from pigeons block and if you're interested
36:45
About Reading more about Kalman filter. There's a really good Kalman and patient fillers book by Roger lobby or level and Yeah, he's also using Jupiter notebooks and
37:02
Showing how Kalman filled and patient feel that work Okay, so you can find this talk under that URL and Thanks for your attention, thanks for listening and I'm ready for some questions Thank you, Florian. Is there any question? Hey great talk
37:40
I Was wondering if standard geo libraries like Jita or OGR don't supply like Comparable functionality What sorry I didn't get them what kind of libraries do you know about libraries like Jita or OGR, which are Yeah, pretty standard geo libraries
38:05
I Haven't I haven't actually checked them out but the And the question is do they have a cool? Python interface so I They do have a Python interface I was just wondering if they also
38:25
Supply GPS specific functionality, but you don't know no no I don't know So I was I was doing when I started this research and for me the the most important point was that I can really easily access it from from Python and So
38:42
Maybe I missed it but so far I don't think so that you can easily use them Try Hi, so thanks, and what would you do if you had to deal with?
39:04
GPS data in fit format, you know Garmin is exporting just the feed format Mm-hmm, and there's a Python feed parse library, but it's not uploaded since two years ago Would you use some GPS Babel to? Transform it to these
39:21
Okay, I mean, what would be your approach if you have experience so I would I don't know this format of coming So since I'm quite liking this we're using the the polar products They directly allow you to upload or download everything in GPX but in this case, I would look for converter that surely isn't converter and if it's
39:41
Yeah, a human readable format this common format is it's or is it binary is completely More efficient in memory and in when you like have really long tracks. It's really memory efficient So it's not human readable. Okay, then you might be having a hard time, but maybe our converters for it, I guess
40:07
Fit Files can be imported in the Garmin website and exported there as GPX. It's a cop-out, but okay. We'll see
40:22
Okay, but that's yeah a good point. So if this always problematic if you use a proton a proton Formats then Okay, but then it should be possible to find software that's Transfers it to GPX. I'm quite sure then so often
40:54
GPS data also comes with like a value of accuracy I Don't know if that was available in this in this talk or in this in the system
41:04
Would it be possible to also use that data to make it more accurate if you know the accuracy of the GPS data? Yeah, that should be definitely possible if you have at that point, I mean you have four You have for each point this error covariance matrix
41:21
And if you have then an estimation even what the error is at that point you can also use that additional information you could use the error maybe just as new state variable and then Use your measurement of the error to
41:41
Correct this so I yeah, I would need to think about this, but it should definitely be possible yeah So basically with the help of the common whatever kind of sensors you have having different error variances and even if you have a measurement for the
42:01
Variance for the error then you can Yeah, merge them together to get a better estimation Okay. Thank you Any other question, okay. Thank you very much