예제 #1
0
        /// <summary>
        /// Knoten für eine logische oder physische Datei anhängen
        /// </summary>
        /// <param name="tn"></param>
        /// <param name="tre">wenn null, wird das Objekt erzeugt</param>
        /// <param name="binreader"></param>
        public static void AppendChildNodes(TreeNode tn, GarminCore.Files.StdFile_DEM dem, GarminCore.BinaryReaderWriter binreader)
        {
            DeleteDummyChildNode(tn);

            AppendNode(AppendNode(tn, NodeContent.NodeType.GarminCommonHeader, dem, "Garmin Common Header"));
            AppendNode(AppendNode(tn, NodeContent.NodeType.GarminSpecialHeader, dem, "Garmin DEM-Header"));
            AppendNode(AppendNode(tn, NodeContent.NodeType.DEM_Zoomlevel, dem, "Zoomlevel"));
        }
예제 #2
0
 /// <summary>
 /// Knoten für einen Header anhängen
 /// </summary>
 /// <param name="tn"></param>
 /// <param name="tre"></param>
 public static void AppendChildNodesOn_GarminSpecialHeader(TreeNode tn, GarminCore.Files.StdFile_DEM dem)
 {
     AppendNode(tn, NodeContent.NodeType.DataRange, new NodeContent.Content4DataRange(dem.Flags, 0x15, "Flags: " + DecimalAndHexAndBinary(dem.Flags), false), "Flags");
     AppendNode(tn, NodeContent.NodeType.DataRange, new NodeContent.Content4DataRange(dem.ZoomlevelCount, 0x19, "ZoomlevelCount: " + DecimalAndHexAndBinary(dem.ZoomlevelCount)), "ZoomlevelCount");
     AppendNode(tn, NodeContent.NodeType.DataRange, new NodeContent.Content4DataRange(dem.Unknown_0x1B, 0, dem.Unknown_0x1B.Length, NodeContent.Content4DataRange.DataType.Other, 0x1B, "Unknown 0x1B"), "Unknown 0x1B");
     AppendNode(tn, NodeContent.NodeType.DataRange, new NodeContent.Content4DataRange(dem.ZoomlevelRecordSize, 0x1F, "ZoomlevelRecordSize: " + DecimalAndHexAndBinary(dem.ZoomlevelRecordSize)), "ZoomlevelRecordSize");
     AppendNode(tn, NodeContent.NodeType.DataRange, new NodeContent.Content4DataRange(dem.PtrZoomlevel, 0x21, "ZoomlevelOffset: " + DecimalAndHexAndBinary(dem.PtrZoomlevel), false), "ZoomlevelOffset");
     AppendNode(tn, NodeContent.NodeType.DataRange, new NodeContent.Content4DataRange(dem.Unknown_0x25, 0, dem.Unknown_0x25.Length, NodeContent.Content4DataRange.DataType.Other, 0x25, "Unknown 0x25"), "Unknown 0x25");
 }
예제 #3
0
 /// <summary>
 /// dateitypischer Header
 /// </summary>
 /// <param name="info"></param>
 /// <param name="dem"></param>
 public static void SpecialHeader(StringBuilder info, GarminCore.Files.StdFile_DEM dem)
 {
     info.AppendLine("Flags                (4 Byte):        " + DecimalAndHexAndBinary(dem.Flags, 32));
     info.AppendLine("   HeigthInFeet              (Bit 1): " + dem.HeigthInFeet.ToString());
     info.AppendLine("ZoomlevelCount       (2 Byte):        " + DecimalAndHexAndBinary(dem.ZoomlevelCount));
     info.AppendLine("Unknown 0x1B         (4 Byte):        " + HexString(dem.Unknown_0x1B));
     info.AppendLine("ZoomlevelRecordSize  (2 Byte):        " + DecimalAndHexAndBinary(dem.ZoomlevelRecordSize));
     info.AppendLine("ZoomlevelOffset      (4 Byte):        " + DecimalAndHexAndBinary(dem.PtrZoomlevel));
     info.AppendLine("Unknown 0x25         (" + dem.Unknown_0x25.Length.ToString() + " Byte):        " + HexString(dem.Unknown_0x25));
 }
