コード例 #1
0
        public override void DebugPrint(string Directory, Dictionary <int, Catchment> Catchments)
        {
            if (Reduction.Count == 0)
            {
                return;
            }

            DataTable dt = new DataTable();

            dt.Columns.Add("ID15", typeof(int));
            dt.Columns.Add("RedFactor", typeof(double));

            using (ShapeWriter sw = new ShapeWriter(Path.Combine(Directory, Name + "_factors"))
            {
                Projection = MainModel.projection
            })
            {
                foreach (var kvp in Reduction)
                {
                    if (Catchments.ContainsKey(kvp.Key))
                    {
                        GeoRefData gd = new GeoRefData()
                        {
                            Geometry = Catchments[kvp.Key].Geometry
                        };
                        gd.Data              = dt.NewRow();
                        gd.Data[0]           = kvp.Key;
                        gd.Data["RedFactor"] = kvp.Value;
                        sw.Write(gd);
                    }
                }
            }
        }
コード例 #2
0
ファイル: ReductionMap.cs プロジェクト: msruzy/hydronumerics
        private void Print(Dictionary <int, Catchment> AllCatchments, string FileNameAttach)
        {
            //Get the output coordinate system
            ProjNet.CoordinateSystems.ICoordinateSystem projection;
            using (System.IO.StreamReader sr = new System.IO.StreamReader(Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "Default.prj")))
            {
                ProjNet.CoordinateSystems.CoordinateSystemFactory cs = new ProjNet.CoordinateSystems.CoordinateSystemFactory();
                projection = cs.CreateFromWkt(sr.ReadToEnd());
            }

            using (ShapeWriter sw = new ShapeWriter(Path.Combine(Path.GetDirectoryName(OutputFile.FileName), Path.GetFileNameWithoutExtension(OutputFile.FileName) + FileNameAttach))
            {
                Projection = projection
            })
            {
                for (int i = 0; i < ReductionVariables.Rows.Count; i++)
                {
                    GeoRefData gd = new GeoRefData()
                    {
                        Data = ReductionVariables.Rows[i], Geometry = AllCatchments[(int)ReductionVariables.Rows[i]["ID"]].Geometry
                    };
                    sw.Write(gd);
                }
            }
        }
コード例 #3
0
        public void WritePointShapeTest()
        {
            string File = @"..\..\..\TestData\WriteTest.Shp";

            ShapeWriter PSW = new ShapeWriter(File);

            PSW.WritePointShape(10, 20);
            PSW.WritePointShape(20, 30);
            PSW.WritePointShape(30, 40);

            DataTable DT = new DataTable();

            DT.Columns.Add("Name", typeof(string));
            DT.Rows.Add(new object[] { "point1" });
            DT.Rows.Add(new object[] { "point2" });
            DT.Rows.Add(new object[] { "point3" });

            PSW.Data.WriteDate(DT);
            PSW.Dispose();


            ShapeReader PSR = new ShapeReader(File);

            IXYPoint  p;
            DataTable DTread = PSR.Data.Read();

            foreach (DataRow dr in DTread.Rows)
            {
                Console.WriteLine(dr[0].ToString());
                p = (IXYPoint)PSR.ReadNext();
                Console.WriteLine(p.X.ToString() + "   " + p.Y.ToString());
            }
        }
コード例 #4
0
        private void SaveAndCalc(string filename)
        {
            using (ShapeWriter sw = new ShapeWriter(filename))
            {
                DataTable dt = new DataTable();
                dt.Columns.Add("Branch", typeof(string));
                dt.Columns.Add("TopoID", typeof(string));
                dt.Columns.Add("Chainage", typeof(double));
                dt.Columns.Add("DataType", typeof(string));
                dt.Columns.Add("Min", typeof(double));
                dt.Columns.Add("Max", typeof(double));
                dt.Columns.Add("Average", typeof(double));
                dt.Columns.Add("MedianMin", typeof(double));


                foreach (var p in res11file.Points)
                {
                    double        min         = double.MaxValue;;
                    double        max         = double.MinValue;
                    double        middel      = 0;
                    List <double> yearlymins  = new List <double>();
                    int           CurrentYear = 0;
                    for (int i = res11file.GetTimeStep(StartTime); i < res11file.GetTimeStep(EndTime); i++)
                    {
                        if (CurrentYear != res11file.TimeSteps[i].Year)
                        {
                            CurrentYear = res11file.TimeSteps[i].Year;
                            yearlymins.Add(Double.MaxValue);
                        }
                        double d = p.GetData(i);
                        min     = Math.Min(min, d);
                        max     = Math.Max(max, d);
                        middel += d;
                        yearlymins[yearlymins.Count - 1] = Math.Min(yearlymins.Last(), d);
                    }

                    middel /= (res11file.GetTimeStep(EndTime) - res11file.GetTimeStep(StartTime));
                    var drow = dt.NewRow();
                    drow[0] = p.BranchName;
                    drow[1] = p.TopoID;
                    drow[2] = p.Chainage;
                    drow[3] = p.pointType.ToString();
                    drow[4] = min;
                    drow[5] = max;
                    drow[6] = middel;
                    drow[7] = yearlymins.Sum(var => var) / yearlymins.Count;

                    GeoRefData grf = new GeoRefData();
                    grf.Geometry = p;
                    grf.Data     = drow;

                    sw.Write(grf);
                }
            }
        }
コード例 #5
0
ファイル: FileWriters.cs プロジェクト: msruzy/hydronumerics
        /// <summary>
        /// Writes a point shape with entries for each intake in the list. Uses the dataRow as attributes.
        /// </summary>
        /// <param name="FileName"></param>
        /// <param name="Intakes"></param>
        /// <param name="Start"></param>
        /// <param name="End"></param>
        public static void WriteShapeFromDataRow(string FileName, IEnumerable <JupiterIntake> Intakes)
        {
            ShapeWriter PSW = new ShapeWriter(FileName);

            foreach (JupiterIntake JI in Intakes)
            {
                PSW.WritePointShape(JI.well.X, JI.well.Y);
                PSW.Data.WriteData(JI.Data);
            }
            PSW.Dispose();
        }
