public async Task <ActionResult> Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            MeteoData meteoData = await db.MeteoDatas
                                  .Where(m => m.Id == id)
                                  .Include(m => m.MeteoDataType)
                                  .FirstOrDefaultAsync();

            if (meteoData == null)
            {
                return(HttpNotFound());
            }

            ViewBag.Role = "";
            string CurrentUserId = User.Identity.GetUserId();

            if (UserManager.IsInRole(CurrentUserId, "Admin"))
            {
                ViewBag.Role = "Admin";
            }

            return(View(meteoData));
        }
 public WeatherReport(Input userInput, MeteoData meteoData)
 {
     this.userInput = userInput;
     this.meteoData = meteoData;
     this.meteoData.addObserver(this);
     showWeatherReport();
 }
        public async Task <ActionResult> DeleteConfirmed(int id)
        {
            MeteoData meteoData = await db.MeteoDatas.FindAsync(id);

            db.MeteoDatas.Remove(meteoData);
            await db.SaveChangesAsync();

            return(RedirectToAction("Index"));
        }
        public async Task <ActionResult> Edit([Bind(Include = "Id,MeteoDataTypeId,Year,Month,Day,Longitude,Latitude,Value")] MeteoData meteoData)
        {
            if (ModelState.IsValid)
            {
                db.Entry(meteoData).State = EntityState.Modified;
                await db.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            ViewBag.MeteoDataTypeId = new SelectList(db.MeteoDataTypes
                                                     .ToList()
                                                     .OrderBy(m => m.Name), "Id", "NameGroupAdditional", meteoData.MeteoDataTypeId);
            return(View(meteoData));
        }
        public async Task <ActionResult> Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            MeteoData meteoData = await db.MeteoDatas
                                  .Where(m => m.Id == id)
                                  .Include(m => m.MeteoDataType)
                                  .FirstOrDefaultAsync();

            if (meteoData == null)
            {
                return(HttpNotFound());
            }
            return(View(meteoData));
        }
        public async Task <ActionResult> Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            MeteoData meteoData = await db.MeteoDatas.FindAsync(id);

            if (meteoData == null)
            {
                return(HttpNotFound());
            }
            ViewBag.MeteoDataTypeId = new SelectList(db.MeteoDataTypes
                                                     .ToList()
                                                     .OrderBy(m => m.Name), "Id", "NameGroupAdditional", meteoData.MeteoDataTypeId);
            return(View(meteoData));
        }
