Continental Scale Point Cloud Data Management with Entwine
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 |
| |
| Alternative Title |
| |
| Title of Series | ||
| Number of Parts | 295 | |
| Author | ||
| Contributors | ||
| License | CC Attribution 3.0 Germany: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/43562 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
| |
| Keywords |
00:00
Point (geometry)Scale (map)Point cloudData managementLibrary (computing)AbstractionAngleBuildingBlock (periodic table)Scaling (geometry)Process (computing)Point (geometry)Library (computing)BitSimilarity (geometry)Function (mathematics)Open sourceLevel (video gaming)Reading (process)Point cloudBlock (periodic table)BuildingSoftwareVector spaceFilter <Stochastik>Raster graphicsComputer fileData managementAbstractionNoise (electronics)Metropolitan area networkSet (mathematics)Graph coloringDivisorProjective planeComplex (psychology)Multiplication signComputer animation
02:13
Point cloudType theoryNetwork topologyDifferent (Kate Ryan album)Discrete element methodMathematicsTrailSet (mathematics)Electric power transmissionEndliche ModelltheorieImage resolutionWave packetVolumePoint (geometry)Sign (mathematics)
02:53
Multiplication signSoftwarePoint (geometry)DataflowTessellationPopulation densityOrder of magnitudeState of matterComputer animation
03:36
TessellationSoftwareLevel (video gaming)Population densityRaster graphicsPoint cloudPoint (geometry)
03:58
SoftwarePoint (geometry)Point cloudSelf-organizationScalabilityParallel computingQuery languageData structureAttribute grammarOrder (biology)outputParallel portPoint (geometry)Self-organizationFront and back endsSoftwareoutputData storage deviceStandard deviationInformationData compressionAttribute grammarFile formatComputer fileData structureSet (mathematics)Point cloudFluid staticsMultiplicationType theoryTransformation (genetics)Electronic mailing listTessellationComputer animation
05:27
Point (geometry)1 (number)Data structureRepresentation (politics)Network topologyOctreeComputer animation
05:46
Point cloudPoint cloudWeb 2.0Service (economics)Level (video gaming)TessellationPoint (geometry)Data structureVisualization (computer graphics)Analytic setScaling (geometry)Exploit (computer security)Physical system2 (number)Arithmetic meanVideoconferencingResponse time (technology)Real numberEntire functionGoodness of fitDependent and independent variablesScalabilityComputer animation
07:24
AudiovisualisierungExploit (computer security)Roundness (object)Visualization (computer graphics)Server (computing)Computer fileFile systemFile formatBitMiniDiscProjective planeGradientNumberOctreeMathematical analysisComputer animation
08:31
Limit (category theory)Digital filterBound stateImage resolutionMultiplicationNoise (electronics)Electronic visual displayPatch (Unix)Similarity (geometry)TessellationOrthogonalityPoint (geometry)DatabaseAlgorithmQuery languageComputer fileRight angleImage resolutionMetreData structureMereologyState of matterProduct (business)Operator (mathematics)Point cloudBoundary value problemHierarchyFigurate numberEndliche ModelltheorieWater vapor2 (number)EmailBound stateFunction (mathematics)Raster graphicsPolygon meshQuicksortOrder (biology)
10:23
Thresholding (image processing)AlgorithmEndliche ModelltheorieError messageDigital filterMappingQuicksortSet (mathematics)RewritingBoundary value problem2 (number)Different (Kate Ryan album)Point cloudAlgorithmResultantPoint (geometry)HexagonRevision controlAttribute grammarBinary fileImage resolutionGreatest elementService (economics)NeuroinformatikWeb serviceLaptopMetreNormal (geometry)Data structureMereologyMultilaterationContext awarenessDimensional analysisWebsiteArithmetic meanTotal S.A.BitSocial classComputer animation
12:13
SoftwareEndliche ModelltheoriePoint cloudBuildingOpen sourceExploit (computer security)Visualization (computer graphics)File formatOctreeData compressionBefehlsprozessorCodierung <Programmierung>Standard deviationAttribute grammarMultiplication signVisualization (computer graphics)BuildingPoint cloudNumberTessellationMixed realityFile formatType theoryEquivalence relationAnalogyVolumenvisualisierungAttribute grammarData compressionStandard deviationLevel (video gaming)Data structureBitVideo gameExploit (computer security)Endliche ModelltheorieHypermediaDifferent (Kate Ryan album)InformationOpen sourceWave packetLibrary (computing)Single-precision floating-point formatOctreeAudiovisualisierungMetadataAlgorithmWritingComputer animation
14:33
Java appletScripting languageUtility softwareSuite (music)Web browserMiniDiscTranslation (relic)Library (computing)Projective planeProcess (computing)Scripting languageWeb browserBitTessellationRoutingTranslation (relic)Server (computing)Transformation (genetics)File formatDirection (geometry)Point cloudMultiplication signDependent and independent variablesEquivalence relationTowerGateway (telecommunications)Reflection (mathematics)Computer animation
15:38
Lambda calculusGateway (telecommunications)Point cloudEquivalence relationServer (computing)Transformation (genetics)Point (geometry)SoftwareComputer programLambda calculusServer (computing)TessellationMultiplication signLaptopDot productSet (mathematics)Greatest elementData structureStatisticsEquivalence relationPoint (geometry)Reflection (mathematics)Computer programCountingRight angleBoundary value problemOpen sourceInformation privacyProjective planeScaling (geometry)VolumenvisualisierungTransformation (genetics)Point cloudSoftware2 (number)Archaeological field surveyState of matterComputer animation
18:02
Coma BerenicesSampling (music)InformationVarianceMaxima and minimaStandard deviationPoint (geometry)Standard deviationAnalytic setMathematicsWebsiteState of matterSampling (statistics)MetreSet (mathematics)Computer animationJSONXML
18:30
StatisticsSampling (music)Maxima and minimaVarianceInformationTessellationNumberAttribute grammarComputer fileMereologyLink (knot theory)Set (mathematics)Point (geometry)Web 2.0Network topologyMappingServer (computing)Descriptive statisticsMathematicsFile formatOrder (biology)BitMetreSharewareComputer reservations systemData structureMultiplication signProjective planeType theoryOctreeSpacetimeTransformation (genetics)Web pageService (economics)Bound stateAbstractionState of matterSeries (mathematics)Image resolutionCombinational logicBlack boxData storage deviceMetadataCoordinate systemBlogFlagOntologyWebsiteCASE <Informatik>Default (computer science)Twin primeElectronic mailing listLevel (video gaming)Social classFluid staticsPhysical systemSubsetQuery languageRight angleVideo gameInstance (computer science)Computer animation
Transcript: English(auto-generated)
00:08
OK, we're going to get started with our next talk. Thanks for coming to this last session. So now we have Connor Manning from the United States talking to us about continental scale point cloud management with Entwine.
00:22
And it really is continental scale. So let's go. All right, thank you, Adam. Like you said, I'm Connor Manning, and I'm here to talk to you about really, really large point clouds with some open source software called Entwine and a little bit of Poodle. So first, I'm going to go over a little bit of some
00:43
of the open source software tools that make up these projects. Poodle or PDAL, either pronunciation is fine, and Entwine. So first, I'm going to talk about Poodle a bit. It is the point data abstraction library and is used to translate and manipulate point cloud data.
01:02
So for people that are familiar with GDAL, which is probably quite a few of you, it has a similar scope in point cloud land that GDAL does in raster and vector land. And Poodle provides you a processing pipeline to develop workflows which are composed of stages. And stages are readers, writers, and filters.
01:23
So an example of a simple pipeline might be something like read a couple last files, re-project one of them to match the other, and write the output to a TIFF. But they can also get quite complex because these stages are composable, you can develop some pretty complex workflows.
01:41
I'm not going to go through the details of this one, but we're doing some reading from an EPT data source, which is one I'm going to go over shortly. We do some reprojection, denoising, and what we end up with is just the ground points from this data set, and we write the output to both the TIFF and a LAZ file.
02:02
So the building blocks that Poodle gives you are very powerful. It's pretty unopinionated about how you compose your workflows. It gives you small building blocks on which to build. So you might imagine some workflows, or probably a lot of people that work with point clouds already have a lot of workflows in mind. So for example, you might be seeing how close
02:21
your trees are to your power line over your train track. Or maybe you're concerned with stripping all that out and you're interested in the terrain itself. Maybe you have some post-earthquake point cloud model, and you'd like to figure out how to turn that into a dem at different resolutions, so you're playing around
02:42
with some settings to figure out how to do volumetric change detection type stuff. City planning type things, setbacks from curbs, figuring out where to put signs, et cetera. Or maybe you're just measuring something in a place that's not very easy to reach all the time.
03:00
So probably everybody has workflows in mind, and a lot of people can think of software and tools that do that, but what about when your data, instead of looking like those, looks a little more like this? Like this is a, I think, 60 billion point city gathered with mobile lidar, so they drove cars around with lidars attached. Or countries, this is all of the Netherlands,
03:21
640 billion points, many terabytes. Or large states, this is Kentucky and the USA. So data like this, at this magnitude, is sometimes delivered as flights, but more frequently will be delivered as lots and lots of full density tiles with fixed width,
03:40
which can be very difficult to work with. People aren't delivering map tiles and raster tiles this way, but you do see point clouds delivered this way a lot. So I'm gonna talk to you next about a software that I think is a better way to do delivery of lidar data. And the software behind it is called Entwine.
04:01
So it's a point cloud organization software that enables you to efficiently query, analyze, visualize, and enrich your very large point cloud collections. It's very scalable, up to trillions of points, which we'll see shortly. And it's built with parallelization in the cloud in mind.
04:22
So what Entwine does is generate a new format called Entwine point tiles, or the EPT format. And this is a static file structure that's agnostic to the encoding, so you can swap out the backend compression depending on your use case, or you can use the industry standards like Lazip, et cetera.
04:41
It's got a flexible attribute schema, so you are not bound by fixed predefined sets of types. And it is fully lossless. And a really important thing here is that it's lossless in the strictest sense of the word such that the input data set is fully reconstructable from EPT. And now this is really important
05:01
when you're looking at multiple terabyte data sets, because if you're gonna undertake a transformation that converts these multiple terabytes to another multiple terabytes, it would be great if you didn't have to keep both of them around, and you could put one in cold storage. So the EPT format has been designed with maintaining every aspect of the information from the input in EPT itself
05:22
so that you could theoretically reproduce the input set completely from EPT. So this is just a visual representation. I mentioned that EPT is an octree structure, and this is kind of what an octree is visually represented. You can see the point budget slider being slid up and down,
05:41
and as we decide, yes, I can load more points, or no, I want fewer points, we can discard the ones that are least relevant depending on what we're currently looking at. So it's kind of like slippy map tiles, web map tile services for point clouds. So this is a bit longer of a video, but I'm just gonna show some of the visualization
06:03
and scalability of how big the EPT stuff can scale to. So this is a four trillion point data set, I think slightly less, but approximately four trillion individual points for the entire United States interstate system.
06:20
So as we're zooming around, you can see we're hopping all over the country, but the part that we're interested in fills in quite quickly. And some people are probably thinking, well, yeah, visualization, I mean, it's kind of cool, but that's really not why we're using point clouds, right? But the key thing to kind of think about and imagine here is that if we can load the data that we care about very quickly on demand
06:42
with millisecond response time, we can probably do a lot of other things too. So after this video finishes playing, I'll talk about some of the analytics and exploitation that you can do with this data structure. I think it's another 20 seconds or so. Does anybody have any early questions?
07:00
Something real quick? Good. Company that I don't think I can say the name of. Sorry.
07:21
The video's the only public thing. So the data is structured as a whole bunch of files on disk in octree format. So there's no server typically, you would store them in something like S3
07:41
or distributed file system or bare metal server. And it's, you can use any encoding you wish that data in particular and most LIDAR data, we use last zip and it's a bunch of last zip files with some metadata that let you access them this way. So like I said, Entwined scope isn't really just about visualization. We try to be somewhere in the middle of this gradient
08:03
between being able to view your data and being able to do things with your data, probably a little bit more towards the exploitation side, but somewhere in the middle. There are a lot of projects way over at the green end and a number of them way over at the blue end, not quite as many in the middle. So EPT, it doesn't try to be the best at visualization,
08:22
but it tries to be the most useful all around format. So I'll talk about some analysis and exploitation, like I said, and this is gonna be using Poodle. So I'll go through just a couple of workflows and how you might use EPT to solve them, similar to before. So for example, maybe you're interested in this patch,
08:40
this lovely patch of a forested hill, but what you're really interested in is modeling how the water might flow over it. So you'd like to get rid of all that vegetation. And what you really want is some sort of watertight mesh or a raster or some other derivative product from the point cloud. So like before, you can probably think of ways to do this, right?
09:00
You may have done this before or something similar, but what if that patch of land is in a, I think this one's 500 billion point data set that spans multiple terabytes, how maybe that complicates it a bit. You're probably now thinking about, well, I need to go query the tile database, figure out which overlaps there are, then I have to do a bunch of downloads and then use them.
09:21
It can be difficult when your data exists in an ecosystem this large. But with the EPT reader with Poodle, using the spatially accelerated data structure, it's actually quite easy. So you can see that at the top there, we have an EPT reader and the important part there is that we're querying by only the bounds we care about. And then we do some operations on it.
09:41
So we're detecting noise, we're running a ground algorithm and then filtering the non-ground points and then writing the output to a TIFF. And even in a multi terabyte data set like that one was this would probably take only a few seconds around the order of minutes. Another kind of orthogonal example is this is the state of Kentucky,
10:01
also half a trillion points. How would you do something like generate a reasonable boundary for it, right? You might think taking the headers of the files and mashing all the bounds together but then you get a bunch of jagged edges. It's not necessarily something you want to display as kind of your user facing footprint.
10:21
And this is also really easy with the EPT reader because it's structured in a hierarchical manner by resolution. So the key part here is that resolution there, it's quite coarse, so I'm querying 400 points that are 400 meters apart typically and then I'm just using Poodle's hex bin filter to create a hex boundary out of that data. And like I said that Kentucky set is multiple terabytes
10:42
and I think this takes about five or six seconds or so on my laptop. And another thing you can do with the EPT structure and with Poodle is you can do enrichment to the data. And what I mean by that is that you can add new attributes later.
11:01
And at the bottom there, so you don't need to add them or you don't need to add them to the exact set itself so there's no rewrites involved. You can write these locally and this is something we'll see a little bit later. So for example if you have a web service but you don't have write access to it, can you swap out attributes for it with attributes that you've decided?
11:20
And examples of that might be things like normals that you're gonna reuse for lots of different algorithms or workflow results like classifiers. A typical example would be replacing the classification of some service with something that, with a better version of classification algorithm. And there's a lot of stuff on here.
11:41
A lot of it's not all that important but the point to note here is the EPT add-on writer which maps dimension, that's the result of a workflow. So we've assigned a classification with some awesome ground algorithm and then we map that to a path. And in this example it's on our local computer
12:00
and then later we can map these paths back into attributes in the point cloud. So if you have all sorts of different classifications for different contexts or you're comparing different algorithms, you can swap them out kind of dynamically this way. So now we're gonna pivot a little bit and some of you, I think there have been a lot of talks about seizing 3D tiles. I actually see a shirt out there of 3D tile shirt.
12:23
So some of you might have been thinking, well this sounds kind of like 3D tiles. What is this? What are the differences? Why would I use one over the other? So first what they are, cesium is a rendering library and 3D tiles is a format. So the analog would be cesium is like,
12:40
well I guess poetry which I haven't mentioned. Poetry was the visualizer we were using earlier. But 3D tiles is the format. And in general cesium is really good for mixed media types because you can do things like mix up your building models and train models and point clouds and you can load them all up in a single renderer. And they've also got flexible tiling formats so you can define how you want to split your data.
13:03
And it's just a really robust rendering library. But for point clouds in particular, and I'm gonna compare it with EPT here, there are some drawbacks. And these aren't really, it's not things that cesium is like missing that they should have added,
13:20
but their scope is a little more toward the visualization side. So when you start to look at it for things like exploitation, you're missing some important things. So one example of an advantage of EPT over 3D tiles is that you can build EPT with open source tools which would be entwined. With cesium you need to use cesium ion
13:40
for building things. And in general the format's just more oriented toward visualization. You can't use standard LIDAR encodings. The compression's optimized for GPU. So if you were to write algorithmic things against it, it might be a little clunky. And in general, non-renderable attributes are deprioritized. So for example, if you upload something to cesium ion,
14:03
it strips out the things that aren't renderable, like your GPS time and your return number, scan angle, which are all really important to people that really care about LIDAR and are using it for driving things. And the last one there is that the metadata for equivalent EPT is much larger in cesium because EPT is an implicit octree.
14:22
We can embed a lot of information just in our node structure while cesium explicitly has to list a lot of implicit things. And that's on the roadmap for them. So I'll come back to that in a little bit and we're gonna switch again real quick to a new project I've been working on called EPT tools.
14:43
And this is a JavaScript library that can run in the browser or in Node.js and it has tools to work with EPT data. So right now there aren't very many. You can see there's only three tools. One of them is validate so we can check out the metadata and make sure it looks good, which would be useful if you were creating your own EPT and not using a twine.
15:01
And then to go back to the 3D tile stuff, there's a tile command that translates EPT to 3D tiles as a one-time transformation. So this would be duplicating your data in yet another format. Or perhaps more interesting would be the live translation of EPT to 3D tiles. And that looks something like this. You just serve an EPT project route
15:21
and then you point cesium at that route and cesium makes 3D tiles requests that are automatically converted by the server from EPT. So EPT serve responds to that with 3D tiles data directly. And more interesting than that though is that that's actually item potent and stateless
15:41
so you can run that in a Lambda. So with something like AWS Lambda and API Gateway, for example, or the equivalent in some other cloud, you can have a serverless reflection of all of your point clouds in EPT as 3D tiles for very cheap because you're not paying for server time. You're paying for the milliseconds of the actual transformation
16:02
so you don't have a server running all the time. So the last thing I'm gonna talk about, just a couple minutes left, is an example project of using tools like this to manage a very large data collection at scale. So some of the LIDAR people from the US
16:21
or people that have worked with LIDAR for a long time might be familiar with the US Geological Survey 3DEP program which gathers lots and lots of LIDAR. So here's some stats about the data set. It goes back about 15 years, 70 plus terabytes. It existed as tile data in S3 as LAZ.
16:43
So leveraging this data, so the USGS just had it sitting there for a long time and people were downloading it, but how can we leverage it and do other things? Like can we look at all of it? Can we write software against it? Can we query and filter it? And most importantly, can we get Amazon to pay for it perhaps?
17:01
And the answer to that was yes, actually all of these. So through the AWS public data sets program, Amazon paid for the compute time for converting all the data from tile data to EPT as well as hosting in S3 for at least the next two years. And here's kind of the portal of what we ended up with.
17:24
So you can see all the footprints. I talked about how these were generated before. All of these, so you can see the point count up top, over 10 trillion, but all these boundaries were generated in I think like four or five minutes on my laptop. So they're not perfect, they're quite coarse, but it's pretty good for something like this
17:41
and you wouldn't be able to do this with every structure. And so you can see down at the bottom there, there's poetry and plazio little dots. Those are two open source renders. And on the right you have cesium, which goes to the on-demand reflected 3D tiles transformation. So this data only exists as EPT,
18:02
but we do reflect it as cesium as well. Here's an example of just what you can do with this website and they're filtering down to 500 billion points or so and just loading that all up. This is poetry. And you can also run analytics.
18:20
I mean it's full EPT data sets available over HTTP. So do things like sample the Zs. Actually this data set's quite noisy as you can see. The standard deviation of the Zs is 300, but this state has an elevation change of approximately 10 or 20 meters because it's Iowa. Or you can also do sampling on the classification.
18:42
So this is counting, this is querying at really low resolution, that same data set, a really large one, and counting the values that come back as classification. You can see you have one that's kind of weird there, the 229, I'm not sure what that would be. But that's all I got. I'm not gonna put up a whole bunch of links.
19:02
You should only need this one because after the session's over, I'll have a blog post on the main page there with these slides and with all the links to all the projects I've talked about. So if you need to remember a link, that's the only one you should need. If the blog post isn't there yet, when you check, give me a little bit of time. But thank you, that's all I've got.
19:26
Thanks, Connor. Does anyone have any questions? I do have swag for questions. What's the time, or what's the roadmap for ATP tools? I know there's only three that you listed. What more do you plan on adding?
19:41
Well, this is the first time I've actually publicized it. I've given it out to a couple people that have used it, but it's probably gonna, it's going to depend on community involvement. What do people think would fit in this space and say, hey, I need this, there should be this tool. So people like you will be the drivers of the roadmap. So, and you get a spork, entwined sporks.
20:07
So I have a Dixa for you, Connor. When you're writing add-ons, do they consume the same amount of space on your storage as the original data set? No, so the add-ons take up, so for example, an add-on, you can specify the type,
20:21
like for classification, I think it's 16 bits, eight or 16 bits, one of the two. Eight, eight bits, thank you, Martin. It's eight bits, so if you're writing your own classification, it will take up eight bits times the number of points that you actually run the classifier on. You don't have to, so I mentioned the octree structure,
20:41
so it's a tree structure. You don't have to write an add-on for the full set. You can write it for a subset, so that all those queries, like the bounds queries we were talking about, or the resolution queries, if you have add-ons that only go up to a certain resolution, you can write those as a subset. So they will only take the amount of space of the attribute type times the number of points
21:00
that you actually apply them to. Cool, thanks. Martin. Martin, I'll bring the microphone. I appreciate your slide on lossless in the beginning, and I appreciate that it included ordering. Yes. So does that mean if I have the state of Iowa
21:21
in 1,700 tiles, and I give it to the Entwine encoder, that I can get back those 1,700 tiles in the same naming with every point in the same order? And if yes, how did you implement that? Yes.
21:41
So on the Entwine.io website, there's a link called Entwine point tiles on the sidebar, and that's the description of the format. So the key parts, as far as specifically what you asked, for every file that comes in, we add a new attribute called the origin ID, which maps back to the combination
22:00
of the file's full metadata, so everything in the last headers, all the VLRs, all the EVLRs, et cetera. So we store all that. We store the file name itself. And so by default, we don't include a point ID because typically they're already ordered by GPS time, so we use GPS time as an implicit ordering, but you can set, there's a flag on Entwine
22:22
that you can say, store point ID, and it will tag every single point with its order in its origin file. So hopefully that answers it. Anything else? Yeah, we have a few minutes, so more questions or welcome, or? More sports to give away.
22:42
You'll get one. I, well, first of all, thanks, Entwine. I think I saw a demo earlier on the web where you switched between the US and then Holland and then maybe Denmark on the fly. Was that the multi-CRS thing, or was that everything was re-projected?
23:01
In that specific case, I think everything was re-projected, so for the public services that we kind of host as demos, we actually do something that all the LIDAR people won't like very much is we put it all in Web Mercator because then everybody can interact with it very easily. I mean, it's demo data, right? It's not really meant for everything,
23:23
but yeah, so in those instances, that was all Web Mercator. Something I didn't mention about the 3D tiles one that's actually a pretty nice benefit of the EBT tool stuff is that CZM only supports, I think, lat-long Web Mercator and ECEF
23:40
or some combination thereof. I think the points are ECEF, but the metadata must be lat-long. Part of the on-the-fly transformation of the EBT tool stuff is doing the reprojection from whatever your data set is in, so if your data is all in UTM or some local coordinate, as long as you have the coordinate systems and they can be re-projected to show up correctly on a globe, you can do that translation, but in your specific case,
24:01
I think all that data was in the same CRS. Okay, thanks. Anyone else? Yeah, we got one. Time for one super short question.
24:20
One more. Oh, Greyhound. What was that? Where is Greyhound? Greyhound? I actually should have mentioned this, I guess. Some of you guys might have seen me talking about Greyhound a couple years ago, which was a server that kind of did a lot of these features, and this is the first time I'm presenting EPT. So Greyhound was a live server, so you had to have a live server up and running at all times,
24:41
and what Greyhound did was translate a black box format that wasn't documented to anybody, but it served data kind of like EPT does. That black box format that you weren't supposed to look at because we wanted the abstraction layer of Greyhound has been solidified into EPT, and because we've implemented it as, we've implemented the ability to read it statically
25:03
in things like Poetry, et cetera, and Poodle, there's no server involved there. So Greyhound's kind of, the need for it kind of goes away when you have a static format that's more recognizable, or more usable. I think the space for Greyhound, or what was Greyhound might move towards the EPT tools kind of thing,
25:21
like if you do want a live server for some reason, or maybe it's a series of lambdas, I think that's where it would go, if you want to do filtering on the server or something like that. So probably Greyhound doesn't exist anymore, but would be in EPT tools. All right, thanks everyone, that's it for this talk.