コード例 #6
0
        public void DebugPrint(string outputpath, string FileName, string SoilGridCodesFileName)
        {
            List <GeoRefData> Allpoints;

            ProjNet.CoordinateSystems.ICoordinateSystem proj;
            using (ShapeReader shr = new ShapeReader(SoilGridCodesFileName))
            {
                proj      = shr.Projection;
                Allpoints = shr.GeoData.ToList();
            }
            Dictionary <int, GeoRefData> data = new Dictionary <int, GeoRefData>();

            foreach (var p in Allpoints)
            {
                data.Add((int)p.Data["GRIDID"], p);
            }

            string name = Path.GetFileNameWithoutExtension(FileName);

            name = "Y_" + name.Substring(name.Length - 4);

            var dt = Allpoints.First().Data.Table;

            dt.Columns.Add(name, typeof(double));
            //if(GridCounts!=null)
            //  dt.Columns.Add(name, typeof(double));

            List <GeoRefData> NewPoints = new List <GeoRefData>();

            using (ShapeWriter sw = new ShapeWriter(Path.Combine(outputpath, "Leach_" + name + "_debug.shp"))
            {
                Projection = proj
            })
            {
                using (StreamReader sr = new StreamReader(FileName))
                {
                    //        Headers = sr.ReadLine().Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
                    while (!sr.EndOfStream)
                    {
                        var    de     = sr.ReadLine().Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
                        double leach  = double.Parse(de[de.Count() - 2]);
                        int    gridid = int.Parse(de[0]);
                        var    p      = data[gridid];
                        p.Data[name] = leach;
                        NewPoints.Add(p);
                    }
                }
                foreach (var v in NewPoints)
                {
                    sw.Write(v);
                }
            }
        }
コード例 #7
0
ファイル: MouseSetup.cs プロジェクト: msruzy/hydronumerics
        public void SaveToShape(string ShapeFileName)
        {
            using (ShapeWriter sw = new ShapeWriter(ShapeFileName))
            {
                DataTable dt = new DataTable();
                dt.Columns.Add("LinkID", typeof(string));
                dt.Columns.Add("FromNode", typeof(string));
                dt.Columns.Add("ToNode", typeof(string));
                dt.Columns.Add("SpecifiedLength", typeof(double));

                foreach (var b in Links.Values)
                {
                    GeoRefData grf = new GeoRefData();
                    var        l   = new XYPolyline();
                    l.Points.Add(new XYPoint(b.UpstreamNode.pfsnode.X, b.UpstreamNode.pfsnode.Y));
                    l.Points.Add(new XYPoint(b.DownstreamNode.pfsnode.X, b.DownstreamNode.pfsnode.Y));
                    grf.Geometry = l;
                    grf.Data     = dt.NewRow();
                    grf.Data[0]  = b.pfslink.LinkID;
                    grf.Data[1]  = b.pfslink.FromNode;
                    grf.Data[2]  = b.pfslink.ToNode;
                    grf.Data[3]  = b.pfslink.SpecifiedLength;
                    sw.Write(grf);
                }
            }

            if (Branches != null && Branches.Count > 0)
            {
                using (ShapeWriter sw = new ShapeWriter(Path.Combine(Path.GetDirectoryName(ShapeFileName), Path.GetFileNameWithoutExtension(ShapeFileName) + "_branches.shp")))
                {
                    DataTable dt = new DataTable();
                    dt.Columns.Add("Name", typeof(string));
                    dt.Columns.Add("Length", typeof(double));

                    foreach (var b in Branches)
                    {
                        var line = new XYPolyline();
                        line.Points.AddRange(b.Links.Select(p => p.UpstreamNode.Location));
                        line.Points.Add(b.Links.Last().DownstreamNode.Location);
                        GeoRefData grf = new GeoRefData();
                        grf.Geometry = line;
                        grf.Data     = dt.NewRow();
                        grf.Data[0]  = b.Name;
                        grf.Data[1]  = line.GetLength();

                        sw.Write(grf);
                    }
                }
            }
        }
コード例 #8
0
ファイル: FileWriters.cs プロジェクト: msruzy/hydronumerics
        /// <summary>
        /// Writes the wells to a point shape
        /// Calculates statistics on the observations within the period from start to end
        /// </summary>
        /// <param name="FileName"></param>
        /// <param name="Wells"></param>
        /// <param name="Start"></param>
        /// <param name="End"></param>
        public static void WriteSimpleShape(string FileName, IEnumerable <IIntake> Intakes, DateTime Start, DateTime End)
        {
            ShapeWriter PSW = new ShapeWriter(FileName);

            OutputTables.PejlingerOutputDataTable PDT = new OutputTables.PejlingerOutputDataTable();

            foreach (Intake I in Intakes)
            {
                var SelectedObs = I.HeadObservations.ItemsInPeriod(Start, End);

                PSW.WritePointShape(I.well.X, I.well.Y);

                OutputTables.PejlingerOutputRow PR = PDT.NewPejlingerOutputRow();

                PR.NOVANAID = I.ToString();
                PR.LOCATION = I.well.Description;
                PR.XUTM     = I.well.X;
                PR.YUTM     = I.well.Y;
                PR.JUPKOTE  = I.well.Terrain;

                if (I.Screens.Count > 0)
                {
                    PR.INTAKETOP = I.Screens.Min(var => var.DepthToTop);
                    PR.INTAKEBOT = I.Screens.Max(var => var.DepthToBottom);
                }

                PR.NUMBEROFOB = SelectedObs.Count();
                if (SelectedObs.Count() > 0)
                {
                    PR.STARTDATO = SelectedObs.Min(x => x.Time);
                    PR.ENDDATO   = SelectedObs.Max(x => x.Time);
                    PR.MAXOBS    = SelectedObs.Max(num => num.Value);
                    PR.MINOBS    = SelectedObs.Min(num => num.Value);
                    PR.MEANOBS   = SelectedObs.Average(num => num.Value);
                }
                PDT.Rows.Add(PR);
            }


            PSW.Data.WriteDate(PDT);
            PSW.Dispose();
        }
