public void Repository_CalledRemove_True()
{
// Arrange
var id = Guid.NewGuid();
var expectedLocalPoint = new LocalPoint {
Id = id
};
_mockDbSet.Setup(mock => mock.Find(expectedLocalPoint.Id)).Returns(expectedLocalPoint);
// Act
var findedLocalPoint = _regionRepository.GetById(id);
_regionRepository.Remove(findedLocalPoint);
// Assert
_mockDbSet.Verify(
dbSet => dbSet.Find(
expectedLocalPoint.Id
), Times.Once());
_mockDbSet.Verify(
dbSet => dbSet.Remove(
expectedLocalPoint
), Times.Once());
}
public float Calculate_y(float _x)
{
int i;
for (i = 0; i < _points.Length && _points[i]._x < _x; i++)
{
}
LocalPoint localPoint = default(LocalPoint);
if (i == 0)
{
if (_points.Length >= 2)
{
CopyPointToLocalPoint(_points[0], ref localPoint);
}
else
{
localPoint._x = 0f;
localPoint._y = 0f;
}
}
else
{
CopyPointToLocalPoint(_points[i - 1], ref localPoint);
}
LocalPoint localPoint2 = default(LocalPoint);
if (i >= _points.Length)
{
if (_points.Length >= 2)
{
CopyPointToLocalPoint(_points[i - 1], ref localPoint2);
}
else
{
localPoint._x = 0f;
localPoint._y = 0f;
}
}
else
{
CopyPointToLocalPoint(_points[i], ref localPoint2);
}
float num = 0.5f;
if (localPoint2._x != localPoint._x)
{
num = (_x - localPoint._x) / (localPoint2._x - localPoint._x);
}
if (localPoint._y > localPoint2._y)
{
num = 1f - num;
num = 1f - CalculateValueByType(localPoint._curveType, 1f, num);
}
else
{
num = CalculateValueByType(localPoint._curveType, 1f, num);
}
return(localPoint._y + (localPoint2._y - localPoint._y) * num);
}
public LocalPoint GetLocalPoint(TerrestrialObservation terrestrialObservation)
{
LocalPoint point = new LocalPoint();
point.PointId = terrestrialObservation.PointId;
point.Y = terrestrialObservation.EdmDistance * Math.Sin((double)terrestrialObservation.VerticalAngle) * Math.Sin((double)terrestrialObservation.HorizontalCircleReading);
point.X = terrestrialObservation.EdmDistance * Math.Sin((double)terrestrialObservation.VerticalAngle) * Math.Cos((double)terrestrialObservation.HorizontalCircleReading);
point.Z = terrestrialObservation.EdmDistance * Math.Cos((double)terrestrialObservation.VerticalAngle);
return(point);
}
public async Task <string> SaveLocalCoords(LocalPoint coordinates, string roundId)
{
var filter = Builders <TerrestrialRound> .Filter.Eq(s => s._id, roundId);
var update = Builders <TerrestrialRound> .Update.Set(u => u.Results.LocalCoordinates[coordinates.PointId], coordinates);
await _MongoCollectionRounds.UpdateOneAsync(filter, update);
return(roundId);
}
private LocalPoint MeanWeightedLocalPoint(LocalPoint localPoint1, LocalPoint localPoint2, int count)
{
LocalPoint point = new LocalPoint()
{
X = (localPoint1.X * count + localPoint2.X) / (count + 1),
Y = (localPoint1.Y * count + localPoint2.Y) / (count + 1),
Z = (localPoint1.Z * count + localPoint2.Z) / (count + 1),
PointId = localPoint1.PointId
};
return(point);
}
private float CalculateValueByType(CurveTypes curveType, float value, float t)
{
float result = 0f;
switch (curveType)
{
case CurveTypes.Bezier:
{
point[0] = default(LocalPoint);
point[1] = default(LocalPoint);
point[2] = default(LocalPoint);
point[3] = default(LocalPoint);
point[0]._x = 0f;
point[0]._y = 1f;
point[3]._x = 1f;
point[3]._y = 1f - value;
point[1]._x = 1f;
point[1]._y = 1f;
point[2]._x = 0f;
point[2]._y = 1f - value;
LocalPoint dest = default(LocalPoint);
Bezier(ref dest, point, t);
result = 1f - dest._y;
break;
}
case CurveTypes.Linear:
result = t * value;
break;
case CurveTypes.Raised:
result = (float)Math.Sqrt(t) * value;
break;
case CurveTypes.Flat:
{
float num4 = t - 0.5f;
result = 0.5f - 4f * (num4 * num4 * num4);
break;
}
case CurveTypes.Log:
{
float num = 1024f;
float num2 = (float)Math.Log(1f + num) / (float)Math.Log(2.0);
float num3 = -1f;
result = ((float)Math.Pow(2.0, num2 * t) + num3) / num;
break;
}
}
return(result);
}
private void Bezier(ref LocalPoint dest, LocalPoint[] point, float t)
{
ab._x = point[0]._x + (point[1]._x - point[0]._x) * t;
ab._y = point[0]._y + (point[1]._y - point[0]._y) * t;
bc._x = point[1]._x + (point[2]._x - point[1]._x) * t;
bc._y = point[1]._y + (point[2]._y - point[1]._y) * t;
cd._x = point[2]._x + (point[3]._x - point[2]._x) * t;
cd._y = point[2]._y + (point[3]._y - point[2]._y) * t;
abbc._x = ab._x + (bc._x - ab._x) * t;
abbc._y = ab._y + (bc._y - ab._y) * t;
bccd._x = bc._x + (cd._x - bc._x) * t;
bccd._y = bc._y + (cd._y - bc._y) * t;
dest._x = abbc._x + (bccd._x - abbc._x) * t;
dest._y = abbc._y + (bccd._y - abbc._y) * t;
}
private ILocalPointService GetLocalPointService(Guid itemId)
{
var mockContext = new Mock <IUnitOfWork>();
var expectedLocalPoint = new LocalPoint()
{
Id = itemId,
Name = "testName",
Description = "testDescription"
};
var mockDbSet = new Mock <IRepository <LocalPoint> >();
mockDbSet.Setup(mock => mock.GetByIdAsync(itemId)).ReturnsAsync(expectedLocalPoint);
mockContext
.Setup(context =>
context.Repository <LocalPoint>())
.Returns(mockDbSet.Object);
mockContext.Setup(mock => mock.GetByIdAsync <LocalPoint>(itemId)).ReturnsAsync(expectedLocalPoint);
var cfg = new MapperConfiguration(a => a.AddProfile <LocalPointProfile>());
ILocalPointService regionService = new LocalPointService(mockContext.Object, new Mapper(cfg));
return(regionService);
}
private double Get2dDist(LocalPoint point1, LocalPoint point2)
{
return(Math.Sqrt(Math.Pow((double)(point2.X - point1.X), 2) + Math.Pow((double)(point2.Y - point1.Y), 2)));
}
private double Get3dDist(LocalPoint point1, LocalPoint point2)
{
//Gets the 3D distance between 2 coordinates
return(Math.Sqrt(Math.Pow((double)(point2.X - point1.X), 2) + Math.Pow((double)(point2.Y - point1.Y), 2) + Math.Pow((double)(point2.Z - point1.Z), 2)));
}
private void CopyPointToLocalPoint(Point point, ref LocalPoint localPoint)
{
localPoint._x = point._x;
localPoint._y = point._y;
localPoint._curveType = point._curveType;
}
