/// <summary> /// Creates a new KmzFile using the data specified in the KmlFile. /// </summary> /// <param name="kml">The Kml data to add to the archive.</param> /// <returns> /// A new KmzFile populated with the data specified in the KmlFile. /// </returns> /// <remarks> /// This overloaded version does not resolve any links in the Kml data /// and, therefore, will not add any local references to the archive. /// </remarks> /// <exception cref="ArgumentNullException">kml is null.</exception> public static KmzFile Create(KmlFile kml) { if (kml == null) { throw new ArgumentNullException("kml"); } var instance = new KmzFile(new MemoryStream()); instance._zip = new ZipFile(); // Add the Kml data using (var stream = new MemoryStream()) { kml.Save(stream); instance.AddFile(DefaultKmlFilename, stream.ToArray()); } return instance; }
public void ShouldFindAllTheLinkTypesInTheKmlFile() { // Verify that GetLinks finds all kinds of hrefs in a KML file. string[] expected = { "http://example.com/icon.jpg", "itemicon.png", "../more.kml", "go.jpeg", "so.jpeg", "po.jpeg", "#myschema", "model.dae", "style.kml#style" }; using (var stream = SampleData.CreateStream("Engine.Data.Links.kml")) using (var reader = new StreamReader(stream)) { var resolver = new LinkResolver(KmlFile.Load(reader)); IEnumerable <string> links = resolver.Links.Select(u => u.OriginalString); Assert.That(links, Is.EquivalentTo(expected)); } }
/// <summary> /// Run one route script with an IFR model aircraft /// </summary> /// <param name="route">A complete route script to run</param> /// <returns>True if OK</returns> private bool RunSimFromScript(CmdList route) { string routeName = route.Descriptor.Start_IcaoID + "_" + route.Descriptor.End_IcaoID; var virtAcft = new IFRvAcft(route); // use the Jet model var kmlFile = new KmlFile( ); var kmlLine = new line { Name = routeName, LineColor = LineStyle.LT_Blue }; do { virtAcft.StepModel(m_stepLen_sec); // step the model at 2 sec until finished kmlLine.Add(new point { Position = new LatLon(virtAcft.LatLon), Altitude_ft = virtAcft.Alt_ft, Heading = (int)virtAcft.TRK }); } while (!virtAcft.Out); // setup Comm kmlFile.Lines.Add(kmlLine); kmlFile.WriteKML(routeName + ".kml"); return(Valid); }
/// <summary> /// Parses the raw KML Data file returned by the inReach service and produces live /// waypoint data. /// </summary> /// <param name="stream">stream to read kml from</param> /// <param name="mapShareIdentifier">MapShare identifier used for request</param> /// <returns>live waypoint data</returns> internal LiveWaypointData ParseRawKmlDataFile(Stream stream, string mapShareIdentifier) { var file = KmlFile.Load(stream); var placemark = file.Root.Flatten().First(x => x is Placemark) as Placemark; if (placemark == null) { throw new FormatException("Garmin inReach Raw KML Data contains no Placemark"); } var point = placemark.Geometry as Point; var when = (placemark.Time as Timestamp).When; if (when.HasValue) { this.lastRequestByMapShareIdentifier[mapShareIdentifier] = new DateTimeOffset(when.Value); } return(new LiveWaypointData { ID = FormatLiveWaypointId(mapShareIdentifier), Name = "Garmin inReach " + placemark.Name, Latitude = point.Coordinate.Latitude, Longitude = point.Coordinate.Longitude, Altitude = (int)(point.Coordinate.Altitude ?? 0.0), TimeStamp = when.HasValue ? new DateTimeOffset(when.Value) : DateTimeOffset.Now, Description = FormatDescriptionFromPlacemark(placemark), DetailsLink = string.Format(MapSharePublicUrl, mapShareIdentifier), }); }
static void LoadFile() { FileStream fs; KmlFile file = null; Console.WriteLine("Enter KML filepath:"); try { fs = File.OpenRead(Console.ReadLine()); file = KmlFile.Load(fs); } catch (Exception ex) { Console.WriteLine(ex.Message); Console.Write("Retry/Exit (r/x)? "); if (Console.ReadKey().KeyChar == 'r') { Console.WriteLine(); LoadFile(); return; } else { Environment.Exit(0); } } kmlFile = file; }
public static string ExploreKml(string filename, KmlFile file) { List <string> lines = new List <string>() { $"{filename}:" }; if (!(file.Root is Kml kml)) { return("File root isn't a KML"); } if (!(kml.Feature is Document doc)) { return("Main feature isn't a Document"); } if (!doc.Features.Any()) { return("No features in Document"); } foreach (Feature element in doc.Features) { lines.AddRange(DisplayElement(element, 0)); } lines.Add(""); return(string.Join("\r\n", lines)); }
public void TestAltMarkupData() { using (var stream = SampleData.CreateStream("Engine.Data.Entity Data.kml")) { KmlFile file = KmlFile.Load(stream); Placemark placemark = file.Root as Placemark; Assert.That(placemark, Is.Not.Null); EntityMapper mapper = new EntityMapper(file); mapper.ParseEntityFields(placemark); Assert.That(mapper.Entities.Count, Is.EqualTo(6)); for (int i = 0; i < 4; ++i) { Assert.That(mapper.Markup[i], Is.EqualTo(AltMarkup[i])); } // Assert that a second parse produces the same result (this // is different to the C++ version, which clears the Entities // but adds to the Markup - we reset both. mapper.ParseEntityFields(placemark); Assert.That(mapper.Entities.Count, Is.EqualTo(6)); Assert.That(mapper.Markup.Count, Is.EqualTo(4)); } }
public void TestSave() { // Create the Kml data const string Xml = "<Placemark xmlns='http://www.opengis.net/kml/2.2'><name>tmp kml</name></Placemark>"; var parser = new Parser(); parser.ParseString(Xml, true); var kml = KmlFile.Create(parser.Root, false); using (var stream = new MemoryStream()) { // Create and save the archive using (var file = KmzFile.Create(kml)) { file.Save(stream); } // Try to open the saved archive, rewinding the stream stream.Position = 0; using (var file = KmzFile.Open(stream)) { // Make sure it's the same as what we saved parser.ParseString(file.ReadKml(), true); SampleData.CompareElements(kml.Root, parser.Root); } } }
public void TestDispose() { // Make sure we can't call any methods after the object has been disposed var file = KmzFile.Create(KmlFile.Create(new Kml(), false)); file.Dispose(); // Make sure we can call Dispose more than once Assert.That(() => file.Dispose(), Throws.Nothing); // Check all methods and properties throw. var flags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public; foreach (var method in typeof(KmzFile).GetMethods(flags)) { // Dispose should be able to be called mutliple times without // an exception being thrown. if (method.Name != "Dispose") { // Actual exception thrown will be TargetInvocationException // so check the InnerException. object[] arguments = new object[method.GetParameters().Length]; Assert.That(() => method.Invoke(file, arguments), Throws.InnerException.TypeOf <ObjectDisposedException>()); } } foreach (var property in typeof(KmzFile).GetProperties(flags)) { // Mono doesn't throw a TargetInvocationException so just check that the property // throws, as it doesn't throw any other type of exception. Assert.That(() => property.GetValue(file, null), Throws.Exception); } }
public static void Run() { var point = new sd.Point { Coordinate = new sb.Vector(37.42052549, -122.0816695) }; var placemark = new sd.Placemark { Name = "Да круто", Geometry = point }; var point1 = new sd.Point { Coordinate = new sb.Vector(37.419837, -122.078902) }; var placemark1 = new sd.Placemark { Name = "Да круто", Geometry = point1 }; var document = new sd.Document { Description = new sd.Description { Text = "Документ" } }; var kml = new sd.Kml { Feature = document }; var folder = new sd.Folder { Description = new sd.Description { Text = "Светофоры" }, Name = "СО" }; folder.AddFeature(placemark); document.AddFeature(folder); document.AddFeature(placemark1); //var serializer = new sb.Serializer(); //using FileStream fileStream = new FileStream("kmlTest.kml", FileMode.OpenOrCreate); //serializer.Serialize(kml, fileStream); var kmlFile = KmlFile.Create(kml, true); //using KmzFile kmz = SaveKmlAndLinkedContentIntoAKmzArchive(kmlFile, OutputPath); //using Stream output = File.Create(OutputPath); //kmz.Save(output); //Console.WriteLine("Saved to '{0}'.", OutputPath); //Console.ReadKey(); }
/// <summary> /// Basic output of the instances Kml to a Kmz as specified in configuration. /// </summary> public void Save(string band = "") { string FileName; if (String.IsNullOrWhiteSpace(settings.FileName)) { if (band == "") { FileName = $"{DateTime.Now.ToString("yyyy-MM-dd")} - Subscriber Map.kmz"; } else { FileName = $"{DateTime.Now.ToString("yyyy-MM-dd")} - Subscriber Map ({band}).kmz"; } } else { FileName = settings.FileName; } KmlFile kmlFile = KmlFile.Create(OutputKml, true); using (FileStream fs = new FileStream(FileName, FileMode.Create)) { using (KmzFile kmz = KmzFile.Create(kmlFile)) { kmz.Save(fs); } } }
private static KmlFile LoadKml(string path) { using (Stream file = File.OpenRead(path)) { return(KmlFile.Load(file)); } }
/// <summary> /// Method to parse the KmlFile /// </summary> /// <param name="kmlFile">The file to parse</param> private void ParseKml(KmlFile kmlFile) { var kml = kmlFile.Root as Kml; if (kml == null) { throw new Exception("Kml file is null! Please check that the file conforms to http://www.opengis.net/kml/2.2 standards"); } var doc = kml.Feature as Document; if (doc == null) { throw new Exception("Kml file does not have a document node! please check that the file conforms to http://www.opengis.net/kml/2.2 standards"); } _geometryFactory = GeoAPI.GeometryServiceProvider.Instance.CreateGeometryFactory(4326); ConnectionID = doc.Name; if (doc.Description != null && !string.IsNullOrEmpty(doc.Description.Text)) { ConnectionID += " (" + doc.Description.Text + ")"; } ExtractStyles(kml); ExtractStyleMaps(kml); ExtractGeometries(kml); }
public List <PostImport.ExcelPost> LesInn(byte[] content) { var poster = new List <PostImport.ExcelPost>(); var kml = KmlFile.Load(new MemoryStream(content)); var root = (SharpKml.Dom.Kml)kml.Root; var document = (Document)root.Feature; foreach (var folder in document.Features.OfType <Folder>()) { foreach (var placemark in folder.Features.OfType <Placemark>()) { var name = placemark.Name; var description = placemark.Description; var point = placemark.Geometry as Point; var coordinates = point?.Coordinate ?? new Vector(); var image = placemark.ExtendedData?.Data?.FirstOrDefault()?.Value; var post = KonverterTilExcelPost(name, description, coordinates, image, document.Name); poster.Add(post); } } return(poster); }
public static KmlFile JoinFoldersIntoKml(String inputPath) { DirectoryInfo dir = new DirectoryInfo(inputPath); if (!dir.Exists) { throw new DirectoryNotFoundException(); } FileInfo kmlf = dir.EnumerateFiles().ToList().FirstOrDefault(f => ".kml".Equals(f.Extension, StringComparison.OrdinalIgnoreCase)); if (kmlf == null) { throw new Exception(); } KmlFile rootKmlFile = FileHelper.LoadKmlKmzFile(kmlf.FullName); if (!(rootKmlFile.Root is Document)) { throw new Exception(); } Document rootDoc = (Document)(rootKmlFile.Root.Clone()); dir.EnumerateDirectories().ToList().ForEach(f => { processFolder(rootDoc, f); }); KmlFile kmlOut = KmlFile.Create(rootDoc, false); return(kmlOut); }
static void processFolder(Container parentContainer, DirectoryInfo directory) { FileInfo kmlf = directory.EnumerateFiles().ToList().FirstOrDefault(f => ".kml".Equals(f.Extension, StringComparison.OrdinalIgnoreCase)); if (kmlf == null) { throw new Exception(); } KmlFile rootKmlFile = FileHelper.LoadKmlKmzFile(kmlf.FullName); if (!(rootKmlFile.Root is Document)) { throw new Exception(); } Document doc = (Document)rootKmlFile.Root; Folder folder = (Folder)parentContainer.Features.FirstOrDefault(c => c is Folder && doc.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)); if (folder == null) { folder = new Folder(); parentContainer.AddFeature(folder); } folder.Name = doc.Name; if (doc.Description != null) { folder.Description = doc.Description; } List <DirectoryInfo> directories = directory.EnumerateDirectories().ToList(); doc.Features.ToList().ForEach(feature => folder.AddFeature(feature.Clone())); directory.EnumerateDirectories().ToList().ForEach(f => { processFolder(folder, f); }); }
static void Main(string[] args) { String inFile = @"C:\tmp\Test\Ferrocarril Belgrano.kml"; String outFile = @"C:\tmp\Test\out.kml"; KmlFile kmlFile = null; using (Stream fileStream = File.OpenRead(inFile)) { kmlFile = KmlFile.Load(fileStream); } Kml kml = kmlFile.Root as Kml; Document d = kml.Feature as Document; Folder f = (Folder)d.Features.FirstOrDefault(); Folder f2 = (Folder)f.Features.FirstOrDefault(); Document doc = new Document(); doc.Name = "MyTestKml"; d.Schemas.ToList().ForEach(s => doc.AddSchema(s.Clone())); doc.AddFeature(f2.Clone()); // This allows us to save and Element easily. KmlFile kmlOut = KmlFile.Create(doc, false); using (var stream = System.IO.File.OpenWrite(outFile)) { kmlOut.Save(stream); } }
public void TestSingleSimpleDelete() { const string DeleteXml = "<Update>" + "<targetHref/>" + "<Delete>" + "<Placemark targetId=\"p\"/>" + "</Delete>" + "</Update>"; var parser = new Parser(); parser.ParseString("<Folder><Placemark id=\"p\"/></Folder>", false); var file = KmlFile.Create(parser.Root, false); var target = parser.Root as Folder; Assert.That(target, Is.Not.Null); Assert.That(target.Features.Count(), Is.EqualTo(1)); parser.ParseString(DeleteXml, false); var update = parser.Root as Update; Assert.That(update, Is.Not.Null); update.Process(file); Assert.That(target.Features.Count(), Is.EqualTo(0)); Assert.That(file.FindObject("p"), Is.Null); // Make sure it was deleted from the KmlFile too. }
public void TestSingleSimpleChange() { const string ChangeXml = "<Update>" + "<targetHref/>" + "<Change>" + "<Placemark targetId=\"p\">" + "<name>NEW NAME</name>" + "</Placemark>" + "</Change>" + "</Update>"; var parser = new Parser(); parser.ParseString("<Placemark id=\"p\"><name>hi</name></Placemark>", false); var file = KmlFile.Create(parser.Root, false); var target = file.FindObject("p") as Placemark; Assert.That(target, Is.Not.Null); Assert.That(target.Name, Is.EqualTo("hi")); parser.ParseString(ChangeXml, false); var update = parser.Root as Update; Assert.That(update, Is.Not.Null); // Verify the test XML update.Process(file); Assert.That(target.Name, Is.EqualTo("NEW NAME")); Assert.That(target.TargetId, Is.Null); }
private static void ProcessDelete(DeleteCollection delete, KmlFile file) { foreach (var source in delete) { if (source.TargetId != null) { Feature feature = file.FindObject(source.TargetId) as Feature; if (feature != null) { // Remove the Feature from the parent, which is either // a Container or Kml Container container = feature.Parent as Container; if (container != null) { container.RemoveFeature(source.TargetId); } else { Kml kml = feature.Parent as Kml; if (kml != null) { kml.Feature = null; } } // Also remove it from the file file.RemoveFeature(feature); } } } }
public static void Run() { KmlFile file = Program.OpenFile("Enter a file to show the placemarks of:"); if (file == null) { return; } // It's good practice for the root element of the file to be a Kml element if (file.Root is Kml kml) { var placemarks = new List <Placemark>(); ExtractPlacemarks(kml.Feature, placemarks); // Sort using their names placemarks.Sort((a, b) => string.Compare(a.Name, b.Name)); // Display the results foreach (Placemark placemark in placemarks) { Console.WriteLine(placemark.Name); } } }
/// <summary> /// Returns the KML file at the specified <paramref name="path"/>. /// /// If the KMZ file's <see cref="KmlDocument.NetworkLink"/> property indicates another KML or KMZ file, that file will be retrieved and returned instead. /// </summary> /// <param name="path">The path to the file on disk.</param> /// <returns>An instance of <see cref="KmlFile"/>.</returns> public static KmlFile LoadKml(string path) { KmlFile kml; // Get the KML file from the KMZ file at "path" using (KmzFile kmz = OpenRead(path)) { kml = kmz.Kml; } // If the KML file doesn't have a network link, we'll just return it right away if (kml.Document.HasNetworkLink == false) { return(kml); } // Get the KML or KMZ file specified by the network link HttpResponse response = (HttpResponse)HttpUtils.Requests.Get(kml.Document.NetworkLink.Link.Href); // Parse the response body switch (response.ContentType) { case KmlConstants.KmlMimeType: return(KmlFile.Parse(response.Body)); case KmlConstants.KmzMimeType: using (KmzFile kmz = Parse(response.BinaryBody)) return(kmz.Kml); default: throw new KmzException("Unknown mime type " + response.ContentType); } }
/// <summary> /// Creates a new KML data file from stream /// </summary> /// <param name="stream">stream to read from</param> /// <param name="isKml">indicates if stream contains a kml or a kmz file</param> public KmlDataFile(Stream stream, bool isKml) { if (isKml) { using (var reader = new StreamReader(stream)) { this.kml = KmlFile.Load(reader); if (this.kml.Root == null && stream.CanSeek) { stream.Seek(0, SeekOrigin.Begin); this.kml = this.ReadLegacyKmlStream(stream, isKml); } } } else { var kmz = KmzFile.Open(stream); this.kml = kmz.GetDefaultKmlFile(); } if (this.kml != null) { this.ScanKml(); } }
private void OpenMenu_Click(object sender, RoutedEventArgs e) { // Create an instance of the open file dialog box. OpenFileDialog openFileDialog = new OpenFileDialog(); // Set filter options and filter index. openFileDialog.Filter = "Google Earth (.kml .kmz)|*.kml;*.kmz"; openFileDialog.FilterIndex = 1; openFileDialog.Multiselect = true; // Call the ShowDialog method to show the dialog box. bool?userClickedOK = openFileDialog.ShowDialog(); // Process input if the user clicked OK. if (userClickedOK == true) { KmlFile kmlFile = KmlFileHelper.OpenFile(openFileDialog.FileName); FerromapasKmlHelper.AddFerromapasSchemaIfNotExists(kmlFile); String fileName = ((kmlFile.Root as Kml).Feature as Document).Name; this.Title = fileName; this.kmlFile = kmlFile; kmlTreeView.kmlFile = kmlFile; this.fileName = openFileDialog.FileName; } }
public static KmlFile OpenFile(string prompt) { string filename = GetInputFile(prompt, "Data/20191114.kml"); KmlFile file; try { using (FileStream stream = File.Open(filename, FileMode.Open)) { file = KmlFile.Load(stream); } } catch (Exception ex) { DisplayError(ex.GetType() + "\n" + ex.Message); return(null); } if (file.Root == null) { DisplayError("Unable to find any recognized Kml in the specified file."); return(null); } return(file); }
public void TestManyDeletes() { const int NumberOfFolders = 100; var folder = new Folder(); for (int i = 0; i < NumberOfFolders; ++i) { folder.AddFeature(CreateFeature(i, true)); // Add the features with their Id set } Assert.That(folder.Features.Count(), Is.EqualTo(NumberOfFolders)); var file = KmlFile.Create(folder, false); var update = new Update(); for (int i = 0; i < NumberOfFolders; ++i) { var delete = new DeleteCollection { CreateFeature(i, false) // This time set the TargetId }; update.AddUpdate(delete); } update.Process(file); Assert.That(folder.Features.Count(), Is.EqualTo(0)); }
/// Read file in KMZ and KML format private void ReadGISFile() { string pathToimage = null; using (FileStream reader = new FileStream(path, FileMode.Open)) using (KmzFile kmzFile = KmzFile.Open(reader)) { KmlFile kmlFile = kmzFile.GetDefaultKmlFile(); var image = kmlFile.Root.Flatten().OfType <GroundOverlay>().FirstOrDefault(); if (image != null) { pathToimage = image.Icon.Href.ToString(); } var latLonBox = kmlFile.Root.Flatten().OfType <LatLonBox>().FirstOrDefault(); if (latLonBox != null) { var coorners = GetMapCorners(latLonBox); map = new Map() { MapCorners = coorners, Rotation = latLonBox.Rotation, Name = kmlFile.Root.Flatten().OfType <Folder>().FirstOrDefault().Name }; } } ReadArchiveAndExport(pathToimage); }
/// <summary> /// Provides in-place (destructive) processing of the <see cref="Update"/>. /// </summary> /// <param name="update">The update instance.</param> /// <param name="file"> /// A KmlFile containing the <c>Update</c> and the update targets. /// </param> /// <exception cref="ArgumentNullException">file is null.</exception> public static void Process(this Update update, KmlFile file) { if (file == null) { throw new ArgumentNullException("file"); } foreach (var child in update.Updates) { ChangeCollection change = child as ChangeCollection; if (change != null) { ProcessChange(change, file); continue; } CreateCollection create = child as CreateCollection; if (create != null) { ProcessCreate(create, file); continue; } DeleteCollection delete = child as DeleteCollection; if (delete != null) { ProcessDelete(delete, file); } } }
private static KmlFile CreateFile(string kml, bool duplicates) { var parser = new Parser(); parser.ParseString(kml, false); return(KmlFile.Create(parser.Root, duplicates)); }
private static KmzFile SaveKmlAndLinkedContentIntoAKmzArchive(KmlFile kml, string path) { // All the links in the KML will be relative to the KML file, so // find it's directory so we can add them later string basePath = Path.GetDirectoryName(path); // Create the archive with the KML data KmzFile kmz = KmzFile.Create(kml); // Now find all the linked content in the KML so we can add the // files to the KMZ archive var links = new LinkResolver(kml); // Next gather the local references and add them. foreach (string relativePath in links.GetRelativePaths()) { // Make sure it doesn't point to a directory below the base path if (relativePath.StartsWith("..", StringComparison.Ordinal)) { continue; } // Add it to the archive string fullPath = Path.Combine(basePath, relativePath); using (Stream file = File.OpenRead(fullPath)) { kmz.AddFile(relativePath, file); } } return(kmz); }
public static void Run() { KmlFile file = Program.OpenFile("Enter a file to show the styles of:"); if (file == null) { return; } Console.WriteLine("Style names:"); // We're going to extend the first style later StyleSelector firstStyle = null; foreach (StyleSelector style in file.Styles.OrderBy(s => s.Id)) { if (firstStyle == null) { firstStyle = style; } Console.WriteLine(style.Id); } // If there was a style display it's Xml if (firstStyle != null) { Console.WriteLine("\nExpanding '{0}':", firstStyle.Id); var serializer = new Serializer(); serializer.Serialize(firstStyle); Console.WriteLine(serializer.Xml); } }
public void TestSave() { // Create the Kml data const string Xml = "<Placemark xmlns='http://www.opengis.net/kml/2.2'><name>tmp kml</name></Placemark>"; var parser = new Parser(); parser.ParseString(Xml, true); var kml = KmlFile.Create(parser.Root, false); // This will be where we temporary save the archive to string tempFile = Path.GetTempFileName(); try { // Create and save the archive using (var file = KmzFile.Create(kml)) { file.Save(tempFile); } // Try to open the saved archive using (var file = KmzFile.Open(tempFile)) { // Make sure it's the same as what we saved parser.ParseString(file.ReadKml(), true); SampleData.CompareElements(kml.Root, parser.Root); } } finally { File.Delete(tempFile); } }
public static void Run() { const string OutputPath = "output.kmz"; string input = Program.GetInputFile("Enter a file to convert to Kmz:", "Data/doc.kml"); try { KmlFile kml = LoadKml(input); using (KmzFile kmz = SaveKmlAndLinkedContentIntoAKmzArchive(kml, input)) using (Stream output = File.Create(OutputPath)) { kmz.Save(output); Console.WriteLine("Saved to '{0}'.", OutputPath); } // Now open the file we saved and list the contents using (Stream file = File.OpenRead(OutputPath)) using (KmzFile kmz = KmzFile.Open(file)) { Console.WriteLine("Contents:"); foreach (string name in kmz.Files) { Console.WriteLine(name); } } } catch (Exception ex) { Program.DisplayError(ex.GetType() + "\n" + ex.Message); } }
/// <summary> /// Initializes a new instance of the EntityMapper class. /// </summary> /// <param name="file">The kml information to parse.</param> /// <exception cref="ArgumentNullException">file is null.</exception> public EntityMapper(KmlFile file) { if (file == null) { throw new ArgumentNullException("file"); } _file = file; }
public static string getBusDescription(KmlFile kml) { string name = ""; foreach (var item in kml.Root.Flatten().OfType<Document>()) { name = item.Name; } return name; }
private static void ProcessChange(ChangeCollection change, KmlFile file) { foreach (var source in change) { if (source.TargetId != null) { KmlObject target = file.FindObject(source.TargetId); if (target != null) { target.Merge(source); target.TargetId = null; // Merge copied the TargetId from the source, but target shouldn't have it set } } } }
private static void ProcessCreate(CreateCollection create, KmlFile file) { foreach (var source in create) { if (source.TargetId != null) { Container target = file.FindObject(source.TargetId) as Container; if (target != null) // Make sure it was found and that the target was a Container { foreach (var feature in source.Features) { var clone = feature.Clone(); // We never give the original source. target.AddFeature(clone); file.AddFeature(clone); } } } } }
/* Código referente ao cadastro dos Ônibus juntamente com suas Rotas. É feito um join da rota do ônibus com as estações em que ele passa. Portanto, DEVE ser feito o cadastro das estações de ônibus ANTES de adicionar a rota. É realizado um insert nas tabelas BUSES, ROUTES e STATION_BUSES */ private bool addBusRoutes(KmlFile kml) { BUS bus = new BUS(); ROUTE route = new ROUTE(); DBRoute dbRoute = new DBRoute(context); DBStation dbStation = new DBStation(context); route.BUS = bus; StringBuilder sb = new StringBuilder("LINESTRING ("); bus.Bus_Description = Methods.getBusDescription(kml); bool hasStation = false; foreach (var folder in kml.Root.Flatten().OfType<Folder>()) { if (folder.Flatten().OfType<SharpKml.Dom.LineString>().Any()) { DBStation_Bus dbStationBus = new DBStation_Bus(context); foreach (var placemark in folder.Flatten().OfType<SharpKml.Dom.Placemark>()) { parseLineString(placemark, sb); // grava a rota do onibus hasStation = parsePoint(placemark, dbStationBus, dbStation, bus, route, hasStation); // grava as estacoes que o onibus passa } } } if (!hasStation) { string message = "The stations this bus pass by are not in the database. Please insert the stations first, then the bus route"; Methods.DisplayMessage(lblMessage, message, Color.Red); throw new Exception(message); } route.Route_Coordinates = DbGeography.LineFromText(sb.Replace(',', ')', sb.Length - 1, 1).ToString(), 4326); dbRoute.Add(route); return true; }
private async void ConvertPolyLinesToKml(KmlFile passedInKmlFile) { KmlFile kmlF = passedInKmlFile; string bobby = "Bobby"; byte[] byteArray = new byte[1000]; using (MemoryStream sourceStream = File.Open(bobby, FileMode.OpenOrCreate)) { kmlF.Save((Stream)sourceStream); } //var file = FileIO. //IRandomAccessStream stream = await newFile.OpenAsync(FileAccessMode.ReadWrite); //var buffer = new Windows.Storage.Streams.Buffer(1024 * 1024 * 10); //await FileIO.WriteBufferAsync(newFile, buffer); }
/// <summary> /// Creates an instance of this class using the provided KmlFile /// </summary> /// <param name="kmlFile">The KmlFile</param> public KmlProvider(KmlFile kmlFile) { ParseKml(kmlFile); }
// Código referente ao cadastro dos Pontos de Referência OU das Estações de Ônibus // É realizado um insert nas tabelas STATIONS OU LANDMARKs e LANDMARK_KNOWN_AS private bool parseFolder(KmlFile kml, bool done, StreamWriter writetext) { foreach (var folder in kml.Root.Flatten().OfType<Folder>()) { IEnumerable<Placemark> enumerablePlacemark = null; if (folder.Flatten().OfType<Placemark>().Any()) { if (folder.Flatten().OfType<LineString>().Any()) { enumerablePlacemark = folder.Flatten().OfType<Placemark>().Take(1); } else { enumerablePlacemark = folder.Flatten().OfType<Placemark>(); } } done = parsePlacemark(enumerablePlacemark, done, writetext, kml); } return done; }
public void SetKML(KmlFile kmlFile) { _kmlFile = kmlFile; }
private bool parsePlacemark(IEnumerable<Placemark> enumerablePlacemark, bool done, StreamWriter writetext, KmlFile kml = null) { foreach (var placemark in enumerablePlacemark) { done = parsePoint(placemark, done, writetext); if (placemark.Flatten().OfType<SharpKml.Dom.LineString>().Any()) { BUS bus = new BUS(); bus.Bus_Description = Methods.getBusDescription(kml); } } return done; }
private static void RunTestCase(KmlFile file, string id, BoundingBox box) { Feature feature = file.FindObject(id) as Feature; Assert.That(feature, Is.Not.Null); // Verify the test data var bounds = feature.CalculateBounds(); Assert.That(bounds, Is.Not.Null); Assert.That(bounds.East, Is.EqualTo(box.East)); Assert.That(bounds.North, Is.EqualTo(box.North)); Assert.That(bounds.South, Is.EqualTo(box.South)); Assert.That(bounds.West, Is.EqualTo(box.West)); }
/// <summary> /// Method to parse the KmlFile /// </summary> /// <param name="kmlFile">The file to parse</param> private void ParseKml(KmlFile kmlFile) { var kml = kmlFile.Root as Kml; if (kml == null) { throw new Exception("Kml file is null! Please check that the file conforms to http://www.opengis.net/kml/2.2 standards"); } var doc = kml.Feature as Document; if (doc == null) { throw new Exception("Kml file does not have a document node! please check that the file conforms to http://www.opengis.net/kml/2.2 standards"); } _geometryFactory = GeoAPI.GeometryServiceProvider.Instance.CreateGeometryFactory(4326); ConnectionID = doc.Name; if (!string.IsNullOrEmpty(doc.Description.Text)) ConnectionID += " (" + doc.Description.Text + ")"; ExtractStyles(kml); ExtractStyleMaps(kml); ExtractGeometries(kml); }
private static void RunTestCase(TestCase test, KmlFile file) { // Need to create a file from the element for Process to use, // making sure we pass a copy not the real thing! var target = KmlFile.Create(file.FindObject(test.Target).Clone(), false); // Update is stored as an orphan of the parent folder var update = (Update)(file.FindObject(test.Input).Orphans.ElementAt(0)); var expected = file.FindObject(test.Output).Children.ElementAt(0); update.Process(target); SampleData.CompareElements(expected, target.Root.Children.ElementAt(0)); }