コード例 #9
0
 public override void  DebugPrint(string Directory, Dictionary <int, Catchment> Catchments)
 {
     if (ExtraOutput)
     {
         using (ShapeWriter sw = new ShapeWriter(System.IO.Path.Combine(Directory, Name + "_debug")))
         {
             for (int i = 0; i < Data.Rows.Count; i++)
             {
                 if (Catchments.ContainsKey((int)Data.Rows[i][0]))
                 {
                     Geometry.GeoRefData gd = new Geometry.GeoRefData()
                     {
                         Geometry = Catchments[(int)Data.Rows[i][0]].Geometry, Data = Data.Rows[i]
                     };
                     sw.Write(gd);
                 }
             }
         }
     }
 }
コード例 #10
0
ファイル: Tools.cs プロジェクト: msruzy/hydronumerics
        public void TestMethod1()
        {
            Dictionary <int, int> dmuTOId15 = new Dictionary <int, int>();

            using (StreamReader sr = new StreamReader(@"D:\DK_information\Overfladevand\stationer\maol.txt"))
            {
                sr.ReadLine();
                while (!sr.EndOfStream)
                {
                    var data = sr.ReadLine().Split(new string[] { "\t" }, StringSplitOptions.None);

                    dmuTOId15.Add(int.Parse(data[1]), int.Parse(data[3]));
                }
            }
            using (ShapeWriter sw = new ShapeWriter(@"D:\DK_information\Overfladevand\stationer\stationer2.shp"))
            {
                using (ShapeReader sh = new ShapeReader(@"D:\DK_information\Overfladevand\stationer\stationer.shp"))
                {
                    var dt = sh.Data.Read();
                    dt.Columns.Add("ID15", typeof(int));
                    for (int i = 0; i < dt.Rows.Count; i++)
                    {
                        int dmunr = int.Parse(dt.Rows[i][0].ToString());

                        int id15;
                        if (dmuTOId15.TryGetValue(dmunr, out id15))
                        {
                            dt.Rows[i]["ID15"] = id15;
                        }

                        sw.Write(new Geometry.GeoRefData()
                        {
                            Geometry = sh.ReadNext(i), Data = dt.Rows[i]
                        });
                    }
                }
            }
        }
コード例 #11
0
ファイル: LakeSink.cs プロジェクト: msruzy/hydronumerics
        public override void DebugPrint(string Directory, Dictionary <int, Catchment> Catchments)
        {
            if (ExtraOutput & Update)
            {
                using (ShapeWriter sw = new ShapeWriter(Path.Combine(Directory, Name + "_debug.shp")))
                {
                    System.Data.DataTable dt = new System.Data.DataTable();
                    dt.Columns.Add("ID15", typeof(int));
                    dt.Columns.Add("LakeName", typeof(string));
                    dt.Columns.Add("NitrateReduction", typeof(double));
                    dt.Columns.Add("NitrateConcentration", typeof(double));
                    dt.Columns.Add("FlushingRatio", typeof(double));
                    foreach (var c in Catchments.Values.Where(c => c.BigLake != null))
                    {
                        var row = dt.NewRow();
                        row[0] = c.ID;
                        row[1] = c.BigLake.Name;
                        row[2] = c.BigLake.NitrateReduction.Average;
                        row[3] = c.BigLake.NitrateConcentration.Average;
                        row[4] = c.BigLake.FlushingRatio.Average;
                        sw.Write(new GeoRefData()
                        {
                            Geometry = c.Geometry, Data = row
                        });

                        using (StreamWriter st = new StreamWriter(Path.Combine(Directory, Name) + "_" + c.ID + "_debug.csv"))
                        {
                            st.WriteLine("Time;NitrateReduction;NitrateContration;FlushingRatio");
                            for (int i = 0; i < c.BigLake.NitrateReduction.Items.Count; i++)
                            {
                                st.WriteLine(c.BigLake.NitrateReduction.Items[i].Time.ToString() + ";" + c.BigLake.NitrateReduction.Items[i].Value + ";" + c.BigLake.NitrateConcentration.Items[i].Value + ";" + c.BigLake.FlushingRatio.Items[i].Value);
                            }
                        }
                    }
                }
            }
        }
コード例 #12
0
        private void button3_Click(object sender, EventArgs e)
        {
            if (saveFileDialog1.ShowDialog() == DialogResult.OK)
            {
                IEnumerable <Plant>         plants  = listBoxAnlaeg.Items.Cast <Plant>();
                IEnumerable <JupiterIntake> intakes = JupiterReader.AddDataForNovanaExtraction(plants, dateTimeStartExt.Value, dateTimeEndExt.Value);
                HeadObservations.WriteShapeFromDataRow(saveFileDialog1.FileName, intakes);

                IEnumerable <Plant> PlantWithoutIntakes = plants.Where(var => var.PumpingIntakes.Count == 0);
                if (PlantWithoutIntakes.Count() > 0)
                {
                    if (DialogResult.Yes == MessageBox.Show("The list contains plants with no intakes attached. Should these be written to a new shape-file?", "Plants without intakes!", MessageBoxButtons.YesNo))
                    {
                        if (saveFileDialog1.ShowDialog() == DialogResult.OK)
                        {
                            NovanaTables.IndvindingerDataTable dt = JupiterReader.FillPlantData(PlantWithoutIntakes, dateTimeStartExt.Value, dateTimeEndExt.Value);
                            ShapeWriter PSW = new ShapeWriter(saveFileDialog1.FileName);
                            PSW.WritePointShape(dt, dt.ANLUTMXColumn.ColumnName, dt.ANLUTMYColumn.ColumnName);
                            PSW.Dispose();
                        }
                    }
                }
            }
        }
