What's new in Cesium: the open-source alternative for 3D maps
This is a modal window.
Das Video konnte nicht geladen werden, da entweder ein Server- oder Netzwerkfehler auftrat oder das Format nicht unterstützt wird.
Formale Metadaten
| Titel |
| |
| Serientitel | ||
| Anzahl der Teile | 188 | |
| Autor | ||
| Lizenz | CC-Namensnennung 3.0 Deutschland: Sie dürfen das Werk bzw. den Inhalt zu jedem legalen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen. | |
| Identifikatoren | 10.5446/31758 (DOI) | |
| Herausgeber | ||
| Erscheinungsjahr | ||
| Sprache | ||
| Produzent | ||
| Produktionsjahr | 2014 | |
| Produktionsort | Portland, Oregon, United States of America |
Inhaltliche Metadaten
| Fachgebiet | ||
| Genre | ||
| Abstract |
| |
| Schlagwörter |
FOSS4G 2014 Portland11 / 188
7
10
14
15
16
23
24
25
28
29
33
37
39
40
43
45
46
48
50
56
64
65
69
72
74
82
89
91
98
102
107
111
114
118
128
131
132
135
138
141
143
147
149
150
157
158
161
164
165
166
173
174
175
179
185
00:00
AlgorithmusProgrammbibliothekVideokonferenzGlobale OptimierungTermReelle ZahlInternetworkingWurzel <Mathematik>DatenfeldKartesische KoordinatenBrowserMailing-ListeSicherungskopieOpen SourceDifferenteDomain <Netzwerk>Speicherbereichsnetzwerksinc-FunktionRechter WinkelDemo <Programm>BenutzerbeteiligungSoftwareentwicklerEinsLie-GruppePhysikalischer EffektAggregatzustandVisualisierungOffene MengeMinkowski-MetrikComputeranimation
01:56
DatensatzStatistikMAPVideokonferenzPhysikalisches SystemSatellitensystemTeilmengeTermVirtuelle MaschineVisualisierungDatentransferBrowserDateiformatEndliche ModelltheorieLaufzeitfehlerStandardabweichungBenutzerbeteiligungOrtsoperatorApp <Programm>StichprobenumfangElektronischer DatenaustauschNormalvektorCAN-BusBitrateOpen SourceARM <Computerarchitektur>Rechter WinkelComputeranimation
03:27
Weg <Topologie>Kontextbezogenes SystemMinkowski-MetrikProgrammierspracheBitSatellitensystemWinkelServerDifferenteEinsStatistikZoomComputeranimation
04:53
Natürliche ZahlMAPBitPolygonnetzSatellitensystemDatenfeldDateiformatSichtenkonzeptStreaming <Kommunikationstechnik>Minkowski-MetrikBenutzerbeteiligungBildgebendes VerfahrenWellenpaketGeometrische QuantisierungMatchingRuhmassep-BlockTwitter <Softwareplattform>
06:10
FrequenzWellenpaketLinearisierungMultiplikationsoperatorVideokonferenzGeradeZoomRechter WinkelApp <Programm>
06:46
TypentheorieInternetworkingKlassische PhysikDemo <Programm>App <Programm>Projektive EbeneSoftwareentwicklerComputeranimation
07:16
VisualisierungVerschlingungVersionsverwaltungKartesische KoordinatenMultiplikationsoperatorDemoszene <Programmierung>ComputerspielTVD-Verfahren
07:56
Gebäude <Mathematik>MAPApp <Programm>CodeOffene MengeMapping <Computergraphik>Bildgebendes VerfahrenInformationTelekommunikationWellenvektorMetadatenRechter WinkelVektorraumBitmap-GraphikSchätzfunktionDifferenteComputeranimation
09:00
Rechter WinkelInformationInternetworkingKartesische KoordinatenBrowserMeterWeg <Topologie>Demo <Programm>App <Programm>Bildgebendes VerfahrenProfil <Aerodynamik>WellenpaketArithmetisches MittelBitGeradeMereologieSoundverarbeitungMultiplikationsoperatorOrtsoperatorComputeranimation
10:41
Bildgebendes VerfahrenCodeDynamisches SystemInformationMehrrechnersystemOrdnung <Mathematik>SchaltnetzProdukt <Mathematik>WellenpaketMAPGraphikkarteVektorraumIntegralSoftwaretestArithmetisches MittelBildschirmmaskeLeistung <Physik>MereologiePhysikalismusPolygonnetzRechenschieberSatellitensystemSpeicherabzugTermVisualisierungZahlenbereichDatenflussFlächeninhaltÄhnlichkeitsgeometrieStochastische AbhängigkeitCASE <Informatik>Prozess <Informatik>SystemverwaltungMetropolitan area networkTranslation <Mathematik>Graphische BenutzeroberflächeNummernsystemÄußere Algebra eines ModulsPunktQuaderKartesische KoordinatenUmsetzung <Informatik>Installation <Informatik>MetadatenFokalpunktDateiformatGraphfärbungPlastikkarteElektronische PublikationClientWeg <Topologie>WhiteboardWeb SiteEndliche ModelltheorieSystemplattformWeb logsinc-FunktionSingle Sign-OnMultiplikationsoperatorStandardabweichungSchreiben <Datenverarbeitung>Mapping <Computergraphik>TesselationRechter WinkelDienst <Informatik>Demo <Programm>BenutzerbeteiligungVolumenvisualisierungOrtsoperatorSoftwareentwicklerRelativitätstheorieVideokonferenzBetafunktionBitPortabilitätTriangulierungGüte der AnpassungEin-AusgabeOffene MengeInteraktives FernsehenElektronisches ForumSichtenkonzeptMinkowski-MetrikHumanoider RoboterApp <Programm>Computeranimation
18:55
CodeHardwareImplementierungInformationStatistikTransformation <Mathematik>TypentheorieMAPBildschirmfensterVektorraumIntegralDreieckSoftwaretestBitGeradeInhalt <Mathematik>Inverser LimesMereologiePolygonnetzSpeicherabzugVisualisierungWechselsprungZahlenbereichE-MailFastringVersionsverwaltungGüte der AnpassungReelle ZahlDifferential-algebraisches GleichungssystemProzess <Informatik>NamensraumGraphische BenutzeroberflächeRepository <Informatik>Arithmetische FolgeDatentransferUmsetzung <Informatik>MetadatenMailing-ListeRahmenproblemHierarchische StrukturElektronische PublikationPräprozessorOpen SourceEndliche ModelltheorieMultiplikationsoperatorPlug inMapping <Computergraphik>Rechter WinkelDemo <Programm>BenutzerbeteiligungDemoszene <Programmierung>App <Programm>Bildgebendes VerfahrenDatensatzLineares GleichungssystemFrequenzGebäude <Mathematik>Produkt <Mathematik>WellenpaketElementargeometrieGruppenoperationHydrostatischer AntriebLastMaterialisation <Physik>Physikalisches SystemTermZellularer AutomatQuick-SortSystemaufrufEinflussgrößeServerMatchingIntelligentes NetzFächer <Mathematik>Codierung <Programmierung>SchnittmengeDateiformatPunktwolkeKnotenmengeTextur-MappingKollaboration <Informatik>VolumenvisualisierungSpezifisches VolumenGamecontrollerSoftwareentwickler
27:10
DatensatzProgrammbibliothekProdukt <Mathematik>WellenpaketSoftwaretestGruppenoperationMereologieProjektive EbeneTeilmengeZellularer AutomatEnergiedichteSummierbarkeitAppletMailing-ListeDateiformatOpen SourceEndliche ModelltheorieMapping <Computergraphik>SatellitensystemUmsetzung <Informatik>MeterC sharpPlug inComputeranimationVorlesung/KonferenzBesprechung/Interview
29:08
Formale SemantikGebäude <Mathematik>WellenpaketBildschirmfensterBitUmsetzung <Informatik>AppletDateiformatDifferenteKonfiguration <Informatik>Güte der AnpassungRenderingC sharpComputeranimation
30:11
Bildgebendes VerfahrenMathematikSoftwareTelekommunikationProgrammbibliothekGebäude <Mathematik>MAPIntegralBitFunktionalVisualisierungZahlenbereichE-MailServerComputervirusGemeinsamer SpeicherPunktBildschirmsymbolSchnittmengeKartesische KoordinatenShape <Informatik>FirewallRichtungDateiformatOpen SourceSichtenkonzeptWeb SiteDifferenteMultiplikationsoperatorStandardabweichungKollaboration <Informatik>TesselationDemo <Programm>BenutzerbeteiligungApp <Programm>Natürliche ZahlSymmetrieTopologiePlotterWellenpaketGrenzschichtablösungArithmetisches MittelCOMEinfach zusammenhängender RaumForcingGeometrische QuantisierungLastPolygonnetzStichprobenumfangZellularer AutomatMatchingDean-ZahlDatenfeldRandomisierungRepository <Informatik>Wort <Informatik>PunktwolkeSchreib-Lese-KopfElement <Gruppentheorie>Plug inMapping <Computergraphik>Minkowski-MetrikRechter WinkelWeb-ApplikationVorlesung/KonferenzBesprechung/Interview
36:16
DivisionJensen-MaßWeb-SeiteElement <Gruppentheorie>BenutzerbeteiligungOffice-PaketComputeranimationVorlesung/KonferenzBesprechung/Interview
Transkript: Englisch(automatisch erzeugt)
00:00
So, I was curious, how many people have heard of cesium before this talk? Wow, awesome. How many people are using it or evaluating it right now, considering using it? Okay, cool, hopefully we'll see more hands at the end of this. So my name is Patrick Hosey, I'm a developer from a company called Analytical Graphics.
00:21
And for this talk, you know, I want to talk about cesium, maybe like a pretty quick intro, but more about what's new since false 4G NA 2013. So cesium is an open source JavaScript library for doing 3D globes in the web browser. It's built on WebGL, so it's very fast.
00:42
A lot of developers have a long history of doing 3D graphics in OpenGL, so we've done a lot of optimized graphics algorithms. It's being used in a lot of different fields, fields that we didn't even anticipate it being used. Certainly, AGI's roots are in aerospace, so we have a lot of people using it in the aerospace field, but also geospatial is widely used, as well as some other ones
01:04
that maybe we didn't expect, sporting, entertainment, even some real estate folks have popped up, people doing air traffic visualization, which is a great list of different problem domains. So in terms of what's new, you know, I want to talk about what's new in the API
01:22
with the new features. But the other thing that's new that's cool is there's a lot of applications have came out built on cesium, so I wanted to show some of those. I'm going to try to do all these as live demos. I know the Internet's been going in and out. I do have some videos as backup if we need. If everyone wants to start streaming video right now, that would be really, really useful
01:41
for these demos. So the first one is probably maybe the most well-known one, which is San. When people hear cesium, they go, well, tell me about San. We heard that NORAD tracks San and uses cesium, so I'll bring up this. This one is a video because it only runs on Christmas Eve.
02:02
So NORAD has this big elaborate system for tracking Santa Claus on Christmas Eve. They have sonar, they have satellites in geosynchronous orbit, they have fighter jets, they have Santa cans, and they use all of this technology to see where Santa is and to give us Santa's position so that on a web map we can show where Santa is with an
02:23
animated 3D model here. So this app is built on top of cesium, AGI built this. We've done it a few years in a row now, but new this past year was the 3D model we see here, the animated model, and this is using a format called GLTF, the GL transmission format, which is something I work on with Kronos, which will be an open standard for
02:43
streaming 3D models to the web browser. So think of a format like Kalata, that's XML based, that's for interchange between 3D formats, 3D tools, I'll replay that, whereas GLTF is for getting it to the web for runtime visualization. In terms of WebGL acceptance rates, some people ask, well, where does cesium run?
03:04
How many machines can it run on? So this went to 20 million users in December, and we had about a 50% WebGL success rate. So we reached 10 million users. And these are all sorts of users. This isn't just tech community, right? This is everyone, the general population. So I think 50% is pretty good, and 50% in rising, too.
03:23
So we'll see what the stats are this December. Okay. So next up is something AGI is building on top of cesium, and this is for our space situational awareness. See if the link works.
03:43
So AGI does a lot of work in space, and we're tracking satellites, and we want to know where satellites are, where they will be, and hopefully not if they're going to hit each other, potentially come near each other. So this here is called the space book. Let me try to resize it a little bit. Oh, it's very big.
04:04
Okay. And I'll zoom out, and these are all active unclassified satellites, and this is real data coming from AGI servers. I'll speed it up a little bit, and we can see them moving. We can zoom in and take different angles on them, and then I'll zoom all the way back
04:24
out. And we can do things like we can take the stats and say, well, show me only operational ones. I know. There's a lot of debris out there, too. It's wild.
04:41
And then this is still our full 3D globe, but it also does 2D, and that's the same API. It just does. It just switches it to 2D, and then you can spin it around and all that kind of stuff. We can take it to two and a half D. We call this Columbus view.
05:02
This is particularly exciting when you have satellites because you see the geo belt very clearly out here, and I'm not a space guy, but I'll pretend a little bit to be a space guy, so. And let's switch it back to 3D. And then this is just some image.
05:21
This is natural earth imagery that we tiled up using TMS, and I'll switch it to Bing imagery. Coming in pretty fast. And I'm going to turn on some terrain data. I know some folks are going to Mount St. Helens for the field trip tomorrow, so let's go do a preview.
05:40
And here, another thing that's new with cesium is the streaming terrain. We've now published the format. Last year we were streaming height map data. Here we are streaming mesh data. It's quantized mesh data that's really tuned for rendering, so it's very concise. We get in a web worker and we very quickly create the final mesh that we're going to
06:00
stream in. And this is global terrain, so another place I really like to go is Seneca Rocks. And this is a place I used to rock climb when I was younger, and this was also a training ground for World War II. I'll zoom straight down. And this is amazing. So this fin, oh, the train is not coming up here yet.
06:22
Well, this fin actually peaks like straight up. Here we go. How many people are streaming video right now? So here, this peak is really amazing to climb. People climb to the top of it. It's like 600 feet tall. Then you can look out all around it, and I'll come back out home.
06:44
So that's our SSA app. So let's see. Okay, so this D3 demo is something that we did last year, too. This was actually a hackathon project, and we started this in one day, two of our developers,
07:04
because we were like, well, hey, we really like D3. I wonder what type of apps we could do with cesium and D3 together. And the Internet's looking like it's slowing down on us. Okay, so here we have the classic health and wealth of nations. That's data that you see with a lot of D3 visualizations.
07:22
And you see the D3 visualization, where on the x-axis, you see the income, and on the y-axis, you see the life expectancy, and then over time, you're seeing how these vary. But what we're also seeing here is the Columbus View version of it in cesium. And these two are linked, too. So I could mouse over one of these, and it gets highlighted, or I could mouse over
07:45
in D3, and it gets highlighted out here in cesium. And then you could also switch this to 3D, so it's still the same API. Cool, so I want to show two more apps, and then I'll go into some of the features.
08:03
So Nick, there's a company that's been doing a lot of work with cesium. They've been building some very cool apps on top of it, and they've also been contributing a lot to the code base. So one app that they're building is the National Map. This is the Australia National Map. So Australia has fantastic open data within their government.
08:22
And this map here is built between NICTA, working with the Department of Communications, and Geosciences Australia. So here they have a lot of different raster data. I'll turn some on. And then a wider array of vector data, so I'll come down. I've been playing with the population estimates.
08:42
I'll turn that on, and that's an overlaid image layer. Then I could click on one of these features and get some metadata about it coming up here on the right. And then maybe I'll go over the broadband set, turn that on. Then we're getting full 3D, and I could go for info for some of this.
09:01
And I could maybe change the translucency. Let's make that really translucent. And this is in beta right now, but you can check it out. Everything that I'm showing here, this is all online. So you could go run these yourself. And the final demo I will show is also from NICTA, which I think is very exciting stuff here.
09:22
So this is an app called Duorama that they built on top of Cesium. And it really features the Cesium streaming, terrain, and imagery in a sporting application. We're here, I'll speed it up a little bit. So you get these guys going, then I'll slow it down. So here we see gliders.
09:42
We have several gliders going. And they all had GPS on when they did their trip, so they have position, time, information. And then we're playing it back inside Cesium. And this has the streaming terrain data, which has probably 30 meter in this part, as well as the streaming imagery, which is Bing imagery here. And then there's some post-processing going on to get this
10:02
kind of old-school film effect. Then I could switch between the individual people paragliding and look at each of them. And within each one, you get this height profile, this terrain profile. And it's really interesting to see how they change altitude. They fly off to change altitude.
10:20
Then you'll watch them fly and go along the ridge lines, the mountains. Very cool stuff. And what's awesome is, I mean, this is JavaScript and WebGL all in your browser. So this is duorama.com. If you have some GPS tracks for things you've done, go upload it to here. It's pretty nice. Cool, okay, I'm glad the Internet held up pretty well.
10:42
All right, so a lot of people ask me, they go, well, why did AGI make cesium? And it's a very fair question. A lot of times in a technical talk, I don't even address it at all. But it's such a common question. There's two reasons we made it. One was we had customers that needed cross-platform visualization.
11:00
And we had a bunch of C++ and OpenGL code. And we thought about porting it. But at the time, WebGL was coming out. And we said, well, hey, if we can get on WebGL, we can run with no install, don't need admin rights, don't need a plug-in. We could go cross-platform, cross-device, and that would be awesome. So that was one reason why we did it.
11:20
The other reason is we needed it. We needed it for SSA work, the space app that I just showed. And then the next question that comes up is people ask, well, how do you fund cesium development? If you look at the GitHub, there's quite a few people that are working on it. We've been working on it for quite a while. Where's the funding coming from? So AGI does sell commercial terrain servers, provide data for cesium.
11:44
And we're also soon gonna offer support, enhance our space visualization and integration with some of our products. So we are continuing developing this. We didn't just make cesium and then throw it over the fence and said we're done with it, we're really active and it's growing actually quite a bit since our 1.0 release.
12:04
But it's not just AGI working on cesium, which is really awesome. We have quite a nice community growing. It's been on GitHub for over two years now. Then it's been in development for about three and a half. We started in February 2011, just about right when the WebGL spec was announced.
12:23
There's 18 contributors from AGI and 17 from other companies where Nicta would be the most prominent contributor, doing a lot of terrain and imagery related work. Also got some nice contributions from Raytheon on triangulation. And then some individuals who submitted individual CLAs but
12:41
are from major companies as well. Now it looks like we have 35 developers. We do not have 35 developers full time. One day I think we might, but today we don't. We probably have more like maybe three to seven full time on it, which is still a nice size team for it. And then the forum, we have a pretty active forum that has maybe 10 to 25
13:03
posts a day that has almost 400 people. So it's a great community. So with WebGL, it runs almost everywhere now. So big news that I'm sure many of you have heard by now is IE 11 does support WebGL, and the WebGL support is actually pretty good.
13:21
CCM will run on it. And for a GPU bound application where a lot of the work is being done on the video card, IE 11 performance is good. For CPU bound, I need to do some more testing before I'm gonna, I'll probably do a blog post to say where I think performance is on that side. Opera is actually really good too.
13:41
So Opera at this point runs on Blink, which is the fork of WebKit. So Chrome and Opera really are running the same WebGL engine. So if you can't run Chrome, Opera's a good alternative to it. iOS and Safari, that's on its way. So I think Apple did make an announcement for iOS WebGL support coming out very soon.
14:02
There was some informal testing done on the national map application, and CCM does run, but it does need some performance improvements. I've heard that across the board from a number of WebGL developers, so we'll definitely get that. Hopefully, the combination of us and Apple will get that quality up to snuff. We don't technically support Android yet, but we pretty much always run on Android.
14:23
Certainly, if you take out your Nexus 7, it runs really well. But we want to get 100% tests running and passing before we say that we definitely support something. So the WebGL has just been getting better and better over the past couple of years. So great platform for reaching a lot of people now. So in terms of what CCM does, the core features for
14:43
geospatial users is map layers, terrain, vector data, and 3D models. Then you can do the 3D, 2D, and Columbus views. We do all the standard map tiles from WMS, WMTS, TMS, OpenStreetMap, and so on.
15:02
And then for the terrain, I'll talk about it in a couple slides, but we do have a quantized mesh format that we use. But we can also still do height maps. The problem with streaming height map terrain data is it takes more processing to get that to become a mesh that we're gonna render with WebGL. And also for flat areas, you're wasting data there.
15:24
For vector data, we have a JSON schema that we're working on that Brian mentioned in his talk in the first session for this track, which is CZML. And that is for time dynamic visualization. So that's for not just describing spatially where the data is, but how it varies over time.
15:41
So instead of just saying, here's a position, you can say, well, here's a position at this time, and here's a position at this other time. And here's how you can interpolate those. Or here's a color at this time interval, and then here's a color at this other time interval. So it's very flexible, and certainly we use it a lot for our satellite visualization, which has fairly deep requirements.
16:05
And then of course we do GeoJSON and TopoJSON, KML is on the way. And then for 3D models, I mentioned GLTF, and I'll do a demo of model conversion for that. Okay, so one thing I like for CZML is, CZML has an API, and
16:21
we have reference documentation and examples, and you can write a lot of JavaScript code and go right down to our API. But I think a lot of use cases, you can write server-side code or offline code that generates a CZML file, which is a JSON file. And then you can see, and that is your application. It's really server-side generated, and your client can be very simple.
16:42
So I'll try to bring up another example. So if you just go right to the main CZML website, you can do this right now. And there's this Click to Interact button. And let's see how fast it comes up. So this here, these are a few satellites that are moving around. And we generated this using one of our desktop products called SDK.
17:01
I'm gonna switch it to a brighter map. And this application is really just processing the CZML file. So you have all the satellites moving, and you don't have any really client-side code, cuz that's all in CZML itself. One cool thing to show while we're running this app, is I'm gonna zoom out home.
17:21
I'll switch to Columbus view. So this satellite is in Minaiah orbit, where it sometimes comes really close to the Earth, and then it gets really far away. So I'm gonna click on the Minaiah satellite here. I'll get the info. And that info box is also part of the metadata in CZML. So I'm gonna speed up the animation.
17:41
I'll do it just for a second, I don't want anyone to throw up. But you can zoom all the way down, follow it all the way up. It's pretty cool. So yeah, so CZML, check it out. It's a similar relationship. CZML to Cesium is similar as KML to Google Earth.
18:02
Okay, so what's new feature-wise? Yeah, an awful lot. So we'll go through each one of these in excruciating detail. I'm kidding, we'll just hit a few of these. So we did a 1.0 release August 1st. And we were in beta, you know, beta in quotes for quite a while. But we hit 1.0, which really means the API is stable and
18:22
now we won't break it release to release. We may deprecate and then break over time, but we won't break it right away. And the 1.0 was really a great thing for us. We saw a huge uptick in adoption and contribution like the very second we hit 1.0. And there's been a lot of big releases recently, too, right? Open layers three, and then we're upcoming, we're gonna see a leaflet 1.0, too.
18:43
So we did the 3D models, the terrain format. We've improved translucency with order-independent translucency, so you have intersecting or overlapping translucency. It looks better. You may have some trouble on some older Intel cards, but in Cesium 1.2 that's coming out August 1st, you can turn that off if you need to.
19:02
We started a plug-in ecosystem, so I'll bring that up. So, Cesium features and plug-ins. And folks are writing code that works with Cesium but isn't in the core Cesium repo. And they're doing some cool stuff, so Oculus Rift support, subsurface visualization by Necta, Leap Motion Controller.
19:22
So we're starting to see more and more of these, so please. This is also an easier way to contribute to Cesium if you don't want to go into the core code, you can still keep it. And we'll list it here for you. We can do an unlimited number of overlapping map layers now, too. Before we were limited by the hardware limits in WebGL, and
19:43
now we'll do a multi-pass and you could do a lot of them. Okay, so I want to talk a little bit more for 3D models and terrain, a little bit more on the tech side. So glTF is the GL transmission format, and it is tuned and optimized for being fast to download and fast to render in WebGL.
20:03
And the way we do this is we have a JSON file that describes the node hierarchy of the scene and the materials, just kind of that metadata of the model. It's very easy to parse. And then all of the geometry, the textures, the animation data, the key frames for the animation, the skins, that's all in binary data.
20:24
And that could be external files or it could be embedded, base64 encoded, embedded into a single glTF. And anything that you might see in a traditional model, you might have to triangulate the triangles. You might have to split meshes into less than 64k vertices,
20:41
all these types of pre-processing things. That's all done offline, and the glTF spec defines a spec that's very easy and quick to render with WebGL. So what we do is we provide a converter from Collada, which is a popular interchange format, to convert your Collada file to glTF.
21:00
And I'll show a quick example. So this is on cesiumjs.org slash convert model HTML. So I'm gonna take, I have a DAE is a Collada file and it references two textures, and I'm gonna drag and drop them here. And they're getting zipped, and then they're getting uploaded to the server, and they're going through the content pipeline to do all the transformations we need to
21:24
create a glTF model, which then we're gonna download, and we could load with the cesium API, and then we'll see a preview here. And these models aren't too big, so hopefully they will come back soon.
21:45
And we will let that process, it will finish, I promise you. And we will move on cuz we only have three minutes. Okay, so a little more on the terrain data.
22:01
So we're using meshes, so we have a pyramid of levels of detail, right? So think of it very similar to how you would slice up imagery data. And each, instead of having an image, each thing is a mesh, and that mesh is quantized, so we're using fewer bits. And it has some extra data, like bounding volume, so we can do efficient calling
22:24
and level of detail, as well as some edge information so we can make adjacent nodes look good together. So this is something that we've really tuned to make it really fast to render. We downloaded a little bit of processing in a web worker, get it off to the pipeline.
22:41
Let's see, all right, well, that's a bust, that demo. Not bad, all the other demos went well. So just some statistics, this is 80,000 lines of JavaScript code. It's quite a bit of JavaScript code. We do use AMD, so you could use RequireJS just pulling the parts that you need. And we have 76,000 lines of test code. The numbers aren't that important, but the ratio, to me, is very important.
23:03
So we have almost as much test code as we do regular code, well over 5,000 tests with 93% code coverage. And what's awesome here is I gave a talk last July, and these stats were basically the same in that we had the same amount of test code as we did regular code and the same amount of code coverage. Cuz usually over time, you could write a 1,000 line app and
23:23
you have 100% code coverage, and then over time it deteriorates. But it has not deteriorated, so we're always running the tests just to keep the quality high. Okay, so to quickly finish up, I wanna talk a little bit about Cism and the false 4G ecosystem. We have a lot of great mapping APIs here, and
23:42
I wanna talk about how Cism has been cooperating with some of them. And two in particular, OpenLayers 3 and WebGL Earth. Okay, so OpenLayers 3, great product, congratulations on the release. And there's been a lot of interest over the past, geez, two or two and a half years really on integration of OpenLayers 3 and Cism.
24:02
And is that something that we're looking at? When will that be? And there's been some great progress there by camp to camp. And this is something AGI is not working on. AGI is a big fan and big supporter of it. But this is something that camp to camp has been doing. And here we see on the left an OpenLayers map, and
24:23
on the right we see a Cism window. And you see there's vector data on here. And you just write an adapter and you attach it to an OpenLayers map. And then when you start adding data to the OpenLayers map, you also see it in the 3D window. And on the OpenLayers 3 mailing list,
24:41
there's an initial version of this, it should be out pretty soon. The other thing, WebGL Earth 2, so many of you may have seen WebGL Earth. Then that had its own WebGL engine. They rewrote WebGL Earth 2, and it's now built on cesium. And it exposes a leaflet compatible API.
25:01
I think you just need to rename the name space and it's supposed to work with your existing leaflet apps. I have not tried it myself, other than downloading the initial example. But it looks very promising and it's a nice, maybe very easy way to get started if you already have a leaflet app. It was very cool to see the collaboration, especially with cesium, kind of providing the underneath 3D for so many different apps.
25:26
So maybe outside of the open source world, we're seeing a lot of things happen with the Google Earth plug-in. 64-bit Chrome has actually dropped support for the plug-in. And then Google has announced that they're gonna drop NPAPI, which is the plug-in technology from Chrome, by the end of the year.
25:43
And it looks like they are gonna go through with that. So we're seeing a lot of folks, like CubeCities here, they have a very cool screenshot, that are now looking at cesium. They were Google Earth plug-in developers, and they're using KML. And now they wanna go to cesium because, well, I think WebGL's gonna be around for quite a while.
26:02
So these CubeCities, they do a lot of real estate visualization like, show me the hotels and highlight them by how much they cost for a given night. And here's some early work they're doing with buildings and cesium. I'll finish up just with the road map. So on the near term, 3D is awesome, our tech is really cool, but
26:23
we need to be able to get your content into it for it to be useful. So we're improving cesium now on the documentation side and doing a little more outreach for it. And then we're looking to hit KML hard and do a really good implementation of KML, including all of the graphics improvements that we need to do underneath it.
26:41
So you'll get the KML import, and then also more cesium API to get better. To get better graphics. Then we're doing a little more community outreach than we've been doing in the past, so I'm really excited about doing that. And please jump on the forum, it's those particular features that you're interested in. There's some good conversations there, don't be shy, please tell us what you want.
27:04
So that's all, thank you again so much for staying for the last talk. Who has the first question?
27:24
Thanks, that's great. Just two questions for the rock climbing example. So what kind of data did that use in the background, like what was the DM and what was the satellite layer? Sure, so for the Seneca rocks, that terrain data there is NED data,
27:43
which I believe is 3 to 30 meter in the US. And then the imagery there was Bing maps. Okay, and then the second question was, I have actually, I'm working with somebody who had used Google Earth and obviously cannot use that in the future. So he was just, what would be the best format to get, for example,
28:00
data out of PostGIS? We have been using KML and Google Earth plugin. So would that KML be okay on season, or would you rather use some other different format? So we're working on KML now, and we'll be working on it for the next several months. So one thing you could do is go on the forum and tell us what parts of KML that you're using. And we can see how that aligns with what we're looking to do.
28:21
In fact, if you're using a small enough subset, we might already be supporting it. But if not, there's also GeoJSON and CZML. Thanks. Hi, I was wondering what tools are available for generating CZML?
28:43
Yeah, so we have an open source project called, and hey, just for the record guys, here's the converted model that I just refreshed. We have an open source project called CZML Writer, and it's on GitHub. And this is a C Sharp and Java library for writing CZML.
29:02
There are some community projects as well, like there's a Python library. And in here, I believe, I'm not sure if there's any converters anymore, but there's definitely just the writers to make it easy. So at least Java and C Sharp for sure, and I think there's a Python one out there.
29:23
What kind of options would you have for putting in something like X3D or CityGML? Yeah, so we're really interested in doing 3D building. So I've been looking a little bit at CityGML. Most likely what we'll do with CityGML is something similar to what we do with the terrain data, where we will convert it to a tiled format
29:42
that has binary nodes for rendering massive buildings. We'll also consider maybe doing CityGML directly, which would be fine for small cities. But to me, CityGML is very similar to Collada, where it's good interchange but not necessarily good for rendering. The difference here though is if you're gonna convert CityGML to a tiled format
30:04
for rendering, you have to preserve the semantics, right? Because people wanna know that that's a door and that's a window. But if you have building data or you're interested in that, please email me, cuz it's something that we're looking at and we're really interested in moving on.
30:23
Can you describe a little bit about converting from the net data into the open grid, or the open mesh, sorry. Yeah, so there's so many different source terrain data formats. So we use Google to read it, and then we have a content pipeline
30:43
that runs on the server to generate those tiles. And that is one of the value add things that AGI sells. However, we don't wanna lock anyone in, so we publish the format. So if you don't wanna use AGI server, you're welcome to use it to write the format directly.
31:02
No, so we call it quantized mesh, and that is the format that CZM uses for rendering terrain. But you could also do tiled image height maps, but it's not as performing. I really don't recommend it, but if you already have that data available, I mean, you can do it.
31:22
More questions? If you have terrain data and point data, can you project that point onto the elevation map? So you have like a point, are you talking about rendering point clouds, or you have a point and you wanna know what the altitude is at that point?
31:43
You have your 3D mesh, and you have a point on that mountain side. Can you, and you don't know the elevation from your point data, can you project it onto the mesh? Right, yeah, so we do have functions to get altitude. So if you have a lot long, you can get the altitude. And we have an example online where over Mount Everest,
32:01
we put a bunch of icons or place marks, and then we bring them all up to altitude. So yeah, other questions? This is clearly not, I don't know, probably not what a lot of people wanna do with it, but I mean, the really rich 3D capabilities,
32:21
but also an amazing number of other rich capabilities that would also be useful in a flat 2D space, like the animation change over time animation. Is it easy to pop from the oblique view? Can you pop from the oblique view to just the standard old looking
32:42
straight down on the earth view? That's probably quite easy to do, right? Yes. But that said, do you see a use, see a niche in just doing kind of, making advanced visualizations possible easier in a traditional GIS view?
33:04
Yeah, so for 2D, I mean, we continue to support 2D as we do 3D. I can't say that right now, maybe in the next six months for AGI's roadmap, that we're gonna be aggressively looking to go beyond with 2D. But certainly it's a possibility.
33:20
I mean, we are working closely with OpenLayers 3 guys, so we kind of see a nice collaboration there. So I can't say that we're gonna go beyond. And certainly, I'm not necessarily looking out beyond six months yet, but I can't say it's there in the next six months. Are there other questions?
33:44
Yeah, hello. I tested the CCM behind the firewall in a private network. And I had several issues connecting to the data sets. I can choose from them on my side. Is there any special communication port should be open or something like that?
34:02
So the question is that you're on a private network and you're having issues getting to the data sets. So we do provide some tile data sets that you could just bring onto the private network. Under the CCM plugins, there's a CCM assets repo. And we have, for example, the Natural Earth imagery tiled.
34:20
And if you put that on the private network, I think you should be in good shape. The only thing that you'd need to consider is course, cross-origin resource sharing. So if you have one server with your imagery and another server getting your web app, you need to make sure that the server serving the imagery allows cross-origin resource sharing.
34:41
Okay, I have to correct myself. So the communication with the demo site for the standard demo data sets is maybe interrupted, something like that. Is there a special channel or port that must be open for the firewall to connect these data sets? I don't think so.
35:01
It seemed to me afterwards, and maybe we could talk more about it. But I'm pretty sure that there doesn't need to be any extra firewall stuff. And any other questions? I think we have one more up here.
35:22
Hey, demo, does that mean that D3 is built in, or is it a separate library that you just- Yeah, so the D3 app is an application that includes both cesium and both D3. So that's not one, I mean, actually it could be pretty cool for someone to write an API that maybe does some nice integration.
35:41
But the integration there is done at the application level. We had another question over here.
36:04
So the question is, does it play well with other HTML5 elements? And the answer is, yeah, it plays really well with them, which is one reason why WebGL is so great. So here's an application one of our users made where they did a lot of UI elements, and we didn't do this UI, a lot of this is their UI.
36:22
So with WebGL, this is just another div on the page, and you can alpha blend them, you can put UI on top of it. You can even alpha blend the cesium canvas and put things behind it. Yeah, it works really well. More questions?
36:40
All right, well, thanks everyone for staying happy.