Example #7
0
        private Image <Bgr, byte> FillGraphImage(Size imgSize)
        {
            string curDirPath = Directory.GetCurrentDirectory() + "\\logs\\";

            DirectoryInfo dirInfo = new DirectoryInfo(curDirPath);

            List <Dictionary <string, object> > lReadData = new List <Dictionary <string, object> >();

            if (defaultGraphsTimeSpan)
            {
                graphsTimeSpan = new Tuple <DateTime, DateTime>(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow);
            }

            GraphVariablesTypes currVarType = GraphVariablesTypes.none;

            if (rbtnPressureGraph.Checked)
            {
                currVarType = GraphVariablesTypes.Pressure;
            }
            if (rbtnAirTempGraph.Checked)
            {
                currVarType = GraphVariablesTypes.AirTemp;
            }
            if (rbtnWaterTempGraph.Checked)
            {
                currVarType = GraphVariablesTypes.WaterTemp;
            }
            if (rbtnWindSpeedGraph.Checked)
            {
                currVarType = GraphVariablesTypes.WindSpeed;
            }


            if ((fRenderer == null) || (!prevGraphsTimeSpan.Equals(graphsTimeSpan) || currVarType != prevGraphVariable))
            {
                fRenderer = new MultipleScatterAndFunctionsRepresentation(imgSize);
                switch (currVarType)
                {
                case GraphVariablesTypes.Pressure:
                {
                    currValueColor = new Bgr(Color.Blue);
                    break;
                }

                case GraphVariablesTypes.AirTemp:
                {
                    currValueColor = new Bgr(Color.Red);
                    break;
                }

                case GraphVariablesTypes.WaterTemp:
                {
                    currValueColor = new Bgr(Color.RoyalBlue);
                    break;
                }

                case GraphVariablesTypes.WindSpeed:
                {
                    currValueColor = new Bgr(Color.Gray);
                    break;
                }

                default:
                {
                    currValueColor = new Bgr(Color.Blue);
                    break;
                }
                }
            }
            else if (fRenderer != null)
            {
                if (fRenderer.TheImage.Size != imgSize)
                {
                    fRenderer.ResizeCanvas(imgSize);
                }
            }



            if (!prevGraphsTimeSpan.Equals(graphsTimeSpan))
            {
                IEnumerable <string> ncFileNames = Directory.EnumerateFiles(curDirPath,
                                                                            "IoffeVesselInfoStream-MeteoDataLog-*.nc",
                                                                            SearchOption.TopDirectoryOnly);
                foreach (string ncFileName in ncFileNames)
                {
                    Tuple <DateTime, DateTime> currFileDateTimeRange = null;
                    try
                    {
                        currFileDateTimeRange = ServiceTools.GetNetCDFfileTimeStampsRange(ncFileName);
                    }
                    catch (Exception ex)
                    {
                        #region report

#if DEBUG
                        ServiceTools.ExecMethodInSeparateThread(this, () =>
                        {
                            theLogWindow = ServiceTools.LogAText(theLogWindow,
                                                                 "an exception has been thrown during file reading: " + Environment.NewLine + ncFileName +
                                                                 Environment.NewLine + "message: " + ex.Message + Environment.NewLine +
                                                                 ServiceTools.CurrentCodeLineDescription());
                        });
#else
                        ServiceTools.ExecMethodInSeparateThread(this, () =>
                        {
                            ServiceTools.logToTextFile(errorLogFilename,
                                                       "an exception has been thrown during file reading: " + Environment.NewLine + ncFileName +
                                                       Environment.NewLine + "message: " + ex.Message + Environment.NewLine +
                                                       ServiceTools.CurrentCodeLineDescription(), true, true);
                        });
#endif

                        #endregion report
                    }

                    if (currFileDateTimeRange == null)
                    {
                        continue;
                    }

                    if ((currFileDateTimeRange.Item1 >= graphsTimeSpan.Item1) &&
                        (currFileDateTimeRange.Item1 <= graphsTimeSpan.Item2) ||
                        (currFileDateTimeRange.Item2 >= graphsTimeSpan.Item1) &&
                        (currFileDateTimeRange.Item2 <= graphsTimeSpan.Item2))
                    {
                        Dictionary <string, object> dictFileData = null;
                        try
                        {
                            dictFileData = NetCDFoperations.ReadDataFromFile(ncFileName);
                        }
                        catch (Exception ex)
                        {
                            #region report

#if DEBUG
                            ServiceTools.ExecMethodInSeparateThread(this, () =>
                            {
                                theLogWindow = ServiceTools.LogAText(theLogWindow,
                                                                     "an exception has been thrown during file reading: " + Environment.NewLine +
                                                                     ncFileName +
                                                                     Environment.NewLine + "message: " + ex.Message + Environment.NewLine +
                                                                     ServiceTools.CurrentCodeLineDescription());
                            });
#else
                            ServiceTools.ExecMethodInSeparateThread(this, () =>
                            {
                                ServiceTools.logToTextFile(errorLogFilename,
                                                           "an exception has been thrown during file reading: " + Environment.NewLine + ncFileName +
                                                           Environment.NewLine + "message: " + ex.Message + Environment.NewLine +
                                                           ServiceTools.CurrentCodeLineDescription(), true, true);
                            });
#endif

                            #endregion report
                        }

                        if (dictFileData != null)
                        {
                            lReadData.Add(dictFileData);
                        }
                    }
                }


                foreach (Dictionary <string, object> currFileDataDict in lReadData)
                {
                    if (currFileDataDict == null)
                    {
                        continue;
                    }

                    string varNameDateTime = "DateTime";

                    List <long> currFileDateTimeLongTicksList =
                        new List <long>((currFileDataDict[varNameDateTime] as long[]));
                    List <DateTime> currFileDateTimeList =
                        currFileDateTimeLongTicksList.ConvertAll(longVal => new DateTime(longVal));

                    string           varNameMeteoData      = "MeteoData";
                    List <MeteoData> currFileMeteoDataList =
                        MeteoData.OfDenseMatrix(currFileDataDict[varNameMeteoData] as DenseMatrix);

                    if (tsMeteoDataForGraphs == null)
                    {
                        try
                        {
                            tsMeteoDataForGraphs = new TimeSeries <MeteoData>(currFileMeteoDataList, currFileDateTimeList,
                                                                              true);
                        }
                        catch (Exception ex)
                        {
                            #region report

#if DEBUG
                            ServiceTools.ExecMethodInSeparateThread(this, () =>
                            {
                                theLogWindow = ServiceTools.LogAText(theLogWindow,
                                                                     "couldn`t create timeseries: exception has been thrown" + Environment.NewLine +
                                                                     ServiceTools.CurrentCodeLineDescription() + Environment.NewLine + "message: " +
                                                                     ex.Message);
                            });
#else
                            ServiceTools.ExecMethodInSeparateThread(this, () =>
                            {
                                ServiceTools.logToTextFile(errorLogFilename,
                                                           "couldn`t create timeseries: exception has been thrown" + Environment.NewLine +
                                                           ServiceTools.CurrentCodeLineDescription() + Environment.NewLine + "message: " +
                                                           ex.Message, true, true);
                            });
#endif

                            #endregion report
                        }
                    }
                    else
                    {
                        try
                        {
                            tsMeteoDataForGraphs.AddSubseriaData(currFileMeteoDataList, currFileDateTimeList, true);
                        }
                        catch (Exception ex)
                        {
                            #region report

#if DEBUG
                            ServiceTools.ExecMethodInSeparateThread(this, () =>
                            {
                                theLogWindow = ServiceTools.LogAText(theLogWindow,
                                                                     "couldn`t create timeseries: exception has been thrown" + Environment.NewLine +
                                                                     ServiceTools.CurrentCodeLineDescription() + Environment.NewLine + "message: " +
                                                                     ex.Message);
                            });
#else
                            ServiceTools.ExecMethodInSeparateThread(this, () =>
                            {
                                ServiceTools.logToTextFile(errorLogFilename,
                                                           "couldn`t create timeseries: exception has been thrown" + Environment.NewLine +
                                                           ServiceTools.CurrentCodeLineDescription() + Environment.NewLine + "message: " +
                                                           ex.Message, true, true);
                            });
#endif

                            #endregion report
                        }
                    }
                }



                if (tsMeteoDataForGraphs == null)
                {
                    return(null);
                }

                tsMeteoDataForGraphs.SortByTimeStamps();
                tsMeteoDataForGraphs.RemoveDuplicatedTimeStamps();

                DateTime utcNow = DateTime.UtcNow;
                if (defaultGraphsTimeSpan)
                {
                    tsMeteoDataForGraphs.RemoveValues(dt => (utcNow - dt).TotalSeconds > 86400);
                }
                else
                {
                    tsMeteoDataForGraphs.RemoveValues(
                        dt => !((dt >= graphsTimeSpan.Item1) && (dt <= graphsTimeSpan.Item2)));
                }


                List <TimeSeries <MeteoData> > subSeriesBy1Minute =
                    tsMeteoDataForGraphs.SplitByTimeSpan(new TimeSpan(0, 1, 0));
                List <double>         lSubSeriesEntriesCount = subSeriesBy1Minute.ConvertAll(subs => (double)subs.Count);
                DescriptiveStatistics statsCounts            = new DescriptiveStatistics(lSubSeriesEntriesCount);
                aveMinuteEntriesCount = Convert.ToInt32(statsCounts.Mean);


                // = tsMeteoData.TimeStamps.ConvertAll(dt => (dt - maxDateTime).TotalSeconds);
            }



            List <MeteoData> meteoDataList = tsMeteoDataForGraphs.DataValues;
            DateTime         maxDateTime   = tsMeteoDataForGraphs.TimeStamps.Max();



            if ((currVarType != prevGraphVariable) || !prevGraphsTimeSpan.Equals(graphsTimeSpan))
            {
                double        minVarValue         = 0.0d;
                double        maxVarValue         = 1.0d;
                List <double> currVarToShowValues = new List <double>();
                switch (currVarType)
                {
                case GraphVariablesTypes.Pressure:
                {
                    currVarToShowValues = meteoDataList.ConvertAll(mdt => mdt.pressure);

                    TimeSeries <double> currVarTS = new TimeSeries <double>(currVarToShowValues,
                                                                            tsMeteoDataForGraphs.TimeStamps);
                    currVarTS.RemoveValues(dVal => dVal <= 900.0d);

                    currVarToShowValues = new List <double>(currVarTS.DataValues);
                    currFileSecondsList = currVarTS.TimeStamps.ConvertAll(dt => (dt - maxDateTime).TotalSeconds);

                    fRenderer.yAxisValuesConversionToRepresentTicksValues =
                        new Func <double, string>(dVal => dVal.ToString("F1"));
                    break;
                }

                case GraphVariablesTypes.AirTemp:
                {
                    currVarToShowValues = meteoDataList.ConvertAll(mdt => mdt.airTemperature);

                    TimeSeries <double> currVarTS = new TimeSeries <double>(currVarToShowValues,
                                                                            tsMeteoDataForGraphs.TimeStamps);
                    currVarTS.RemoveValues(dVal => ((dVal < -20.0d) || (dVal > 50.0d)));

                    currVarToShowValues = new List <double>(currVarTS.DataValues);
                    currFileSecondsList = currVarTS.TimeStamps.ConvertAll(dt => (dt - maxDateTime).TotalSeconds);

                    fRenderer.yAxisValuesConversionToRepresentTicksValues =
                        new Func <double, string>(dVal => dVal.ToString("F2"));
                    break;
                }

                case GraphVariablesTypes.WaterTemp:
                {
                    currVarToShowValues = meteoDataList.ConvertAll(mdt => mdt.waterTemperature);

                    TimeSeries <double> currVarTS = new TimeSeries <double>(currVarToShowValues,
                                                                            tsMeteoDataForGraphs.TimeStamps);
                    currVarTS.RemoveValues(dVal => ((dVal < -20.0d) || (dVal > 50.0d)));

                    currVarToShowValues = new List <double>(currVarTS.DataValues);
                    currFileSecondsList = currVarTS.TimeStamps.ConvertAll(dt => (dt - maxDateTime).TotalSeconds);



                    fRenderer.yAxisValuesConversionToRepresentTicksValues =
                        new Func <double, string>(dVal => dVal.ToString("F2"));
                    break;
                }

                case GraphVariablesTypes.WindSpeed:
                {
                    currVarToShowValues = meteoDataList.ConvertAll(mdt => mdt.windSpeed);

                    TimeSeries <double> currVarTS = new TimeSeries <double>(currVarToShowValues,
                                                                            tsMeteoDataForGraphs.TimeStamps);
                    currVarTS.RemoveValues(dVal => ((dVal < 0.0d) || (dVal > 50.0d)));

                    currVarToShowValues = new List <double>(currVarTS.DataValues);
                    currFileSecondsList = currVarTS.TimeStamps.ConvertAll(dt => (dt - maxDateTime).TotalSeconds);

                    fRenderer.yAxisValuesConversionToRepresentTicksValues =
                        new Func <double, string>(dVal => dVal.ToString("F1"));
                    break;
                }

                default:
                    return(null);
                }

                dvVarValues = DenseVector.OfEnumerable(currVarToShowValues);
                dvVarValues = dvVarValues.Conv(Extensions.StandardConvolutionKernels.gauss, aveMinuteEntriesCount * 10);
            }



            fRenderer.dvScatterFuncValues.Add(dvVarValues);
            fRenderer.dvScatterXSpace.Add(DenseVector.OfEnumerable(currFileSecondsList));

            fRenderer.xAxisValuesConversionToRepresentTicksValues = (dValSec) =>
            {
                DateTime currDT = tsMeteoDataForGraphs.TimeStamps.Max().AddSeconds(dValSec);
                return(currDT.ToString("yyyy-MM-dd" + Environment.NewLine + "HH:mm"));
            };

            fRenderer.scatterLineColors.Add(currValueColor);
            fRenderer.scatterDrawingVariants.Add(SequencesDrawingVariants.polyline);
            fRenderer.xSpaceMin           = currFileSecondsList.Min();
            fRenderer.xSpaceMax           = currFileSecondsList.Max();
            fRenderer.overallFuncMin      = dvVarValues.Min();
            fRenderer.overallFuncMax      = dvVarValues.Max();
            fRenderer.fixSpecifiedMargins = true;

            fRenderer.Represent();

            Image <Bgr, byte> retImg = fRenderer.TheImage;

            // расположим надпись
            string strSign = "current value: " + dvVarValues.Last().ToString("F2");

            List <TextBarImage> textBarsCases = new List <TextBarImage>();

            TextBarImage tbimTopLeftSign = new TextBarImage(strSign, retImg);
            tbimTopLeftSign.PtSurroundingBarStart =
                new Point(fRenderer.LeftServiceSpaceGapX + tbimTopLeftSign.textHalfHeight,
                          fRenderer.TopServiceSpaceGapY + tbimTopLeftSign.textHalfHeight);
            textBarsCases.Add(tbimTopLeftSign);

            TextBarImage tbimBtmLeftSign = new TextBarImage(strSign, retImg);
            tbimBtmLeftSign.PtSurroundingBarStart = new Point(fRenderer.LeftServiceSpaceGapX + tbimBtmLeftSign.textHalfHeight,
                                                              retImg.Height - fRenderer.BtmServiceSpaceGapY - tbimBtmLeftSign.textHalfHeight - tbimBtmLeftSign.textHeight * 2);
            textBarsCases.Add(tbimBtmLeftSign);

            TextBarImage tbimTopRightSign = new TextBarImage(strSign, retImg);
            tbimTopRightSign.PtSurroundingBarStart =
                new Point(
                    retImg.Width - fRenderer.RightServiceSpaceGapX - tbimTopRightSign.textHalfHeight -
                    tbimTopRightSign.textBarSize.Width, fRenderer.TopServiceSpaceGapY + tbimTopLeftSign.textHalfHeight);
            textBarsCases.Add(tbimTopRightSign);

            TextBarImage tbimBtmRightSign = new TextBarImage(strSign, retImg);
            tbimBtmRightSign.PtSurroundingBarStart =
                new Point(
                    retImg.Width - fRenderer.RightServiceSpaceGapX - tbimBtmRightSign.textHalfHeight -
                    tbimBtmRightSign.textBarSize.Width,
                    retImg.Height - fRenderer.BtmServiceSpaceGapY - tbimBtmRightSign.textHalfHeight -
                    tbimBtmRightSign.textHeight * 2);
            textBarsCases.Add(tbimBtmRightSign);

            textBarsCases.Sort((case1, case2) => (case1.SubImageInTextRect.CountNonzero().Sum() > case2.SubImageInTextRect.CountNonzero().Sum()) ? 1 : -1);

            MCvFont theFont = new MCvFont(Emgu.CV.CvEnum.FONT.CV_FONT_HERSHEY_PLAIN, 2.0d, 2.0d)
            {
                thickness = 2,
            };
            // retImg.Draw(strSign, textBarsCases[0].ptTextBaselineStart, Emgu.CV.CvEnum.FontFace.HersheyPlain, 2.0d, new Bgr(Color.Green), 2);
            retImg.Draw(strSign, ref theFont, textBarsCases[0].ptTextBaselineStart, new Bgr(Color.Green));
            retImg.Draw(textBarsCases[0].rectSurroundingBar, new Bgr(Color.Green), 2);

            prevGraphsTimeSpan = graphsTimeSpan;
            prevGraphVariable  = currVarType;

            return(retImg);
        }