コード例 #13
0
        public void WritePolyLineTest()
        {
            string     File = @"..\..\..\TestData\PolyLineTest.Shp";
            XYPolyline line = new XYPolyline();

            line.Points.Add(new XYPoint(0, 0));
            line.Points.Add(new XYPoint(2, 2));
            line.Points.Add(new XYPoint(4, 5));

            DataTable dt = new DataTable();

            dt.Columns.Add("tekst", typeof(string));

            GeoRefData grf = new GeoRefData();

            grf.Geometry = line;
            grf.Data     = dt.NewRow();
            grf.Data[0]  = "Her er værdien";

            ShapeWriter sp = new ShapeWriter(File);

            sp.Write(grf);
            sp.Dispose();
        }
コード例 #14
0
ファイル: Network.cs プロジェクト: msruzy/hydronumerics
        /// <summary>
        /// Writes a polyline shape file with the network
        /// </summary>
        /// <param name="shapefilename"></param>
        public void WriteToShape(string shapefilename)
        {
            using (ShapeWriter swc = new ShapeWriter(shapefilename + "_QHPoints"))
            {
                DataTable dat = new DataTable();
                dat.Columns.Add("BranchName", typeof(string));
                dat.Columns.Add("Chainage", typeof(double));
                dat.Columns.Add("Type", typeof(string));
                foreach (var b in nwkfile.MIKE_11_Network_editor.COMPUTATIONAL_SETUP.branchs)
                {
                    foreach (var p in b.points.points)
                    {
                        GeoRefData gd = new GeoRefData();
                        gd.Data = dat.NewRow();
                        gd.Data["BranchName"] = b.name;
                        gd.Data["Chainage"]   = p.Par1;

                        if (p.Par3 == 0)
                        {
                            gd.Data["Type"] = "h";
                        }
                        else
                        {
                            gd.Data["Type"] = "q";
                        }

                        var bran = Branches.FirstOrDefault(br => br.Name == b.name);
                        if (bran != null)
                        {
                            gd.Geometry = bran.GetPointAtChainage(p.Par1);
                            swc.Write(gd);
                        }
                    }
                }
            }

            ShapeWriter sw = new ShapeWriter(shapefilename);


            ShapeWriter swCsc = new ShapeWriter(shapefilename + "_CrossSections");
            DataTable   dtCsc = new DataTable();

            dtCsc.Columns.Add("Name", typeof(string));
            dtCsc.Columns.Add("TopoID", typeof(string));
            dtCsc.Columns.Add("Chainage", typeof(double));

            DataTable dt = new DataTable();

            dt.Columns.Add("Name", typeof(string));
            dt.Columns.Add("TopoID", typeof(string));
            dt.Columns.Add("ChainageStart", typeof(double));
            dt.Columns.Add("ChainageEnd", typeof(double));

            foreach (var b in branches)
            {
                GeoRefData grf = new GeoRefData();
                grf.Geometry = b.Line;
                grf.Data     = dt.NewRow();
                grf.Data[0]  = b.Name;
                grf.Data[1]  = b.TopoID;
                grf.Data[2]  = b.ChainageStart;
                grf.Data[3]  = b.ChainageEnd;
                sw.Write(grf);

                foreach (var Csc in b.CrossSections)
                {
                    GeoRefData csc_data = new GeoRefData();
                    csc_data.Geometry = Csc.Line;
                    csc_data.Data     = dtCsc.NewRow();
                    csc_data.Data[0]  = Csc.BranchName;
                    csc_data.Data[1]  = Csc.TopoID;
                    csc_data.Data[2]  = Csc.Chainage;

                    swCsc.Write(csc_data);
                }
            }
            sw.Dispose();
            swCsc.Dispose();
        }
