public void AddWind(WindDirection dir, float ammount)
{
unsafe
{
wind[(int)dir] = ammount;
}
}
public float GetWind(WindDirection dir)
{
unsafe
{
return(wind[(int)dir]);
}
}
public async Task LoadWeatherForModels(ObservableCollection <CityTableCellViewModel> citiesModels)
{
using (var httpClient = new HttpClient())
{
foreach (var cityModel in citiesModels)
{
try
{
string url = UrlResolver.ResolveWeatherApiUrl(cityModel.WeatherId);
string json = await httpClient.GetStringAsync(url);
var data = JObject.Parse(json);
int temp = data["main"]["temp"].Value <int>();
var selectedCity = Cities.First((item) => item.WeatherId == cityModel.WeatherId);
selectedCity.CurrentWeather = Convert.ToString(temp) + " °C";
selectedCity.WindDegree = data["wind"]["deg"].Value <int>();
cityModel.Weather = selectedCity.CurrentWeather;
var wind = WindDirection.GetWindDirection(selectedCity.WindDegree);
cityModel.WindDirectionImageSource = WindDirection.GetWindImageDirection(wind);
cityModel.UpdateWeather();
}
catch
{
if (cityModel.WindDirectionImageSource == null)
{
cityModel.WindDirectionImageSource = WindDirection.GetNotLoadedImageDirection();
cityModel.UpdateWeather();
}
}
}
}
WeatherUpdated(this, new EventArgs());
}
public void Create_ValidTopLevelSubMechanismIllustrationPoint_ReturnsEntityWithSubMechanismIllustrationPointEntity()
{
// Setup
var random = new Random(21);
var illustrationPoint = new SubMechanismIllustrationPoint("Illustration point name",
random.NextDouble(),
Enumerable.Empty <SubMechanismIllustrationPointStochast>(),
Enumerable.Empty <IllustrationPointResult>());
var windDirection = new WindDirection("WindDirection Name", random.NextDouble());
var topLevelSubMechanismIllustrationPoint = new TopLevelSubMechanismIllustrationPoint(windDirection,
"Just a situation",
illustrationPoint);
int order = random.Next();
// Call
TopLevelSubMechanismIllustrationPointEntity entity =
topLevelSubMechanismIllustrationPoint.Create(order);
// Assert
TestHelper.AssertAreEqualButNotSame(topLevelSubMechanismIllustrationPoint.ClosingSituation, entity.ClosingSituation);
Assert.AreEqual(order, entity.Order);
TestHelper.AssertAreEqualButNotSame(windDirection.Name, entity.WindDirectionName);
Assert.AreEqual(windDirection.Angle, entity.WindDirectionAngle, windDirection.Angle.GetAccuracy());
SubMechanismIllustrationPointEntity subMechanismIllustrationPointEntity = entity.SubMechanismIllustrationPointEntity;
TestHelper.AssertAreEqualButNotSame(illustrationPoint.Name, subMechanismIllustrationPointEntity.Name);
Assert.AreEqual(illustrationPoint.Beta, subMechanismIllustrationPointEntity.Beta, illustrationPoint.Beta.GetAccuracy());
CollectionAssert.IsEmpty(subMechanismIllustrationPointEntity.IllustrationPointResultEntities);
CollectionAssert.IsEmpty(subMechanismIllustrationPointEntity.SubMechanismIllustrationPointStochastEntities);
}
public static string ToText(this WindDirection direction)
{
switch (direction)
{
case WindDirection.E:
return("В");
case WindDirection.NE:
return("С-В");
case WindDirection.N:
return("С");
case WindDirection.NW:
return("С-З");
case WindDirection.W:
return("З");
case WindDirection.SW:
return("Ю-З");
case WindDirection.S:
return("Ю");
case WindDirection.SE:
return("Ю-В");
case WindDirection.Calm:
return("ШТЛ");
default:
return(string.Empty);
}
}
private List <TileValue> GetFlowerTileValue(WindDirection wd)
{
List <TileValue> ret = new List <TileValue>();
if (wd == WindDirection.East)
{
ret.Add(TileValue.FlowerRomanOne);
ret.Add(TileValue.FlowerNumericOne);
}
if (wd == WindDirection.South)
{
ret.Add(TileValue.FlowerRomanTwo);
ret.Add(TileValue.FlowerNumericTwo);
}
if (wd == WindDirection.West)
{
ret.Add(TileValue.FlowerRomanThree);
ret.Add(TileValue.FlowerNumericThree);
}
if (wd == WindDirection.North)
{
ret.Add(TileValue.FlowerRomanFour);
ret.Add(TileValue.FlowerNumericFour);
}
return(ret);
}
public void Constructor_StochastNamesNotUnique_ThrowArgumentException()
{
// Setup
var random = new Random(21);
WindDirection windDirection = WindDirectionTestFactory.CreateTestWindDirection();
var stochasts = new[]
{
new Stochast("unique", random.NextDouble(), random.NextDouble()),
new Stochast("non-unique", random.NextDouble(), random.NextDouble()),
new Stochast("non-unique", random.NextDouble(), random.NextDouble()),
new Stochast("nonunique", random.NextDouble(), random.NextDouble()),
new Stochast("nonunique", random.NextDouble(), random.NextDouble())
};
IEnumerable <TopLevelIllustrationPointBase> topLevelIllustrationPoints =
Enumerable.Empty <TopLevelIllustrationPointBase>();
// Call
TestDelegate test = () => new GeneralResult <TopLevelIllustrationPointBase>(windDirection,
stochasts,
topLevelIllustrationPoints);
// Assert
const string expectedMessage = "Een of meerdere stochasten hebben dezelfde naam.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentException>(test, expectedMessage);
}
private static void ParseXForecast(XElement xForecast, List <AbstractParameter> parameters)
{
parameters.Add(Temperature.FromDouble(
xForecast.Element("temperature").Attribute("value").Value));
parameters.Add(Pressure.FromHpa(
xForecast.Element("pressure").Attribute("value").Value));
var xPrecipVal = xForecast.Element("precipitation").Attribute("value");
if (xPrecipVal != null)
{
parameters.Add(new PrecipitationAmount(
xPrecipVal.Value));
}
else
{
parameters.Add(new PrecipitationAmount(0));
}
parameters.Add(new Humidity(
xForecast.Element("humidity").Attribute("value").Value));
parameters.Add(new Cloudiness(
xForecast.Element("clouds").Attribute("all").Value));
parameters.Add(WindDirection.FromDouble(
xForecast.Element("windDirection").Attribute("deg").Value));
parameters.Add(WindSpeed.FromDouble(
xForecast.Element("windSpeed").Attribute("mps").Value));
}
public void Constructor_ChildStochastsNotEqualToTopLevelIllustrationPointStochasts_ThrowArgumentException()
{
// Setup
WindDirection windDirection = WindDirectionTestFactory.CreateTestWindDirection();
var illustrationPointNode = new IllustrationPointNode(new TestFaultTreeIllustrationPoint(new[]
{
new Stochast("Stochast 2", 0, 0)
}));
IEnumerable <TopLevelIllustrationPointBase> topLevelIllustrationPoints = new List <TopLevelIllustrationPointBase>
{
new TopLevelFaultTreeIllustrationPoint(windDirection, "closing", illustrationPointNode)
};
IEnumerable <Stochast> stochasts = new[]
{
new Stochast("Stochast 1", 0, 0)
};
// Call
TestDelegate test = () => new GeneralResult <TopLevelIllustrationPointBase>(windDirection,
stochasts,
topLevelIllustrationPoints);
// Assert
const string expectedMessage = "De stochasten van een illustratiepunt bevatten niet dezelfde stochasten als in de onderliggende illustratiepunten.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentException>(test, expectedMessage);
}
public static RoundPlayer GetNextPlayer(ICollection <RoundPlayer> players, WindDirection currentPlayerWind)
{
RoundPlayer ret;
switch (currentPlayerWind)
{
case WindDirection.East:
ret = players.First(p => p.Wind == WindDirection.South);
break;
case WindDirection.South:
ret = players.First(p => p.Wind == WindDirection.West);
break;
case WindDirection.West:
ret = players.First(p => p.Wind == WindDirection.North);
break;
case WindDirection.North:
ret = players.First(p => p.Wind == WindDirection.East);
break;
default:
throw new Exception("Error when getting next player");
}
return(ret);
}
private static void AssertWindDirection(WindDirection expectedWindDirection,
IGeneralResultEntity entity)
{
TestHelper.AssertAreEqualButNotSame(expectedWindDirection.Name, entity.GoverningWindDirectionName);
Assert.AreEqual(expectedWindDirection.Angle, entity.GoverningWindDirectionAngle,
expectedWindDirection.Angle.GetAccuracy());
}
private Vector3 GetWindFlowDirectiond(WindDirection direction)
{
Vector3 windDirection = Vector3.zero;
switch (direction)
{
case WindDirection.North:
windDirection = Vector3.forward * Time.deltaTime * windSpeed;
break;
case WindDirection.East:
windDirection = Vector3.right * Time.deltaTime * windSpeed;
break;
case WindDirection.South:
windDirection = Vector3.back * Time.deltaTime * windSpeed;
break;
case WindDirection.West:
windDirection = Vector3.left * Time.deltaTime * windSpeed;
break;
default:
Debug.Log("This direction does not exist!");
break;
}
return(windDirection);
}
public void CalculateNextFrame(Tree[] treesAround, WindDirection direction)
{
if (!Burned)
{
calculateChance(treesAround, direction);
}
}
public async Task <DancerResponse> Dancing(float latitude, float longitude)
{
var weather = await GetWeather(latitude, longitude);
var random = new Random();
var randomBirds = random.Next(100) < 10;
var dancer = new DancerResponse()
{
Lat = latitude,
Lng = longitude,
HasBirds = randomBirds,
Weather = new WeatherResponse()
{
WindDirection = WindDirection.WindDegreesToDirection(weather.Wind.Deg),
WindDegree = weather.Wind.Deg,
WindSpeed = weather.Wind.Speed
},
HasDangerDanger = IsDangerDanger(weather),
HasNoFlyZone = await _noFlyingBusiness.IsInNoFlyZone(latitude, longitude),
MaxHeight = 1000,
};
return(dancer);
}
internal static WindDirection Clone(this WindDirection original) //דרך ראשונה
{
WindDirection target = new WindDirection();
target.direction = original.direction;
return(target);
}
public ForestFireSimulator(int treesNumber, WindDirection windDirection, int threads = 1, bool showUsage = false)
{
this.treesNumber = treesNumber;
this.threads = threads;
this.showUsage = showUsage;
xSize = (int)Math.Sqrt(treesNumber);
ySize = xSize + (int)Math.Ceiling((decimal)(treesNumber - (xSize * xSize)) / xSize);
direction = windDirection;
trees = new Tree[xSize, ySize];
for (int i = 0; i < ySize; ++i)
{
for (int j = 0; j < xSize; ++j)
{
if ((i * xSize + j) < treesNumber)
{
trees[j, i] = new Tree();
}
else
{
trees[j, i] = null;
}
}
}
//Console.WriteLine("Trees: " + treesNumber + " | " + xSize + "x" + ySize + " | Free: " + free + Environment.NewLine);
}
/// <summary>
/// Parses <see cref="WindDirection"/> objects from the <paramref name="reader"/>.
/// </summary>
/// <param name="reader">The database reader.</param>
/// <exception cref="HydraRingFileParserException">Thrown when the read <see cref="IllustrationPointsDatabaseConstants.WindDirectionAngle"/>
/// is <see cref="DBNull"/> or when no governing wind direction is found.</exception>
private void ParseWindDirections(HydraRingDatabaseReader reader)
{
windDirections = new Dictionary <int, WindDirection>();
foreach (Dictionary <string, object> readWindDirection in GetIterator(reader))
{
int key = Convert.ToInt32(readWindDirection[IllustrationPointsDatabaseConstants.WindDirectionId]);
string name = Convert.ToString(readWindDirection[IllustrationPointsDatabaseConstants.WindDirectionName]);
double angle = ConvertToDouble(readWindDirection[IllustrationPointsDatabaseConstants.WindDirectionAngle],
IllustrationPointsDatabaseConstants.WindDirectionAngle);
bool isGoverning = Convert.ToBoolean(readWindDirection[IllustrationPointsDatabaseConstants.IsGoverning]);
var windDirection = new WindDirection(name, angle);
windDirections[key] = windDirection;
if (isGoverning)
{
governingWindDirection = windDirection;
}
}
if (governingWindDirection == null)
{
throw new HydraRingFileParserException(Resources.IllustrationPointsParser_Parse_No_governing_wind_direction_found);
}
}
public WeatherConditions(double windSpeed, WindDirection windDirection, double temperatureC, double precipitationIntensity)
{
this.WindSpeed = windSpeed;
this.WindDirection = windDirection;
this.TemperatureC = temperatureC;
this.PrecipitationIntensity = precipitationIntensity;
}
private WindDirection NextWindClockWise(WindDirection wind)
{
WindDirection ret;
switch (wind)
{
case WindDirection.East:
ret = WindDirection.South;
break;
case WindDirection.South:
ret = WindDirection.West;
break;
case WindDirection.West:
ret = WindDirection.North;
break;
case WindDirection.North:
ret = WindDirection.East;
break;
default:
ret = WindDirection.East;
break;
}
return(ret);
}
private void calculateChance(Tree[] treesAround, WindDirection direction)
{
BurningChance = 0f;
for (int i = 0; i < treesAround.Length; ++i)
{
if (treesAround[i] != null)
{
if (treesAround[i].Burning)
{
BurningChance += .05f;
}
}
}
try
{
if ((direction == WindDirection.N && treesAround[7].Burning) ||
(direction == WindDirection.S && treesAround[3].Burning) ||
(direction == WindDirection.W && treesAround[1].Burning) ||
(direction == WindDirection.E && treesAround[5].Burning))
{
BurningChance += .5f;
}
}
catch (NullReferenceException ex) { }
}
protected override void Update(GameTime gameTime)
{
InputManager.Update();
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
{
Exit();
}
if (InputManager.OnKeyUp(Keys.N))
{
_windDirection = WindDirection.None;
}
else if (InputManager.OnKeyUp(Keys.Left))
{
_windDirection = WindDirection.Left;
}
else if (InputManager.OnKeyUp(Keys.Right))
{
_windDirection = WindDirection.Right;
}
else if (InputManager.OnKeyUp(Keys.Up))
{
IncreaseFireSource();
}
else if (InputManager.OnKeyUp(Keys.Down))
{
DecreaseFireSource();
}
CalculateFirePropagation();
base.Update(gameTime);
}
public WeatherTelemetryEvent(DateTime measurementStartTime,
DateTime measurementEndTime,
double temperature,
double pressure,
double humidity,
int lightLevel,
WindDirection currentWindDirection,
WindDirection mostFrequentWindDirection,
double averageWindSpeed,
double maxWindSpeed,
double minWindSpeed,
float precipitation)
{
MeasurementStartTime = measurementStartTime;
MeasurementEndTime = measurementEndTime;
Temperature = temperature;
Pressure = pressure;
Humidity = humidity;
LightLevel = lightLevel;
CurrentWindDirection = currentWindDirection;
MostFrequentWindDirection = mostFrequentWindDirection;
AverageWindSpeed = averageWindSpeed;
MaxWindSpeed = maxWindSpeed;
MinWindSpeed = minWindSpeed;
Precipitation = precipitation;
}
public void ToString_DifferentClosingSituations_ReturnsCombinationOfWindDirectionAndClosingSituation()
{
// Setup
string illustrationPointName = string.Empty;
var subMechanismIllustrationPoint =
new SubMechanismIllustrationPoint(illustrationPointName,
3,
Enumerable.Empty <SubMechanismIllustrationPointStochast>(),
Enumerable.Empty <IllustrationPointResult>());
const string closingSituation = "direction";
WindDirection windDirection = WindDirectionTestFactory.CreateTestWindDirection();
var context = new TopLevelSubMechanismIllustrationPoint(windDirection,
closingSituation,
subMechanismIllustrationPoint);
// Call
var properties = new TopLevelSubMechanismIllustrationPointProperties(
context,
new[]
{
closingSituation,
closingSituation,
"Different situation"
});
// Assert
string expectedStringValue = $"{windDirection.Name} ({closingSituation})";
Assert.AreEqual(expectedStringValue, properties.ToString());
}
public void ConvertToGeneralResultTopLevelFaultTreeIllustrationPoint_HydraRingGeneralResultWithFaultTreeIllustrationPointsOnly_ExpectedProperties()
{
// Setup
var random = new Random(21);
const string closingSituation = "Closing situation";
var hydraRingWindDirection = new HydraRingWindDirection("SSE", random.NextDouble());
var hydraRingWindDirectionClosingSituation = new HydraRingWindDirectionClosingSituation(
hydraRingWindDirection,
closingSituation);
var hydraRingIllustrationPoint = new HydraRingFaultTreeIllustrationPoint(
"IllustrationPoint",
random.NextDouble(),
Enumerable.Empty <HydraRingStochast>(),
HydraRingCombinationType.Or);
var hydraRingIllustrationTreeNode = new HydraRingIllustrationPointTreeNode(hydraRingIllustrationPoint);
var governingHydraRingWindDirection = new HydraRingWindDirection("Name", random.NextDouble());
var hydraRingGeneralResult = new HydraRingGeneralResult(
random.NextDouble(),
governingHydraRingWindDirection,
Enumerable.Empty <HydraRingStochast>(),
new Dictionary <HydraRingWindDirectionClosingSituation, HydraRingIllustrationPointTreeNode>
{
{
hydraRingWindDirectionClosingSituation, hydraRingIllustrationTreeNode
}
});
// Call
GeneralResult <TopLevelFaultTreeIllustrationPoint> generalResult =
GeneralResultConverter.ConvertToGeneralResultTopLevelFaultTreeIllustrationPoint(hydraRingGeneralResult);
// Assert
WindDirection generalResultGoverningWindDirection =
generalResult.GoverningWindDirection;
AssertWindDirection(governingHydraRingWindDirection, generalResultGoverningWindDirection);
TopLevelFaultTreeIllustrationPoint topLevelFaultTreeIllustrationPoint =
generalResult.TopLevelIllustrationPoints.Single();
AssertWindDirection(hydraRingWindDirection, topLevelFaultTreeIllustrationPoint.WindDirection);
Assert.AreEqual(closingSituation, topLevelFaultTreeIllustrationPoint.ClosingSituation);
IllustrationPointNode faultTreeIllustrationPoint =
topLevelFaultTreeIllustrationPoint.FaultTreeNodeRoot;
CollectionAssert.IsEmpty(faultTreeIllustrationPoint.Children);
var faultTreeIllustrationPointData = (FaultTreeIllustrationPoint)faultTreeIllustrationPoint.Data;
CollectionAssert.IsEmpty(faultTreeIllustrationPointData.Stochasts);
Assert.AreEqual(hydraRingIllustrationPoint.Name, faultTreeIllustrationPointData.Name);
Assert.AreEqual(hydraRingIllustrationPoint.Beta, faultTreeIllustrationPointData.Beta,
faultTreeIllustrationPointData.Beta.GetAccuracy());
Assert.AreEqual(CombinationType.Or, faultTreeIllustrationPointData.CombinationType);
}
public void Convert_ValidArguments_ExpectedProperties()
{
// Setup
var random = new Random(21);
var hydraRingWindDirection = new HydraRingWindDirection("Name", random.NextDouble());
var hydraRingWindDirectionClosingSituation = new HydraRingWindDirectionClosingSituation(hydraRingWindDirection,
"closing scenario");
var hydraRingIllustrationPointResult = new HydraRingIllustrationPointResult("HydraIllustrationPointResult",
"-",
random.NextDouble());
var hydraRingSubMechanismIllustrationPointStochast =
new HydraRingSubMechanismIllustrationPointStochast("HydraSubMechanismIllustrationPointStochast",
"-",
random.NextDouble(),
random.NextDouble(),
random.NextDouble());
var hydraRingSubMechanismIllustrationPoint = new HydraRingSubMechanismIllustrationPoint("name", new[]
{
hydraRingSubMechanismIllustrationPointStochast
}, new[]
{
hydraRingIllustrationPointResult
}, random.NextDouble());
// Call
TopLevelSubMechanismIllustrationPoint combination =
TopLevelSubMechanismIllustrationPointConverter.Convert(
hydraRingWindDirectionClosingSituation, hydraRingSubMechanismIllustrationPoint);
// Assert
WindDirection windDirection = combination.WindDirection;
Assert.AreEqual(hydraRingWindDirection.Angle, windDirection.Angle, windDirection.Angle.GetAccuracy());
Assert.AreEqual(hydraRingWindDirection.Name, windDirection.Name);
Assert.AreEqual(hydraRingWindDirectionClosingSituation.ClosingSituation, combination.ClosingSituation);
SubMechanismIllustrationPoint subMechanismIllustrationPoint = combination.SubMechanismIllustrationPoint;
Assert.AreEqual(hydraRingSubMechanismIllustrationPoint.Beta, subMechanismIllustrationPoint.Beta, subMechanismIllustrationPoint.Beta.GetAccuracy());
Assert.AreEqual(hydraRingSubMechanismIllustrationPoint.Name, subMechanismIllustrationPoint.Name);
IllustrationPointResult illustrationPointResult = subMechanismIllustrationPoint.IllustrationPointResults.Single();
Assert.AreEqual(hydraRingIllustrationPointResult.Description, illustrationPointResult.Description);
Assert.AreEqual(hydraRingIllustrationPointResult.Value, illustrationPointResult.Value, illustrationPointResult.Value.GetAccuracy());
SubMechanismIllustrationPointStochast stochast = subMechanismIllustrationPoint.Stochasts.Single();
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Alpha, stochast.Alpha, stochast.Alpha.GetAccuracy());
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Duration, stochast.Duration, stochast.Duration.GetAccuracy());
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Name, stochast.Name);
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Unit, stochast.Unit);
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Realization, stochast.Realization, stochast.Realization.GetAccuracy());
}
// Wrapper for the recursion.
private List <int> DisksToChangeForDirection(int place, Players player, WindDirection windDirection)
{
var result = new List <int>();
DisksToChangeForDirection(place, player, windDirection, result);
return(result);
}
public Reading(decimal temperature, decimal pressure,
decimal rainfall, WindDirection windDirection)
{
Temperature = temperature;
Pressure = pressure;
Rainfall = rainfall;
WindDirection = windDirection;
}
public WindDirection GetWindDirection(int day)
{
WindDirection direction = DataSource.directions.Find(d => true);
var directions = (WindDirections[])Enum.GetValues(typeof(WindDirections));
direction.direction = directions[rnd.Next(0, directions.Length)];
return(direction.Clone());
}
public void TestNorth()
{
string isNorth = WindDirection.GetWindDirection(0);
Assert.IsTrue(isNorth == "N");
string isN = WindDirection.GetWindDirection(360);
Assert.IsTrue(isN == "N");
}
public static string GetShortDirectionString(WindDirection actualValue)
{
switch (actualValue)
{
case WindDirection.North:
return("N");
case WindDirection.NorthNorthEast:
return("NNE");
case WindDirection.NorthEast:
return("NE");
case WindDirection.EastNorthEast:
return("ENE");
case WindDirection.East:
return("E");
case WindDirection.EastSouthEast:
return("ESE");
case WindDirection.SouthEast:
return("SE");
case WindDirection.SouthSouthEast:
return("SSE");
case WindDirection.South:
return("S");
case WindDirection.SouthSouthWest:
return("SSW");
case WindDirection.SouthWest:
return("SW");
case WindDirection.WestSouthWest:
return("WSW");
case WindDirection.West:
return("W");
case WindDirection.WestNorthWest:
return("WNW");
case WindDirection.NorthWest:
return("NW");
case WindDirection.NorthNorthWest:
return("NNW");
default:
return(String.Empty);
}
}
public Weather(DateTime date, eWindSpeed windspeed, WindDirection direction, CloudCover cover,Precipitation precip, HourlyWeather[] temperatures,double temperatureLow, double temperatureHigh)
{
this.Date = date;
this.WindSpeed = windspeed;
this.Direction = direction;
this.Cover = cover;
this.Precip = precip;
this.Temperatures = temperatures;
this.TemperatureLow = temperatureLow;
this.TemperatureHigh = temperatureHigh;
}
public void GetAvgWeatherData_CalculateAverageDirectionNearZerroWithSameSpeed_AverageDirection(
WindDirection direction1, WindDirection direction2, WindDirection result)
{
// Arrange
var weatherData = new[]
{
new WeatherDataDto { WindDirection = direction1, WindSpeed = 10 },
new WeatherDataDto { WindDirection = direction2, WindSpeed = 10 }
};
// Act
var averageWeatherData = this.calculator.GetAvgWeatherData(weatherData);
// Assert
Assert.AreEqual(averageWeatherData.WindDirection, result);
}
public Lane(string id, Server server, Vehicle type, settings Settings)
{
_id = id;
_laneNr = Convert.ToInt32(id.Substring(1,1));
_direction = (WindDirection) Enum.Parse(typeof(WindDirection),
Enum.GetNames(typeof(WindDirection)).First((s) => s.StartsWith(id.Substring(0, 1))), true);
_server = server;
_vehicle = type;
_state = TrafficLightState.Red;
_orangeTime = Settings.orangeTime;
BusDirections = new Queue<Direction>();
int windPriority = _direction == WindDirection.North || _direction == WindDirection.South ? 10 : 0;
switch (type)
{
case Vehicle.PEDESTRIAN:
_priority = 73;
break;
case Vehicle.BICYCLE:
_priority = 100;
break;
case Vehicle.CAR:
_priority = 200 + windPriority;
break;
case Vehicle.BUS:
_priority = 300 + windPriority;
break;
}
_compatibilityList = new bool[][,] { _compatibilitySelf, _compatibilityLeft, _compatibilityStraight, _compatibilityRight };
}
private double DegToRad(WindDirection? angle)
{
return DegToRad(angle.HasValue ? (int)angle : 0);
}
public Direction GetRelativeDirection(WindDirection other)
{
return _W2Direction[(int)(other + 4 - _direction) % 4];
}
public void GetAvgWeatherData_CalculateAverageDirectionWithCrosswindAndDifferentSpeed_DirectionWhereMoreSpeed(
WindDirection direction1, WindDirection direction2)
{
// Arrange
var weatherData = new[]
{
new WeatherDataDto { WindDirection = direction1, WindSpeed = 10 },
new WeatherDataDto { WindDirection = direction2, WindSpeed = 11 }
};
// Act
var averageWeatherData = this.calculator.GetAvgWeatherData(weatherData);
// Assert
Assert.AreEqual(averageWeatherData.WindDirection, direction2);
}
public void GetAvgWeatherData_CalculateAverageSpeedWithCrosswindAndDifferentSpeed_AverageSpeed(
WindDirection direction1, WindDirection direction2, double speed1, double speed2)
{
// Arrange
var weatherData = new[]
{
new WeatherDataDto { WindDirection = direction1, WindSpeed = speed1 },
new WeatherDataDto { WindDirection = direction2, WindSpeed = speed2 }
};
// Act
var averageWeatherData = this.calculator.GetAvgWeatherData(weatherData);
// Assert
Assert.AreEqual(averageWeatherData.WindSpeed, Math.Round((speed1 > speed2 ? speed1 - speed2 : speed2 - speed1) / 2, MidpointRounding.AwayFromZero));
}
private StringBuilder SetText(WindDirection direction, StringBuilder sb)
{
sb.Append(direction.GetDisplayName());
return sb;
}
private static string GetWindDirection(WindDirection? direction)
{
switch (direction)
{
case null:
return AppResource.WindDirection_Calm;
case WindDirection.North:
return AppResource.WindDirection_North;
case WindDirection.NorthEast:
return AppResource.WindDirection_NorthEast;
case WindDirection.East:
return AppResource.WindDirection_East;
case WindDirection.SouthEast:
return AppResource.WindDirection_SouthEast;
case WindDirection.South:
return AppResource.WindDirection_South;
case WindDirection.SouthWest:
return AppResource.WindDirection_SouthWest;
case WindDirection.West:
return AppResource.WindDirection_West;
case WindDirection.NorthWest:
return AppResource.WindDirection_NorthWest;
}
return string.Empty;
}
/// <summary>
/// initForecastObjects init and allocate all forecast objects
/// </summary>
private void initForecastObjects()
{
this.location = new Location();
this.sunRise = new SunRise();
this.temperature = new Temperature();
this.humidity = new Humidity();
this.pressure = new Pressure();
this.windSpeed = new WindSpeed();
this.windDirection = new WindDirection();
this.clouds = new Clouds();
this.precipitation = new Precipitation();
this.weather = new Weather();
this.lastupdate = new Lastupdate();
}
public WindInfo(WindDirection direction, string speed)
{
this._direction = direction;
this._speed = speed;
}