Example #8
0
 public UserInput(MeteoData meteoData)
 {
     this.meteoData = meteoData;
     weatherReport = new WeatherReport(this, meteoData);
 }
Example #9
0
        private void btnPerformExport_Click(object sender, EventArgs e)
        {
            string outPath = rtbExportDestinationDirectoryPath.Text;

            outPath += (outPath.Last() == '\\') ? ("") : ("\\");

            if (cbExportMeteoData.Checked)
            {
                //export meteo data

                BackgroundWorker bgwReadMeteoData = new BackgroundWorker();
                bgwReadMeteoData.WorkerSupportsCancellation = false;
                bgwReadMeteoData.WorkerReportsProgress      = true;
                bgwReadMeteoData.DoWork += delegate(object currBGWsender, DoWorkEventArgs args)
                {
                    BackgroundWorker       selfWorker  = currBGWsender as BackgroundWorker;
                    TimeSeries <MeteoData> tsMeteoData = new TimeSeries <MeteoData>();
                    string[] meteoDataFiles            = Directory.GetFiles(Directory.GetCurrentDirectory() + "\\logs\\",
                                                                            "*MeteoDataLog*.nc");
                    int totalFilesCount = meteoDataFiles.Count();
                    int readFiles       = 0;
                    foreach (string meteoDataFileName in meteoDataFiles)
                    {
                        ThreadSafeOperations.SetText(lblStatusBar, "reading " + Path.GetFileName(meteoDataFileName), false);

                        Dictionary <string, object> currMeteoFileData =
                            NetCDFoperations.ReadDataFromFile(meteoDataFileName);

                        List <MeteoData> currFileMeteoData =
                            MeteoData.OfDenseMatrix(currMeteoFileData["MeteoData"] as DenseMatrix);
                        List <long>     currFileDatetimeLong = new List <long>(currMeteoFileData["DateTime"] as long[]);
                        List <DateTime> currFileDatetime     =
                            currFileDatetimeLong.ConvertAll <DateTime>(longDT => new DateTime(longDT));
                        tsMeteoData.AddSubseriaData(currFileMeteoData, currFileDatetime, true);

                        readFiles++;

                        selfWorker.ReportProgress(Convert.ToInt32(100.0d * readFiles / totalFilesCount));
                    }

                    args.Result = new object[] { tsMeteoData };
                };


                bgwReadMeteoData.ProgressChanged += delegate(object currBGWsender, ProgressChangedEventArgs args)
                {
                    ThreadSafeOperations.UpdateProgressBar(prbExportProgress, args.ProgressPercentage);
                };


                bgwReadMeteoData.RunWorkerCompleted += delegate(object currBGWsender, RunWorkerCompletedEventArgs args)
                {
                    ThreadSafeOperations.UpdateProgressBar(prbExportProgress, 0);

                    TimeSeries <MeteoData> tsMeteoData = (args.Result as object[])[0] as TimeSeries <MeteoData>;

                    List <Tuple <DateTime, MeteoData> > lTplMeteoData =
                        tsMeteoData.TimeStamps.Zip(tsMeteoData.DataValues,
                                                   (dt, dat) => new Tuple <DateTime, MeteoData>(dt, dat)).ToList();

                    if (cbExportFormatCSV.Checked)
                    {
                        List <string> tsMeteoDataCSV        = lTplMeteoData.ConvertAll <string>(tpl => tpl.Item1.ToString("o") + "," + tpl.Item2.ToCSV());
                        string        tsMeteoDataCSVForFile = String.Join(Environment.NewLine, tsMeteoDataCSV.ToArray <string>());
                        ServiceTools.logToTextFile(outPath + "MeteoData.csv", "DateTime," + lTplMeteoData[0].Item2.CSVHeader() + Environment.NewLine, false, false);
                        ServiceTools.logToTextFile(outPath + "MeteoData.csv", tsMeteoDataCSVForFile, true, false);
                    }
                };



                ThreadSafeOperations.SetText(lblStatusBar, "meteo data read started", false);
                bgwReadMeteoData.RunWorkerAsync();
            }
        }