コード例 #15
0
ファイル: SWFWriter.cs プロジェクト: mkbiltek2019/Swiffotron
        private void WriteFont(SWFFont font, int fid)
        {
            WriteBuffer fontTag = this.OpenTag(Tag.DefineFont3, font.Name + "; id=" + fid);

            char[] codes = font.CodePoints;

            /* Tag.DefineFont3 */
            {
                fontTag.WriteUI16((uint)fid);

                fontTag.WriteBit(font.HasLayout);

                fontTag.WriteBit(false); /* ISSUE 50: ShiftJIS support */
                fontTag.WriteBit(font.IsSmall);
                fontTag.WriteBit(false); /* ISSUE 51: ANSI support, though I think this might never be false. */

                fontTag.WriteBit(true);  /* ISSUE 52: We always write wide offsets. This is because we're too lazy to measure our table. */
                fontTag.WriteBit(true);  /* Spec says must be true. */

                fontTag.WriteBit(font.IsItalic);
                fontTag.WriteBit(font.IsBold);

                fontTag.WriteUI8((uint)font.LanguageCode);

                fontTag.WriteString(font.Name, true);

                fontTag.WriteUI16((uint)font.GlyphCount);

                byte[][] shapeData       = new byte[font.GlyphCount][];
                int      totalShapeBytes = 0;
                for (int i = 0; i < font.GlyphCount; i++)
                {
                    Tag format;
                    shapeData[i] = ShapeWriter.ShapeToBytes(font.GetGlyphShape(codes[i]), out format);

                    if (format != Tag.DefineFont3)
                    {
                        throw new SWFModellerException(SWFModellerError.Internal, "Can't write non-font shapes as glyphs");
                    }

                    totalShapeBytes += shapeData[i].Length;
                }

                int startOffset = font.GlyphCount * 4 + 4; /* 4 bytes per offset (wide offsets) + 4 for the code table offset */
                int nextOffset  = startOffset;
                foreach (byte[] shapeBytes in shapeData)
                {
                    fontTag.WriteUI32((uint)nextOffset);
                    nextOffset += shapeBytes.Length;
                }

                fontTag.WriteUI32((uint)(startOffset + totalShapeBytes));

                foreach (byte[] shapeBytes in shapeData)
                {
                    fontTag.WriteBytes(shapeBytes);
                }

                foreach (char code in codes)
                {
                    fontTag.WriteUI16((uint)code);
                }

                if (font.HasLayout)
                {
                    fontTag.WriteSI16(font.Ascent.Value);
                    fontTag.WriteSI16(font.Descent.Value);
                    fontTag.WriteSI16(font.Leading.Value);

                    Rect[] bounds    = new Rect[font.GlyphCount];
                    int    boundsPos = 0;
                    foreach (char c in codes)
                    {
                        GlyphLayout gl = font.GetLayout(c);
                        fontTag.WriteSI16(gl.Advance);
                        bounds[boundsPos++] = gl.Bounds;
                    }

                    foreach (Rect bound in bounds)
                    {
                        fontTag.WriteRect(bound);
                        fontTag.Align8();
                    }

                    fontTag.WriteUI16((uint)font.KerningTable.Length);
                    foreach (KerningPair kern in font.KerningTable)
                    {
                        fontTag.WriteUI16(kern.LeftChar);
                        fontTag.WriteUI16(kern.RightChar);
                        fontTag.WriteSI16(kern.Adjustment);
                    }
                }
            }

            this.CloseTag();

            if (font.HasPixelAlignment)
            {
                WriteBuffer zonesTag = this.OpenTag(Tag.DefineFontAlignZones, font.Name + "; id=" + fid);

                zonesTag.WriteUI16((uint)fid);

                if (font.ThicknessHint == null)
                {
                    throw new SWFModellerException(SWFModellerError.Internal, "Can't have pixel aligmnent without a font thickness hint.");
                }

                zonesTag.WriteUBits((uint)font.ThicknessHint, 2);
                zonesTag.WriteUBits(0, 6); /* Reserved */

                foreach (char c in codes)
                {
                    PixelAlignment pa = font.GetPixelAligment(c);

                    if (pa.ZoneInfo.Length != 2)
                    {
                        throw new SWFModellerException(SWFModellerError.Internal, "Pixel aligment should always have 2 zones.");
                    }

                    zonesTag.WriteUI8((uint)pa.ZoneInfo.Length);

                    foreach (PixelAlignment.ZoneData zi in pa.ZoneInfo)
                    {
                        /* These int values are just unparsed 16-bit floats. */
                        zonesTag.WriteUI16((uint)zi.AlignmentCoord);
                        zonesTag.WriteUI16((uint)zi.Range);
                    }

                    zonesTag.WriteUBits(0, 6); /* Reserved */
                    zonesTag.WriteBit(pa.HasY);
                    zonesTag.WriteBit(pa.HasX);
                }

                this.CloseTag();
            }

            if (font.HasExtraNameInfo)
            {
                WriteBuffer nameTag = this.OpenTag(Tag.DefineFontName, font.FullName + "; id=" + fid);

                nameTag.WriteUI16((uint)fid);
                nameTag.WriteString(font.FullName);
                nameTag.WriteString(font.Copyright);

                this.CloseTag();
            }
        }
コード例 #16
0
ファイル: SWFWriter.cs プロジェクト: mkbiltek2019/Swiffotron
        private void WriteCharacter(ICharacter ch, ListSet <Timeline> unboundClasses)
        {
            int cid;

            if (ch == null)
            {
                return;
            }

            if (this.characterMarshal.HasMarshalled(ch))
            {
                return;
            }

            int fontID = -1;

            if (ch is IFontUserProcessor)
            {
                IFontUserProcessor fup = (IFontUserProcessor)ch;
                fup.FontUserProc(delegate(IFontUser fu)
                {
                    if (fu.HasFont && !characterMarshal.HasMarshalled(fu.Font))
                    {
                        fontID = characterMarshal.GetIDFor(fu.Font);
                        this.WriteFont(fu.Font, fontID);
                    }
                    else
                    {
                        fontID = characterMarshal.GetExistingIDFor(fu.Font);
                    }
                });
            }

            if (ch is IShape)
            {
                IImage[] images = ((IShape)ch).GetImages();

                if (images != null)
                {
                    foreach (IImage image in images)
                    {
                        this.WriteImage(image);
                    }
                }

                Tag    format;
                byte[] shapeBytes = ShapeWriter.ShapeToBytes((IShape)ch, out format);

                WriteBuffer shapeTag = this.OpenTag(format);
                cid = this.characterMarshal.GetIDFor(ch);
                shapeTag.WriteUI16((uint)cid);
                shapeTag.WriteBytes(shapeBytes);
#if DEBUG
                this.LogMessage("char id=" + cid);
#endif
                this.CloseTag();
            }
            else if (ch is Sprite)
            {
                this.WriteSprite((Sprite)ch, unboundClasses);
            }
            else if (ch is EditText)
            {
                this.WriteEditText((EditText)ch, fontID);
            }
            else if (ch is StaticText)
            {
                this.WriteStaticText((StaticText)ch);
            }
            else
            {
                /* ISSUE 73 */
                throw new SWFModellerException(
                          SWFModellerError.UnimplementedFeature,
                          "Character of type " + ch.GetType().ToString() + " not currently supported in writer");
            }

            if (ch is Timeline)
            {
                Timeline tl = (Timeline)ch;
                if (tl.HasClass && !(tl.Class is AdobeClass) && !unboundClasses.Contains(tl))
                {
                    unboundClasses.Add(tl);
                }
            }
        }