예제 #4
0
 /// <summary>
 /// liefert das <see cref="GarminFile"/> als <see cref="GarminCore.Files.StdFile_DEM"/>
 /// <para>Falls noch nicht erfolgt, wird die DEM-Datei eingelesen.</para>
 /// <para>Falls <see cref="GarminCore.Files.StdFile_DEM"/> keine DEM-Datei ist, wird null geliefert.</para>
 /// </summary>
 /// <returns></returns>
 public GarminCore.Files.StdFile_DEM GetGarminFileAsDEM()
 {
     GarminCore.Files.StdFile_DEM file = null;
     if (GarminFile == null)
     {
         GarminFile = file = new GarminCore.Files.StdFile_DEM();
         try {
             file.Read(BinaryReader);
         } catch (Exception ex) {
             throw new Exception("Error on reading DEM-File: " + ex.Message);
         }
     }
     else if (GarminFile is GarminCore.Files.StdFile_DEM)
     {
         file = GarminFile as GarminCore.Files.StdFile_DEM;
     }
     return(file);
 }
예제 #5
0
        public static void AppendChildNodesOn_Sections(TreeNode tn, GarminCore.Files.StdFile_DEM dem, NodeContent.NodeType nodetype)
        {
            DeleteDummyChildNode(tn);

            switch (nodetype)
            {
            case NodeContent.NodeType.DEM_Zoomlevel:
                for (int i = 0; i < dem.ZoomlevelCount; i++)
                {
                    TreeNode tn2      = AppendNode(tn, NodeContent.NodeType.Index, i, "Zoomlevel " + i.ToString());
                    int      subtiles = (dem.ZoomLevel[i].ZoomlevelItem.MaxIdxHoriz + 1) * (dem.ZoomLevel[i].ZoomlevelItem.MaxIdxVert + 1);
                    for (int j = 0; j < subtiles; j++)
                    {
                        AppendNode(tn2, NodeContent.NodeType.Index, j, "Subtile " + j.ToString());
                    }
                }
                break;
            }
        }
예제 #6
0
        /// <summary>
        /// liefert einen <see cref="GarminCore.BinaryReaderWriter"/> für die DEM-Datei
        /// </summary>
        /// <param name="dembr"></param>
        /// <param name="outpath">Ausgabepfad</param>
        /// <param name="basefilename"></param>
        /// <param name="overwrite"></param>
        /// <param name="symbolname"></param>
        /// <param name="zoomlevel"></param>
        static void CalculateDem(GarminCore.BinaryReaderWriter dembr, string outpath, string basefilename, bool overwrite, string symbolname, IList <int> zoomlevel)
        {
            GarminCore.Files.StdFile_DEM dem = new GarminCore.Files.StdFile_DEM();
            dem.Read(dembr);
            Console.WriteLine("-> " + basefilename + ".DEM with " + dem.ZoomlevelCount.ToString() + " zoomlevels");

            if (!Directory.Exists(outpath))
            {
                Directory.CreateDirectory(outpath);
            }

            string protfile = Path.Combine(outpath, basefilename + ".txt");

            if (File.Exists(protfile))
            {
                if (!overwrite)
                {
                    throw new Exception("Error: File '" + protfile + "' exists.");
                }
                else
                {
                    File.Delete(protfile);
                }
            }

            using (StreamWriter file = new StreamWriter(protfile)) {
                file.WriteLine(dem.ZoomlevelCount.ToString() + " zoomlevel");

                List <double> lon = new List <double>();
                List <double> lat = new List <double>();

                for (int zl = 0; zl < dem.ZoomlevelCount; zl++)
                {
                    bool used = false;
                    for (int i = 0; i < zoomlevel.Count; i++)
                    {
                        if (zoomlevel[i] == zl)
                        {
                            used = true;
                            break;
                        }
                    }
                    if (used)
                    {
                        GarminCore.Files.DEM.ZoomlevelTableitem record = dem.ZoomLevel[zl].ZoomlevelItem;

                        double west    = record.West;
                        double north   = record.North;
                        double ptdisth = record.PointDistanceHoriz;
                        double ptdistv = record.PointDistanceVert;

                        file.WriteLine("");
                        file.WriteLine("zoomlevel " + zl.ToString());
                        file.WriteLine("{0}x{1} tiles", record.MaxIdxHoriz + 1, record.MaxIdxVert + 1);
                        file.WriteLine("height {0} ... {1}", record.MinHeight, record.MaxHeight);

                        lon.Clear();
                        lat.Clear();
                        int subtileidx = 0;
                        for (int x = 0; x <= record.MaxIdxHoriz; x++)
                        {
                            for (int y = 0; y <= record.MaxIdxVert; y++)
                            {
                                GarminCore.Files.DEM.SubtileTableitem subtile = dem.ZoomLevel[zl].Subtiles[subtileidx].Tableitem;
                                subtileidx++;

                                double tileleft = west + x * (record.PointsHoriz - 1) * ptdisth;
                                double tiletop  = north - y * (record.PointsVert - 1) * ptdistv;

                                file.WriteLine("subtile: x={0}, y={1}, baseheight {2}, heightdiff {3}, west={4}, north={5}",
                                               x,
                                               y,
                                               subtile.Baseheight,
                                               subtile.Diff,
                                               tileleft.ToString(CultureInfo.InvariantCulture),
                                               tiletop.ToString(CultureInfo.InvariantCulture));

                                int maxx = x < record.MaxIdxHoriz ? record.PointsHoriz : record.LastColWidth + 1;
                                int maxy = y < record.MaxIdxVert ? record.PointsVert : record.LastRowHeight + 1;
                                for (int xt = 0; xt < maxx; xt++)
                                {
                                    for (int yt = 0; yt < maxx; yt++)
                                    {
                                        lat.Add(tileleft + xt * ptdisth);
                                        lon.Add(tiletop - yt * ptdistv);
                                    }
                                }

                                WriteGpxFile(outpath, basefilename, zl, x, y, overwrite, symbolname, lon, lat, maxx, maxy);
                            }
                        }
                    }
                }
            }
        }
