public Channel(int id, int stationId, int variableId, TimeInterval availableData)
{
_id = id;
_stId = stationId;
_varId = variableId;
_availableData = availableData;
}
/// <summary>
/// Creates a new regular-spaced list and sets all values to initialValue
/// </summary>
/// <param name="period"></param>
/// <param name="step"></param>
/// <param name="initialValue"></param>
/// <returns></returns>
public TimeValueList(TimeInterval period, TimeStep step, double initialValue)
{
_timeStepFactor = (step == TimeStep.Hour) ? 24 : 1;
_start = period.Start.ToOADate();
switch(TimeStep)
{
case TimeStep.Hour:
_data = new double[(int) period.Length.TotalHours];
break;
case TimeStep.Day:
_data = new double[(int) period.Length.TotalDays];
break;
default:
throw new ArgumentException("'step' parameter must be 'Hour' or 'Day'");
}
if (initialValue != 0.0)
{
// initialize array values...
for (int i = 0; i < _data.Length; ++i)
{
_data[i] = initialValue;
}
}
}
public Channel(int id, Station st, Variable var, TimeInterval availableData)
{
_id = id;
_station = st;
_variable = var;
_availableData = availableData;
_stId = _station.Id;
_varId = _variable.Id;
}
//get the default time step
//TODO: obtain the time step from 'Variable' class instead
public static TimeStep GetDefaultTimeStep(VariableEnum v, TimeInterval interval)
{
int periodLength = (int)interval.Length.TotalDays;
switch (v)
{
case VariableEnum.Stage:
case VariableEnum.Discharge:
return (periodLength > 300) ? TimeStep.Day : TimeStep.Hour;
case VariableEnum.Temperature:
return (periodLength > 31) ? TimeStep.Day : TimeStep.Hour;
case VariableEnum.PrecipHour:
return TimeStep.Hour;
default:
return TimeStep.Day;
}
}
/// <summary>
/// Returns a time series corresponding to the specific channel and interval
/// the 'missing data' (periodList) is also internally loaded for all variables
/// except stage and discharge.
/// </summary>
/// <param name="channel"></param>
/// <param name="interval"></param>
/// <returns></returns>
public static ITimeSeries GetTimeSeries(Channel ch, TimeInterval interval)
{
VariableEnum v = ch.Variable.VarEnum;
TimeStep step = GetDefaultTimeStep(v, interval);
ITimeSeries ts;
if (v == VariableEnum.Stage)
{
ts = new HydroTimeSeries(interval.Start, interval.End);
TimeSeriesDS.LoadObservationsStage2(ch.StationId, interval.Start,
interval.End, step, (IObservationList)ts);
}
else if (v == VariableEnum.Discharge)
{
ts = new HydroTimeSeries(interval.Start, interval.End);
TimeSeriesDS.LoadObservationsDischarge2(ch.StationId, interval.Start,
interval.End, step, (IObservationList)ts);
}
else if (v == VariableEnum.Temperature)
{
ts = new HydroTimeSeries(interval.Start, interval.End);
//step = TimeStep.Hour;
TimeSeriesDS.LoadObservationsTemperature2(ch.StationId, interval.Start, interval.End, step, (IObservationList)ts);
}
else if (v == VariableEnum.Snow)
{
ts = new HydroTimeSeries(interval.Start, interval.End);
TimeSeriesDS.LoadObservationsSnow2(ch.StationId, interval.Start, interval.End, (IObservationList)ts);
}
else if (v == VariableEnum.PrecipHour || v == VariableEnum.Precip || v == VariableEnum.PrecipSum)
{
ts = new MyTimeSeries(interval.Start, interval.End, step);
TimeSeriesDS.LoadObservationsPrecip2(ch.StationId, interval.Start,
interval.End, step, (IObservationList)ts);
}
else
{
//snow
ts = new HydroTimeSeries(interval.Start, interval.End);
TimeSeriesDS.LoadObservationsSnow2(ch.StationId, interval.Start, interval.End, (IObservationList)ts);
}
return ts;
}
private void PlotTemperature(ITimeSeries ts, GraphPane myPane)
{
if (ts.Count > 0)
{
TimeInterval interv = new TimeInterval(ts.Start, ts.End);
TimeStep step = TimeSeriesManager.GetDefaultTimeStep(VariableEnum.Temperature, interv);
ITimeSeries ts2 = TimeSeriesManager.FillDataGaps(ts, step);
LineItem myCurve = myPane.AddCurve("", ts2, Color.Blue, SymbolType.None);
myCurve.Line.Width = 0.5F;
}
}
// plot the stage!
private void PlotStageDischarge(ITimeSeries ts, GraphPane myPane)
{
TimeInterval interval = new TimeInterval(ts.Start, ts.End);
if ( ts.Count > 0 )
{
List<HydroTimeSeries> tsList = TimeSeriesManager.SplitTimeSeries(ts);
foreach (HydroTimeSeries ts2 in tsList)
{
LineItem myCurve = myPane.AddCurve("", ts2, Color.Blue, SymbolType.None);
myCurve.Line.Width = 1F;
myCurve.Line.Fill = new Fill(Color.FromArgb(128, Color.Blue));
}
//mark missing data points
if (tsList.Count > 1)
{
TimeStep step = TimeSeriesManager.GetDefaultTimeStep(VariableEnum.Stage, interval);
HydroTimeSeries missingTs = TimeSeriesManager.GetMissingValuesHydro(ts, ts.Start, ts.End, step);
PlotMissingData(missingTs, myPane);
}
}
}
/// <summary>
/// Plot the snow !!!!
/// </summary>
/// <param name="ts"></param>
/// <param name="myPane"></param>
private void PlotSnow(ITimeSeries ts, GraphPane myPane)
{
TimeInterval interval = new TimeInterval(ts.Start, ts.End);
//Main creation of curve
if ( interval.Length.TotalDays < 160 )
{
BarItem myCurve = myPane.AddBar("", ts, Color.Blue);
myCurve.Bar.Border.Color = Color.Blue;
myCurve.Bar.Border.IsVisible = true;
myCurve.Bar.Fill.Type = FillType.Solid;
myCurve.Bar.Fill.IsScaled = false;
}
else if (interval.Length.TotalDays < 200)
{
StickItem myCurve = myPane.AddStick("", ts, Color.Blue);
}
else if (interval.Length.TotalDays < 400)
{
BarItem myCurve = myPane.AddBar("", ts, Color.Blue);
myCurve.Bar.Border.Color = Color.Blue;
myCurve.Bar.Border.IsVisible = true;
myCurve.Bar.Fill.Type = FillType.Solid;
myCurve.Bar.Fill.IsScaled = false;
}
else
{
StickItem myCurve = myPane.AddStick("", ts, Color.Blue);
}
//else
//{
// StickItem myCurve = myPane.AddStick("", ts, Color.Blue);
// //LineItem myCurve = myPane.AddCurve("", ts, Color.Blue, SymbolType.None);
// //myCurve.Line.Width = 0F;
// //myCurve.Line.Fill = new Fill(Color.Blue);
//}
}
/// <summary>
/// Plot the hourly precipitation !!!!
/// </summary>
private void PlotPrecipHour(ITimeSeries ts, GraphPane myPane)
{
TimeInterval interval = new TimeInterval(ts.Start, ts.End);
string varName = Resources.precip_label;
//Main creation of curve
if ( interval.Length.TotalDays <= 2 )
{
BarItem myCurve = myPane.AddBar(varName, ts, Color.Blue);
myCurve.Bar.Border.Color = Color.Blue;
myCurve.Bar.Border.IsVisible = true;
myCurve.Bar.Fill.Type = FillType.Solid;
myCurve.Bar.Fill.IsScaled = false;
}
else
{
StickItem myCurve = myPane.AddStick(varName, ts, Color.Blue);
}
//cumulative precipitation..
ITimeSeries ts2 = ts.ShowCumulative();
LineItem myCurve2 = myPane.AddCurve(Resources.precip_sum_label,
ts2, Color.Red, SymbolType.None);
myCurve2.IsY2Axis = true;
myPane.AxisChange();
}
/// <summary>
/// Generates a new 'chart' image to be written to http output stream.
/// Also saves the newly generated image to file on disk.
/// </summary>
/// <param name="ImagePath">Http request path of the chart image</param>
public Bitmap GenerateImage(string ImagePath)
{
Bitmap bmp;
ChartEngine ChartGen = new ChartEngine();
Width = 600;
Height = 275;
ShowText = true;
QueryStringValidator QVal = new QueryStringValidator(ImagePath);
QVal.Validate(); //the language and culture is also set in the validator
if (QVal.IsValid)
{
// get query string parameters
string lang = QVal.Culture;
int StId = QVal.StationId;
Variable curVar = QVal.Variable;
DateTime startTime = QVal.StartDate;
DateTime endTime = QVal.EndDate;
// TODO: for longer intervals change curVar to [precip_day]
// search for the channel corresponding to station/variable combination
ChannelSearchResult found = ChannelSearchEngine.FindByStationIdAndVariable(
StId, curVar);
if (!found.HasMatchingStations) //no matching station
{
return ChartGen.CreateErrorChart(found.ErrorMessage);
}
if (found.HasMatchingChannels) //correct results found
{
Channel ch = found.Channels[0];
ITimeSeries ts;
TimeInterval interval = new TimeInterval(startTime, endTime);
MessageWriter writer = new MessageWriter(ch.Station.Name, ch.Variable.Name);
// for precipitation, if it's hourly and a longer period,
// always select daily precipitation to display a readable graph
// otherwise, hourly precipitation will be displayed.
int maxHourPrecipPeriod = 10;
VariableEnum var = ch.Variable.VarEnum;
if (var == VariableEnum.PrecipHour && interval.Length.TotalDays > maxHourPrecipPeriod)
{
var = VariableEnum.Precip;
}
//here we retrieve the time series
ts = TimeSeriesManager.GetTimeSeries(ch, interval);
if (ts.Count == 0) //this also means 'no data for time series'
{
bmp = ChartGen.CreateErrorChart
(writer.WriteErrorMessage(MessageType.NoDataForPeriod));
}
bmp = ChartGen.CreateChart(ch, ts);
}
else
{
// incorrect input - create a 'chart' with an error message
bmp = ChartGen.CreateErrorChart(found.ErrorMessage);
}
}
else
{
// incorrect input - create a 'chart' with an error message
bmp = ChartGen.CreateErrorChart(QVal.ErrorMessage);
}
return bmp;
}
public bool ContainsPartOfInterval(TimeInterval ti)
{
return (!(ti.Start > End || ti.End < Start));
}
public static bool IsMissing(TimeInterval interval)
{
return (interval.Start == DateTime.MaxValue && interval.End == DateTime.MaxValue);
}
public bool ContainsWholeInterval(TimeInterval ti)
{
return (ti.Start >= Start && ti.End <= End);
}