コード例 #17
0
ファイル: Form1.cs プロジェクト: rupeshkumar399/seemapcell
        private void btnSaveToShape_Click(object sender, EventArgs e)
        {
            if (this.saveFileDialogShp.ShowDialog() == DialogResult.OK)
            {
                try
                {
                    List<ShapeType> list = new List<ShapeType>();
                    foreach (Feature feature in this._currentFeatureSet)
                    {
                        ShapeType item = feature.Geometry.ToShapeType();
                        if (!list.Contains(item))
                        {
                            list.Add(item);
                        }
                    }
                    List<DataColumn> list2 = new List<DataColumn>();
                    foreach (string str in this._currentFeatureSet[0].Attributes.Keys)
                    {
                        list2.Add(new DataColumn(str, this._currentFeatureSet[0].Attributes[str].GetType()));
                    }
                    foreach (ShapeType type2 in list)
                    {
                        string str2 = "";
                        if (list.Count > 1)
                        {
                            switch (type2)
                            {
                                case ShapeType.Point:
                                    str2 = "_point";
                                    break;

                                case ShapeType.MultiPoint:
                                    str2 = "_points";
                                    break;

                                case ShapeType.PolyLine:
                                    str2 = "_lines";
                                    break;

                                case ShapeType.Polygon:
                                    str2 = "_regions";
                                    break;
                            }
                        }
                        ShapeWriter writer = new ShapeWriter(Path.Combine(Path.GetDirectoryName(this.saveFileDialogShp.FileName), Path.GetFileNameWithoutExtension(this.saveFileDialogShp.FileName) + str2 + ".shp"), type2, list2.ToArray());
                        writer.Open();
                        foreach (Feature feature2 in this._currentFeatureSet)
                        {
                            if (feature2.Geometry.ToShapeType() == type2)
                            {
                                writer.WriteFeature(feature2);
                            }
                        }
                        writer.Close();
                    }
                }
                catch (Exception exception)
                {
                    MessageBox.Show("Failed to export result:\r\n" + exception.Message);
                }
            }
        }