예제 #7
0
        /// <summary>
        /// Funktion für alle Datei-Infos
        /// </summary>
        /// <param name="info"></param>
        /// <param name="hex"></param>
        /// <param name="firsthexadr"></param>
        /// <param name="filedata"></param>
        /// <param name="nodetype">"Thema" der Info</param>
        /// <param name="idx">wenn größer oder gleich 0, dann der Index auf ein Objekt einer Tabelle</param>
        /// <param name="tn"></param>
        public static void SectionAndIndex(StringBuilder info, out byte[] hex, out long firsthexadr, NodeContent.Content4File filedata, NodeContent.NodeType nodetype, int idx, TreeViewData tvd)
        {
            GarminCore.Files.StdFile_DEM dem = filedata.GetGarminFileAsDEM();
            int hexlen = 0;

            firsthexadr = 0;
            hex         = null;

            switch (nodetype)
            {
            case NodeContent.NodeType.DEM_Zoomlevel:
                firsthexadr = dem.PtrZoomlevel;
                if (idx < 0)
                {
                    info.AppendLine("ZoomlevelCount:       " + DecimalAndHexAndBinary(dem.ZoomlevelCount));
                    info.AppendLine("ZoomlevelRecordSize:  " + DecimalAndHexAndBinary(dem.ZoomlevelRecordSize));
                    hexlen = dem.ZoomlevelRecordSize * dem.ZoomlevelCount;
                }
                else
                {
                    GarminCore.Files.DEM.ZoomlevelTableitem record = dem.ZoomLevel[idx].ZoomlevelItem;

                    info.AppendLine("SpecType                (1 Byte): " + DecimalAndHexAndBinary(record.SpecType));
                    info.AppendLine("Number                  (1 Byte): " + DecimalAndHexAndBinary(record.No));
                    info.AppendLine("Tilesize horizontal     (4 Byte): " + DecimalAndHexAndBinary(record.PointsHoriz));
                    info.AppendLine("Tilesize vertical       (4 Byte): " + DecimalAndHexAndBinary(record.PointsVert));
                    info.AppendLine("LastRowHeight           (4 Byte): " + DecimalAndHexAndBinary(record.LastRowHeight));
                    info.AppendLine("LastColWidth            (4 Byte): " + DecimalAndHexAndBinary(record.LastColWidth));
                    info.AppendLine("Unknown12               (2 Byte): " + DecimalAndHexAndBinary(record.Unknown12));
                    info.AppendLine("MaxIdxHoriz             (4 Byte): " + DecimalAndHexAndBinary(record.MaxIdxHoriz));
                    info.AppendLine("MaxIdxVert              (4 Byte): " + DecimalAndHexAndBinary(record.MaxIdxVert));
                    info.AppendLine("Structure               (2 Byte): " + DecimalAndHexAndBinary(record.Structure, 16));
                    info.AppendLine("   OffsetSize              (Bit 0,1) +1: " + record.Structure_OffsetSize + " Byte");
                    info.AppendLine("   BaseheightSize          (Bit 2) +1:   " + record.Structure_BaseheightSize + " Byte");
                    info.AppendLine("   DiffSize                (Bit 3) +1:   " + record.Structure_DiffSize + " Byte");
                    info.AppendLine("   CodingtypeSize          (Bit 4):      " + record.Structure_CodingtypeSize + " Byte");
                    info.AppendLine("SubtileTableitemSize    (2 Byte): " + DecimalAndHexAndBinary(record.SubtileTableitemSize));
                    info.AppendLine("SubtileTableOffset      (4 Byte): " + DecimalAndHexAndBinary(record.PtrSubtileTable));
                    info.AppendLine("HeightdataOffset        (4 Byte): " + DecimalAndHexAndBinary(record.PtrHeightdata));
                    info.AppendLine("Left                    (4 Byte): " + DecimalAndHexAndBinary(record.west) + "; " + record.West.ToString() + "°");
                    info.AppendLine("Top                     (4 Byte): " + DecimalAndHexAndBinary(record.north) + "; " + record.North.ToString() + "°");
                    info.AppendLine("PointDistanceVertical   (4 Byte): " + DecimalAndHexAndBinary(record.pointDistanceVert) + "; " + record.PointDistanceVert.ToString() + "°");
                    info.AppendLine("PointDistanceHorizontal (4 Byte): " + DecimalAndHexAndBinary(record.pointDistanceHoriz) + "; " + record.PointDistanceHoriz.ToString() + "°");
                    info.AppendLine("MinHeight               (2 Byte): " + DecimalAndHexAndBinary(record.MinHeight));
                    info.AppendLine("MaxHeight               (2 Byte): " + DecimalAndHexAndBinary(record.MaxHeight));

                    firsthexadr += idx * dem.ZoomlevelRecordSize;
                    hexlen       = dem.ZoomlevelRecordSize;
                }
                break;

            case NodeContent.NodeType.Index:
                // etwas tricky, aber nc.Data des übergeordneten Knotens ist der ZoomLevel-Index
                if (tvd.TreeView.SelectedNode != null)
                {
                    int         zoomlevelidxidx = -1;
                    NodeContent nc = NodeContent4TreeNode(tvd.TreeView.SelectedNode.Parent);
                    if (nc.Type == NodeContent.NodeType.Index)
                    {
                        zoomlevelidxidx = (int)nc.Data;
                    }
                    if (zoomlevelidxidx >= 0)
                    {
                        GarminCore.Files.DEM.ZoomlevelTableitem zoomlevel = dem.ZoomLevel[zoomlevelidxidx].ZoomlevelItem;
                        GarminCore.Files.DEM.SubtileTableitem   subtile   = dem.ZoomLevel[zoomlevelidxidx].Subtiles[idx].Tableitem;
                        info.AppendLine("Offset     (" + zoomlevel.Structure_OffsetSize + " Byte): " + DecimalAndHexAndBinary(subtile.Offset));
                        info.AppendLine("Baseheight (" + zoomlevel.Structure_BaseheightSize + " Byte): " + DecimalAndHexAndBinary(subtile.Baseheight));
                        info.AppendLine("Diff       (" + zoomlevel.Structure_DiffSize + " Byte): " + DecimalAndHexAndBinary(subtile.Diff));
                        if (zoomlevel.Structure_CodingtypeSize > 0)
                        {
                            info.AppendLine("Type       (" + zoomlevel.Structure_CodingtypeSize + " Byte): " + DecimalAndHexAndBinary(subtile.Type));
                        }
                        info.AppendLine();
                        info.AppendLine("coded data (" + DecimalAndHexAndBinary(dem.ZoomLevel[zoomlevelidxidx].Subtiles[idx].DataLength) + " Bytes):");

                        firsthexadr = zoomlevel.PtrHeightdata + subtile.Offset;
                        hexlen      = dem.ZoomLevel[zoomlevelidxidx].Subtiles[idx].DataLength;
                    }
                }
                break;

            default:
                info.AppendLine("internal error: no info for nodetype '" + nodetype.ToString() + "'");
                break;
            }

            if (hexlen > 0)
            {
                hex = HexRange(firsthexadr, filedata.BinaryReader, hexlen);
            }
        }