コード例 #18
0
        public void Calibrate(MainModel MW, DateTime CStart, DateTime CEnd)
        {
            dt.Columns.Add("ID15", typeof(int));
            dt.Columns.Add("No_iterations", typeof(int));
            dt.Columns.Add("LastError", typeof(double));
            dt.Columns.Add("GWRatio", typeof(double));
            dt.Columns.Add("IntRatio", typeof(double));
            dt.Columns.Add("MainRatio", typeof(double));

            dt.Columns.Add("RedFactor", typeof(double));
            dt.PrimaryKey = new DataColumn[] { dt.Columns[0] };
            DateTime CurrentTime = CStart;


            string gwsourcename = MW.SourceModels.Single(s => s.GetType() == typeof(GroundWaterSource)).Name;

            foreach (var item in MW.AllCatchments.Values)
            {
                var row = dt.NewRow();
                row[0]      = item.ID;
                CurrentTime = CStart;

                double gwleach   = 0;
                double gwsourec  = 0;
                double gwConcDeg = 0;
                double intsource = 0;
                double intred    = 0;
                double upstream  = 0;
                double mainred   = 0;

                while (CurrentTime < CEnd)
                {
                    double IntMass      = 0;
                    var    CurrentState = MW.StateVariables.Rows.Find(new object[] { item.ID, CurrentTime });

                    gwleach += (double)CurrentState["Leaching"];

                    gwsourec += (double)CurrentState[gwsourcename];
                    IntMass   = (double)CurrentState[gwsourcename];

                    foreach (var conc in MW.InternalReductionModels.Where(s => s.GetType() == typeof(ConceptualSourceReducer) && ((ConceptualSourceReducer)s).SourceModelName == gwsourcename))
                    {
                        gwConcDeg += (double)CurrentState[conc.Name];
                        IntMass   -= (double)CurrentState[conc.Name];
                    }

                    foreach (var intsou in MW.SourceModels.Where(s => s.Name != gwsourcename))
                    {
                        intsource += (double)CurrentState[intsou.Name];
                        IntMass   += (double)CurrentState[intsou.Name];
                    }

                    foreach (var conc in MW.InternalReductionModels.Where(s => s.GetType() != typeof(ConceptualSourceReducer)))
                    {
                        intred  += (double)CurrentState[conc.Name];
                        IntMass -= (double)CurrentState[conc.Name];
                    }

                    foreach (var mainr in MW.MainStreamRecutionModels)
                    {
                        if (!CurrentState.IsNull(mainr.Name))
                        {
                            mainred += (double)CurrentState[mainr.Name];
                            IntMass -= (double)CurrentState[mainr.Name];
                        }
                    }
                    if (!CurrentState.IsNull("DownStreamOutput"))
                    {
                        IntMass = (double)CurrentState["DownStreamOutput"] - IntMass;

                        upstream += IntMass;
                    }
                    CurrentTime = CurrentTime.AddMonths(1);
                }

                if (gwleach == 0)
                {
                    row["GWRatio"] = 1;
                }
                else
                {
                    row["GWRatio"] = (gwleach - gwsourec + gwConcDeg) / gwleach;
                }
                row["IntRatio"]  = intred / (gwsourec - gwConcDeg + intsource);
                row["MainRatio"] = mainred / (gwsourec - gwConcDeg + intsource - intred + upstream);

                dt.Rows.Add(row);
            }


            CurrentTime = CStart;

            this.MW = MW;
            List <Catchment> SortedCatchments = new List <Catchment>();

            ConceptualSourceReducer GWCor = new ConceptualSourceReducer();

            GWCor.Name            = "Calibrator";
            GWCor.SourceModelName = "GroundWater";

            var LastConceptual = MW.InternalReductionModels.LastOrDefault(c => c.GetType() == typeof(ConceptualSourceReducer));

            if (LastConceptual == null)
            {
                MW.InternalReductionModels.Insert(0, GWCor);
            }
            else
            {
                MW.InternalReductionModels.Insert(MW.InternalReductionModels.IndexOf(LastConceptual) + 1, GWCor);
            }

            if (!MW.StateVariables.Columns.Contains(GWCor.Name))
            {
                MW.StateVariables.Columns.Add(GWCor.Name, typeof(double));
            }

            ConceptualSourceReducer IntCor = new ConceptualSourceReducer();

            IntCor.Name = "Calib_Int";
            MW.InternalReductionModels.Add(IntCor);
            if (!MW.StateVariables.Columns.Contains(IntCor.Name))
            {
                MW.StateVariables.Columns.Add(IntCor.Name, typeof(double));
            }

            ConceptualSourceReducer MainCor = new ConceptualSourceReducer();

            MainCor.Name = "Calib_Main";
            MW.MainStreamRecutionModels.Add(MainCor);
            if (!MW.StateVariables.Columns.Contains(MainCor.Name))
            {
                MW.StateVariables.Columns.Add(MainCor.Name, typeof(double));
            }

            foreach (var item in MW.EndCatchments)
            {
                GetCatchmentsWithObs(item, SortedCatchments);
            }
            foreach (var item in MW.AllCatchments.Values)
            {
                GWCor.Reduction.Add(item.ID, 0);
                IntCor.Reduction.Add(item.ID, 0);
                MainCor.Reduction.Add(item.ID, 0);
            }
            int totaliter = 0;

            foreach (var v in SortedCatchments)
            {
                List <double> Errors         = new List <double>();
                double        localdamp      = DampingFactor;
                double        currentreducer = 0;
                double        Error          = double.MaxValue;
                int           itercount      = 0;

                var row = dt.Rows.Find(v.ID);

                NewMessage("Calibrating " + v.ID);
                while (Math.Abs(Error) > AbsoluteConvergence & itercount < MaxNoOfIterations)
                {
                    v.ObsNitrate = null;
                    v.SimNitrate = null;
                    double accgws      = 0;
                    double accs        = 0;
                    double accsink     = 0;
                    double accmainsink = 0;
                    double obssum      = 0;

                    CurrentTime = CStart;
                    while (CurrentTime < CEnd)
                    {
                        v.MoveInTime(CurrentTime);
                        double obsn = v.Measurements.Nitrate.GetValue(CurrentTime, InterpolationMethods.DeleteValue);
                        if (obsn != v.Measurements.Nitrate.DeleteValue)
                        {
                            obssum += obsn;
                            accgws += AccumulateUpstream(GWCor.SourceModelName, v, CurrentTime);
                            foreach (var s in MW.InternalReductionModels)
                            {
                                accsink += AccumulateUpstream(s.Name, v, CurrentTime);
                            }
                            foreach (var s in MW.SourceModels.Where(ss => ss.Name != GWCor.SourceModelName))
                            {
                                accs += AccumulateUpstream(s.Name, v, CurrentTime);
                            }
                            foreach (var s in MW.MainStreamRecutionModels)
                            {
                                accmainsink += AccumulateUpstream(s.Name, v, CurrentTime);
                            }
                        }
                        CurrentTime = CurrentTime.AddMonths(1);
                    }

                    double[] sim;
                    double[] obs;
                    v.ObsNitrate.AlignRemoveDeletevalues(v.SimNitrate, out obs, out sim);
                    double simerror = obs.Sum() - sim.Sum();


                    Error = (accs + accgws - accsink - accmainsink) - obssum;

                    if (itercount == 0 & double.IsNaN(Error))
                    {
                        NewMessage("Initial error is NAN. Could not calibrate " + v.ID);
                        break;
                    }



                    currentreducer = Error / accgws * localdamp;

                    Errors.Add(Error);
                    NewMessage(Error.ToString());

                    if (double.IsNaN(Error) || (itercount > 2 && Math.Abs(Error) > Errors.Skip(itercount - 3).Take(3).Select(e => Math.Abs(e)).Max()))
                    {
                        SendReducUpstream(v, GWCor.Reduction, currentreducer, "GWRatio", true);
                        SendReducUpstream(v, IntCor.Reduction, InternalRatio * currentreducer, "IntRatio", true);
                        SendReducUpstream(v, MainCor.Reduction, MainRatio * currentreducer, "MainRatio", true);

                        NewMessage("Reduce damping and resetting reducer to first value");
                        localdamp     *= 0.5;
                        currentreducer = Errors.First() / accgws * localdamp;

                        Error = 2 * AbsoluteConvergence; //To make sure we do not NAN for testing in the next iteration.
                    }

                    SendReducUpstream(v, GWCor.Reduction, currentreducer, "GWRatio", false);
                    SendReducUpstream(v, IntCor.Reduction, InternalRatio * currentreducer, "IntRatio", false);
                    SendReducUpstream(v, MainCor.Reduction, MainRatio * currentreducer, "MainRatio", false);
                    itercount++;
                }
                totaliter += itercount;

                row[0]           = v.ID;
                row[1]           = itercount;
                row[2]           = Error;
                row["RedFactor"] = GWCor.Reduction[v.ID];

                NewMessage(v.ID + " calibrated in " + itercount + " iterations. Final error: " + Error + ". ReductionFactor: " + GWCor.Reduction[v.ID]);
            }
            NewMessage("Total number of model calls: " + totaliter);
            var outdir = Path.GetDirectoryName(MW.AlldataFile.FileName);

            GWCor.DebugPrint(outdir, MW.AllCatchments);
            IntCor.DebugPrint(outdir, MW.AllCatchments);
            MainCor.DebugPrint(outdir, MW.AllCatchments);

            using (ShapeWriter sw = new ShapeWriter(Path.Combine(outdir, "CalibrationResult"))
            {
                Projection = MainModel.projection
            })
            {
                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    GeoRefData gd = new GeoRefData()
                    {
                        Geometry = MW.AllCatchments[(int)dt.Rows[i][0]].Geometry
                    };
                    gd.Data = dt.Rows[i];
                    sw.Write(gd);
                }
            }
        }
コード例 #19
0
        public void DebugPrint(string Directory)
        {
            //We need to process data for extra output while we have the particles
            {
                foreach (var c in Catchments.Where(ca => ca.EndParticles.Count >= 1))
                {
                    if (c.EndParticles.Count >= 20)
                    {
                        c.ParticleBreakthroughCurves = new List <Tuple <double, double> >();
                        MathNet.Numerics.Statistics.Percentile p = new MathNet.Numerics.Statistics.Percentile(c.EndParticles.Select(pa => pa.TravelTime));
                        for (int i = 1; i < np; i++)
                        {
                            c.ParticleBreakthroughCurves.Add(new Tuple <double, double>(i / np * 100.0, p.Compute(i / np)));
                        }
                        //Also do oxidized breakthrough curves
                        if (c.EndParticles.Count(pp => pp.Registration != 1) >= 20)
                        {
                            c.ParticleBreakthroughCurvesOxidized = new List <Tuple <double, double> >();
                            p = new MathNet.Numerics.Statistics.Percentile(c.EndParticles.Where(pp => pp.Registration != 1).Select(pa => pa.TravelTime));
                            for (int i = 1; i < np; i++)
                            {
                                c.ParticleBreakthroughCurvesOxidized.Add(new Tuple <double, double>(i / np * 100.0, p.Compute(i / np)));
                            }
                        }
                    }
                    DataRow row = DebugData.Rows.Find(c.ID);
                    if (row == null)
                    {
                        row    = DebugData.NewRow();
                        row[0] = c.ID;
                        DebugData.Rows.Add(row);
                    }

                    row["PartCount"]  = c.EndParticles.Count;
                    row["RedoxCount"] = c.EndParticles.Count(pp => pp.Registration == 1);
                    row["RedoxRatio"] = c.EndParticles.Count(pp => pp.Registration == 1) / (double)c.EndParticles.Count;
                    if (c.EndParticles.Count > 0)
                    {
                        row["Drain_to_River"]    = c.EndParticles.Count(pa => pa.SinkType == SinkType.Drain_to_River) / (double)c.EndParticles.Count;
                        row["Drain_to_Boundary"] = c.EndParticles.Count(pa => pa.SinkType == SinkType.Drain_to_Boundary) / (double)c.EndParticles.Count;
                        row["Unsaturated_zone"]  = c.EndParticles.Count(pa => pa.SinkType == SinkType.Unsaturated_zone) / (double)c.EndParticles.Count;
                        row["River"]             = c.EndParticles.Count(pa => pa.SinkType == SinkType.River) / (double)c.EndParticles.Count;
                    }
                    row["PartCount_start"] = c.StartParticles.Count;
                }
            }



            NewMessage("Writing breakthrough curves");

            var selectedCatchments = Catchments.Where(cc => cc.ParticleBreakthroughCurves != null);

            using (System.IO.StreamWriter sw = new System.IO.StreamWriter(Path.Combine(Directory, "BC.csv")))
            {
                StringBuilder headline = new StringBuilder();
                headline.Append("ID\tNumber of Particles");

                for (int i = 1; i < np; i++)
                {
                    headline.Append("\t + " + (i / np * 100.0));
                }
                sw.WriteLine(headline);

                foreach (var c in selectedCatchments.Where(cc => cc.ParticleBreakthroughCurves != null))
                {
                    StringBuilder line = new StringBuilder();
                    line.Append(c.ID + "\t" + c.EndParticles.Count);
                    foreach (var pe in c.ParticleBreakthroughCurves)
                    {
                        line.Append("\t" + pe.Item2);
                    }
                    sw.WriteLine(line);
                }
            }

            if (selectedCatchments.Count() > 0)
            {
                using (ShapeWriter sw = new ShapeWriter(Path.Combine(Directory, Name + "_debug.shp"))
                {
                    Projection = MainModel.projection
                })
                {
                    foreach (var bc in selectedCatchments.First().ParticleBreakthroughCurves)
                    {
                        DebugData.Columns.Add(((int)bc.Item1).ToString(), typeof(double));
                    }
                    foreach (var bc in selectedCatchments.First().ParticleBreakthroughCurves)
                    {
                        DebugData.Columns.Add(((int)bc.Item1).ToString() + "Ox", typeof(double));
                    }

                    foreach (var c in selectedCatchments)
                    {
                        GeoRefData gd = new GeoRefData()
                        {
                            Geometry = c.Geometry
                        };
                        var row = DebugData.Rows.Find(c.ID);

                        if (c.ParticleBreakthroughCurves != null)
                        {
                            foreach (var bc in c.ParticleBreakthroughCurves)
                            {
                                row[((int)bc.Item1).ToString()] = bc.Item2;
                            }
                        }

                        if (c.ParticleBreakthroughCurvesOxidized != null)
                        {
                            foreach (var bc in c.ParticleBreakthroughCurvesOxidized)
                            {
                                row[((int)bc.Item1).ToString() + "Ox"] = bc.Item2;
                            }
                        }

                        gd.Data = row;
                        sw.Write(gd);
                    }
                }
            }

            //selectedCatchments = Catchments.Where(cc => cc.EndParticles.Count > 0).ToList();

            //foreach (var c in selectedCatchments)
            //{
            //  DataTable dt = new DataTable();
            //  dt.Columns.Add("Part_Id", typeof(int));
            //  dt.Columns.Add("Sink", typeof(string));
            //  dt.Columns.Add("Reg", typeof(int));

            //  using (ShapeWriter sw = new ShapeWriter(Path.Combine(Directory, c.ID + "_particles.shp")) { Projection = MainModel.projection })
            //  {
            //    foreach (var p in c.EndParticles)
            //    {
            //      var row = dt.NewRow();
            //      row["Part_Id"] = p.ID;
            //      row["Sink"] = p.SinkType.ToString();
            //      row["Reg"] = p.Registration;
            //      sw.Write(new GeoRefData() { Geometry = new XYLine(p.XStart, p.YStart, p.X, p.Y), Data = row });

            //    }
            //  }
            //}
        }