private WriteableBitmap ReadCroppedImage()
{
string pathForCrop = this.GetPathForCrop();
using (IsolatedStorageFile storeForApplication = IsolatedStorageFile.GetUserStoreForApplication())
{
using (IsolatedStorageFileStream storageFileStream1 = storeForApplication.OpenFile(pathForCrop, (FileMode)3, (FileAccess)1))
{
int num1 = 0;
int num2 = 0;
if (this._currentEffects.CropRect != null)
{
num1 = this._currentEffects.CropRect.Width;
num2 = this._currentEffects.CropRect.Height;
}
BitmapImage bitmapImage = new BitmapImage();
Rect fit = RectangleUtils.ResizeToFit(new Rect(new Point(), this.ViewportSize), new Size((double)num1, (double)num2));
// ISSUE: explicit reference operation
int height = (int)((Rect)@fit).Height;
bitmapImage.DecodePixelHeight = height;
IsolatedStorageFileStream storageFileStream2 = storageFileStream1;
((BitmapSource)bitmapImage).SetSource((Stream)storageFileStream2);
return(new WriteableBitmap((BitmapSource)bitmapImage));
}
}
}
public void PutNextRectangle_ShouldPlaceRectanglesTightly_WhenManyRectanglesWithDifferentSize(
int rectanglesCount)
{
var sizes = new List <Size>();
var rnd = new Random();
for (var i = 0; i < rectanglesCount; i++)
{
var width = rnd.Next(10);
var height = rnd.Next(10);
sizes.Add(new Size(width, height));
}
rectangles = sizes.Select(s => layouter.PutNextRectangle(s)).ToList();
foreach (var rectangle in rectangles)
{
foreach (var closerRectangle in RectangleUtils.GetRectanglesThatCloserToPoint(
config.Center, rectangle, 1))
{
rectangles
.Where(r => r != rectangle)
.Select(r => RectangleUtils.RectanglesAreIntersected(r, closerRectangle))
.Should()
.Contain(true);
}
}
}
public float Sample(Vector2 uv)
{
var subUv = RectangleUtils.CalculateSubPosition(_intensityFieldFigureWithUv.Uv, uv);
var toReturn = _intensityFieldFigureWithUv.FieldFigure.GetPixelWithUv(subUv);
return(toReturn);
}
private GameObject CreateShapeObject(Mesh mesh, HeightPyramidSegmentShapeTemplate shapeTemplate, string name)
{
var go = new GameObject(name);
var flatStartPos = shapeTemplate.FlatPosition;
go.transform.localPosition = new Vector3(flatStartPos.x, 0, flatStartPos.y);
var flatSize = shapeTemplate.FlatSize;
go.transform.localScale = new Vector3(flatSize.x, 1, flatSize.y);
var renderer = go.AddComponent <MeshRenderer>();
var segmentUvs = RectangleUtils.CalculateSubelementUv(_perLevelConfiguration.FloorTextureZeroCenteredWorldArea,
new MyRectangle(flatStartPos.x, flatStartPos.y, flatSize.x, flatSize.y));
renderer.material = new Material(Shader.Find("Custom/ETerrain/Ground"));
renderer.material.SetVector("_SegmentCoords", segmentUvs.ToVector4());
var segmentLevelUvs = RectangleUtils.CalculateSubelementUv(_perLevelConfiguration.FloorTextureZeroCenteredWorldArea.SubRectangle(new MyRectangle(1 / 6.0f, 1 / 6.0f, 4 / 6.0f, 4 / 6.0f)),
new MyRectangle(flatStartPos.x, flatStartPos.y, flatSize.x, flatSize.y));
renderer.material.SetVector("_SegmentLevelCoords", segmentLevelUvs.ToVector4());
var mf = go.AddComponent <MeshFilter>();
mf.sharedMesh = mesh;
return(go);
}
private Vector2 CalculateFollowerMarginUv(WeldSideSource biggerTerrain, WeldSideSource smallerTerrain)
{
var biggerSideRange = new Vector2(0, 0);
if (biggerTerrain.SideType.GetOrientation() == WeldOrientation.Horizontal)
{
biggerSideRange = RectangleUtils.CalculateSubPosition(biggerTerrain.Terrain.DetailGlobalArea,
biggerTerrain.Terrain.UvCoordsPositions2D).XRange;
}
else
{
biggerSideRange = RectangleUtils.CalculateSubPosition(biggerTerrain.Terrain.DetailGlobalArea,
biggerTerrain.Terrain.UvCoordsPositions2D).YRange;
}
var smallerSideRange = new Vector2(0, 0);
if (smallerTerrain.SideType.GetOrientation() == WeldOrientation.Horizontal)
{
smallerSideRange = RectangleUtils.CalculateSubPosition(smallerTerrain.Terrain.DetailGlobalArea,
smallerTerrain.Terrain.UvCoordsPositions2D).XRange;
}
else
{
smallerSideRange = RectangleUtils.CalculateSubPosition(smallerTerrain.Terrain.DetailGlobalArea,
smallerTerrain.Terrain.UvCoordsPositions2D).YRange;
}
var uv = VectorUtils.CalculateSubelementUv(biggerSideRange, smallerSideRange);
Preconditions.Assert(uv.IsNormalized(),
$"E76 Margin uv is not normalized: {uv}, biggerSideRange:{biggerSideRange}, smallerSideRange {smallerSideRange}");
return(uv);
}
private async Task <double?> VerticalLabelPriceSearch(RecognitionResult recognitionResult, Metadata imageMetadata, string[] patterns)
{
Dictionary <string, string> rawExpenses = new Dictionary <string, string>();
List <TextRectangle> rectangles = recognitionResult.Lines
.Select((line) => RectangleUtils.FromPointsArray(line))
.ToList();
// Zone 0
var map = new RectanglesZoneMap(rectangles, imageMetadata);
var priceRegex = new Regex(@"^\s*(\W\D){0,1}\s*[\d,]+\.[\d]{2}\s*$", RegexOptions.IgnoreCase);
bool found = false;
int startingX = -1;
int startingY = -1;
for (int i = 0; i < map.VerticalZoneCount; i++)
{
for (int k = 0; k < map.HorizontalZoneCount; k++)
{
if (TestForPriceLabel(map.MapMatrix[i, k], patterns))
{
found = true;
startingX = k;
startingY = i;
break;
}
}
}
if (found)
{
int offsetX = startingX + 4;
if (offsetX >= map.HorizontalZoneCount)
{
offsetX = map.HorizontalZoneCount - 1;
}
for (int cY = startingY; cY < map.VerticalZoneCount; cY++)
{
for (int cX = startingX; cX < offsetX; cX++)
{
var cleanStr = map.MapMatrix[cY, cX].Trim().Replace(" ", "");
if (priceRegex.IsMatch(cleanStr))
{
try {
var value = double.Parse(cleanStr, System.Globalization.NumberStyles.Currency, CultureInfo.GetCultureInfo("si-LK"));
return(value);
} catch (Exception e) {
Debug.Print(e.StackTrace);
break;
}
}
}
}
}
return(null);
}
private async Task <DateTime?> VerticalLabelDateSearch(RecognitionResult recognitionResult, Metadata imageMetadata, string[] patterns)
{
Dictionary <string, string> rawExpenses = new Dictionary <string, string>();
List <TextRectangle> rectangles = recognitionResult.Lines
.Select((line) => RectangleUtils.FromPointsArray(line))
.ToList();
// Zone 0
var map = new RectanglesZoneMap(rectangles, imageMetadata);
var dateRegex = new Regex(@"^\s*\d{2}\/\d{2}\/\d{4}\s*$", RegexOptions.IgnoreCase);
bool found = false;
int startingX = -1;
int startingY = -1;
for (int i = 0; i < map.VerticalZoneCount; i++)
{
for (int k = 0; k < map.HorizontalZoneCount; k++)
{
if (TestForPriceLabel(map.MapMatrix[i, k], patterns))
{
found = true;
startingX = k;
startingY = i;
break;
}
}
}
if (found)
{
int offsetX = startingX + 4;
if (offsetX >= map.HorizontalZoneCount)
{
offsetX = map.HorizontalZoneCount - 1;
}
for (int cY = startingY; cY < map.VerticalZoneCount; cY++)
{
for (int cX = startingX; cX < offsetX; cX++)
{
var cleanStr = map.MapMatrix[cY, cX].Trim().Replace(" ", "");
if (dateRegex.IsMatch(cleanStr))
{
try {
var value = Convert.ToDateTime(cleanStr);
return(value);
} catch (Exception e) {
Debug.Print(e.StackTrace);
break;
}
}
}
}
}
return(null);
}
public static BitmapImage CreateSizedBitmap(FrameworkElement container, Uri uri, bool backgroundCreation = true)
{
Dictionary <string, string> queryString = UriExtensions.ParseQueryString(uri);
double result1 = 0.0;
double result2 = 0.0;
if (queryString.ContainsKey("wh"))
{
string[] strArray = queryString["wh"].Split((char[])new char[1] {
'_'
});
if (strArray.Length >= 2)
{
double.TryParse(strArray[0], out result1);
double.TryParse(strArray[1], out result2);
}
}
BitmapImage bitmapImage1;
if (backgroundCreation)
{
BitmapImage bitmapImage2 = new BitmapImage();
int num1 = 18;
bitmapImage2.CreateOptions = ((BitmapCreateOptions)num1);
int num2 = 1;
bitmapImage2.DecodePixelType = ((DecodePixelType)num2);
bitmapImage1 = bitmapImage2;
}
else
{
BitmapImage bitmapImage2 = new BitmapImage();
int num1 = 2;
bitmapImage2.CreateOptions = ((BitmapCreateOptions)num1);
int num2 = 1;
bitmapImage2.DecodePixelType = ((DecodePixelType)num2);
bitmapImage1 = bitmapImage2;
}
if (container.Height > 0.0 && container.Width > 0.0)
{
if (result1 == 0.0 || result2 == 0.0)
{
bitmapImage1.DecodePixelHeight = ((int)container.Height);
}
else
{
Rect fill = RectangleUtils.ResizeToFill(new Rect(0.0, 0.0, container.Width, container.Height), new Size(result1, result2));
// ISSUE: explicit reference operation
bitmapImage1.DecodePixelWidth = ((int)((Rect)@fill).Width);
// ISSUE: explicit reference operation
bitmapImage1.DecodePixelHeight = ((int)((Rect)@fill).Height);
}
}
else
{
bitmapImage1.DecodePixelHeight = 300;
}
return(bitmapImage1);
}
public void GetRectanglesThatCloserToPoint_ShouldBeEmpty_WhenPointOnRectangleSide()
{
var point = new Point(2, 0);
var rectangle = new Rectangle(new Point(0, 0), new Size(3, 2));
var result = RectangleUtils.GetRectanglesThatCloserToPoint(point, rectangle, 1);
result.Should().BeEmpty();
}
public void GetRectangleDiagonal_ShouldReturnDiagonal_OnRectangle(
int width, int height, double expectedResult)
{
var rectangle = new Rectangle(new Point(0, 0), new Size(width, height));
var diagonal = RectangleUtils.GetRectangleDiagonal(rectangle);
diagonal.Should().BeApproximately(expectedResult, 1e-5);
}
public List <Vector2> Generate(MyRectangle generationArea, float generationCount,
float exclusionRadius, int maxTries, int maxPerGridCount, IIntensitySamplingProvider intensityProvider)
{
var random = new UnsafeRandomProvider(); //todo!
var offsetGenerationArea = new MyRectangle(0, 0, generationArea.Width, generationArea.Height);
float cellSize = exclusionRadius;
var width = generationArea.Width;
var height = generationArea.Height;
var grid = new CountingGenerationGrid(
cellSize,
new IntVector2(Mathf.CeilToInt(width / cellSize), Mathf.CeilToInt(height / cellSize))
);
var processList = new GenerationRandomQueue <Vector2>();
var acceptedPoints = new List <Vector2>(1000);
var firstPoint = new Vector2(random.Next(0, width), random.Next(0, height));
processList.Add(firstPoint);
acceptedPoints.Add(firstPoint);
grid.Increment(firstPoint);
int tryCount = 0;
while (!processList.Empty)
{
var point = processList.RandomPop();
for (int i = 0; i < generationCount; i++)
{
Vector2 newPoint = GenerateRandomPointAround(point, exclusionRadius, random);
if (offsetGenerationArea.Contains(newPoint))
{
var maxPointsInGrid =
intensityProvider.Sample(
RectangleUtils.CalculateSubelementUv(offsetGenerationArea, newPoint)) *
maxPerGridCount;
if (grid.Retrive(newPoint) < maxPointsInGrid)
{
processList.Add(newPoint);
acceptedPoints.Add(newPoint);
grid.Increment(newPoint);
}
}
tryCount++;
}
if (tryCount > maxTries)
{
break;
}
}
return(acceptedPoints.Select(c => c + generationArea.DownLeftPoint).ToList());
}
public void RectanglesAreIntersected_ShouldReturnFalse_WhenRectanglesAreNotIntersected()
{
var firstRectangle = new Rectangle(new Point(3, 3), new Size(3, 2));
var secondRectangle = new Rectangle(new Point(0, 0), new Size(3, 2));
RectangleUtils
.RectanglesAreIntersected(firstRectangle, secondRectangle)
.Should()
.BeFalse();
}
public void RectanglesAreIntersected_ShouldReturnTrue_WhenTheyPlacedAsACross()
{
var firstRectangle = new Rectangle(new Point(1, 0), new Size(1, 3));
var secondRectangle = new Rectangle(new Point(0, 1), new Size(3, 1));
RectangleUtils
.RectanglesAreIntersected(firstRectangle, secondRectangle)
.Should()
.BeTrue();
}
public void RectanglesAreIntersected_ShouldReturnTrue_WhenOneInsideTheOther()
{
var firstRectangle = new Rectangle(new Point(1, 1), new Size(1, 1));
var secondRectangle = new Rectangle(new Point(0, 0), new Size(3, 3));
RectangleUtils
.RectanglesAreIntersected(firstRectangle, secondRectangle)
.Should()
.BeTrue();
}
public void RectanglesAreIntersected_ShouldReturnTrue_WhenRectanglesAreIntersectedInTheCorner()
{
var firstRectangle = new Rectangle(new Point(1, 1), new Size(3, 2));
var secondRectangle = new Rectangle(new Point(0, 0), new Size(3, 2));
RectangleUtils
.RectanglesAreIntersected(firstRectangle, secondRectangle)
.Should()
.BeTrue();
}
public void GetRectanglesThatCloserToPoint_ShouldNotReturnTheSameRectangle_WhenIntersectsPointCoordinate()
{
var point = new Point(0, 0);
var size = new Size(2, 1);
var rectangle = new Rectangle(new Point(0, 2), size);
var expectedRectangle = new Rectangle(new Point(0, 1), size);
var result = RectangleUtils.GetRectanglesThatCloserToPoint(point, rectangle, 1);
result.Should().OnlyContain(r => r == expectedRectangle);
}
public void Start()
{
var msw = new MyStopWatch();
msw.StartSegment("Loading");
var loader = new HabitatMapOsmLoader();
var fields = loader.Load(@"C:\inz\osm\map.osm");
msw.StartSegment("Translating");
var translator = new HabitatFieldPositionTranslator(GeoCoordsToUnityTranslator.DefaultTranslator);
fields = fields.Select(c => translator.Translate(c)).ToList();
msw.StartSegment("MapCreating");
var map = HabitatMap.Create(
new MyRectangle(62 * 720, 67 * 720, 8 * 720, 8 * 720),
new Vector2(90 * 8, 90 * 8),
fields,
HabitatType.NotSpecified,
HabitatTypePriorityResolver.Default);
GeoCoordsToUnityTranslator translator2 = GeoCoordsToUnityTranslator.DefaultTranslator;
var geoPos1 = new GeoCoordinate(49.600f, 19.543f);
var lifePos1 = translator2.TranslateToUnity(geoPos1);
var geoPos2 = new GeoCoordinate(49.610f, 19.552f);
var lifePos2 = translator2.TranslateToUnity(geoPos2);
MyRectangle territoryUsedToCreateStainTexture =
new MyRectangle(lifePos1.x, lifePos1.y, lifePos2.x - lifePos1.x, lifePos2.y - lifePos1.y);
territoryUsedToCreateStainTexture = RectangleUtils.CalculateSubPosition(territoryUsedToCreateStainTexture,
new MyRectangle(0.65f, 0.65f, 0.1f, 0.1f));
var treeX = map.QueryMap(territoryUsedToCreateStainTexture);
var parentObjectX = new GameObject($"MAGA");
treeX.QueryAll()
.ForEach(c => HabitatMapOsmLoaderDebugObject.CreateDebugHabitatField(c.Field, 0.01f, parentObjectX));
msw.StartSegment("MapQuerying");
for (int x = 0; x < 8; x++)
{
for (int y = 0; y < 8; y++)
{
var tree = map.QueryMap(
new MyRectangle(62 * 720 + x * 720, 67 * 720 + y * 720, 720, 720));
var parentObject = new GameObject($"x:{x} y:{y}");
tree.QueryAll()
.ForEach(c => HabitatMapOsmLoaderDebugObject.CreateDebugHabitatField(c.Field, 0.01f,
parentObject));
}
}
Debug.Log("T64: " + msw.CollectResults());
}
public void GetClosestRectangleThatDoesNotIntersectWithOthers_ShouldReturnClosestPossibleRectangle()
{
var possibleLocation = new Point(-5, 5);
var size = new Size(3, 2);
var center = new Point(0, 0);
var expectedResult = new Rectangle(new Point(-3, 0), size);
var result = RectangleUtils.GetClosestRectangleThatDoesNotIntersectWithOthers(
possibleLocation, size, center, new List <Rectangle>());
result.Should().Be(expectedResult);
}
public void BuildConvexHull_ShouldReturnRectangleCorners_OnOneRectangle()
{
var rectangle = new Rectangle(new Point(1, 1), new Size(3, 1));
var rectangles = new List <Rectangle> {
rectangle
};
var expectedPoints = RectangleUtils.GetRectangleCorners(rectangle);
var result = GeometryUtils.BuildConvexHull(rectangles);
result.Should().BeEquivalentTo(expectedPoints);
}
public static BitmapImage CreateSizedBitmap(FrameworkElement container, Uri uri, bool backgroundCreation = true)
{
Dictionary <string, string> queryString = uri.ParseQueryString();
double result1 = 0.0;
double result2 = 0.0;
if (queryString.ContainsKey("wh"))
{
string[] strArray = queryString["wh"].Split('_');
if (strArray.Length >= 2)
{
double.TryParse(strArray[0], out result1);
double.TryParse(strArray[1], out result2);
}
}
BitmapImage bitmapImage;
if (backgroundCreation)
{
bitmapImage = new BitmapImage()
{
CreateOptions = BitmapCreateOptions.DelayCreation | BitmapCreateOptions.BackgroundCreation,
DecodePixelType = DecodePixelType.Logical
}
}
;
else
{
bitmapImage = new BitmapImage()
{
CreateOptions = BitmapCreateOptions.DelayCreation,
DecodePixelType = DecodePixelType.Logical
}
};
if (container.Height > 0.0 && container.Width > 0.0)
{
if (result1 == 0.0 || result2 == 0.0)
{
bitmapImage.DecodePixelHeight = (int)container.Height;
}
else
{
Rect fill = RectangleUtils.ResizeToFill(new Rect(0.0, 0.0, container.Width, container.Height), new Size(result1, result2));
bitmapImage.DecodePixelWidth = (int)fill.Width;
bitmapImage.DecodePixelHeight = (int)fill.Height;
}
}
else
{
bitmapImage.DecodePixelHeight = 300;
}
return(bitmapImage);
}
private MyRectangle GetAlignedUv(MyRectangle queryArea,
TerrainCardinalResolution resolution)
{
float alignLength = TerrainDescriptionConstants.DetailCellSizesPerResolution[resolution];
var alignedBox = new MyRectangle(
Mathf.FloorToInt(queryArea.X / alignLength) * alignLength,
Mathf.FloorToInt(queryArea.Y / alignLength) * alignLength,
alignLength,
alignLength
);
return(RectangleUtils.CalculateSubelementUv(alignedBox, queryArea));
}
public void GetRectangleSides_ShouldReturnCorrectSegments_OnRectangle()
{
var rectangle = new Rectangle(new Point(0, 0), new Size(4, 3));
var sides = new List <Segment>
{
new Segment(new Point(0, 0), new Point(4, 0)),
new Segment(new Point(0, 0), new Point(0, 3)),
new Segment(new Point(4, 0), new Point(4, 3)),
new Segment(new Point(0, 3), new Point(4, 3)),
};
var result = RectangleUtils.GetRectangleSides(rectangle);
result.Should().BeEquivalentTo(sides);
}
public List <Vector2> Generate(MyRectangle generationArea, int generationCount, float maxTries,
float exclusionRadius, bool collisionsAreChecked, IIntensitySamplingProvider intensitySamplingProvider)
{
var random = new UnsafeRandomProvider(); //todo!
var offsetGenerationArea = new MyRectangle(0, 0, generationArea.Width, generationArea.Height);
float cellSize = exclusionRadius / Mathf.Sqrt(2);
var width = generationArea.Width;
var height = generationArea.Height;
var grid = new SingleElementGenerationGrid(
cellSize,
Mathf.CeilToInt(width / cellSize), Mathf.CeilToInt(height / cellSize),
exclusionRadius
);
var acceptedPoints = new List <Vector2>(generationCount);
int generatedPointsCount = 0;
int triesCount = 0;
while (generatedPointsCount < generationCount && triesCount < maxTries)
{
var randomPoint = new Vector2(random.Next(0, width), random.Next(0, height));
var randomPointValue = random.NextValue;
var intensity =
intensitySamplingProvider.Sample(
RectangleUtils.CalculateSubelementUv(offsetGenerationArea, randomPoint));
if (intensity >= randomPointValue)
{
if (!collisionsAreChecked || !grid.Collides(randomPoint))
{
if (collisionsAreChecked)
{
grid.Set(randomPoint);
}
acceptedPoints.Add(randomPoint);
generatedPointsCount++;
}
}
triesCount++;
}
return(acceptedPoints.Select(c => c + generationArea.DownLeftPoint).ToList());
}
public void GetPossibleRectangles_ShouldReturnRectanglesWithFourDifferentStartPoints_OnPointAndSize()
{
var point = new Point(0, 0);
var size = new Size(2, 1);
var possibleRectangles = new[]
{
new Rectangle(point, size),
new Rectangle(new Point(-2, 0), size),
new Rectangle(new Point(-2, -1), size),
new Rectangle(new Point(0, -1), size),
};
var result = RectangleUtils.GetPossibleRectangles(point, size);
result.Should().BeEquivalentTo(possibleRectangles);
}
public void PutNextRectangle_RectanglesShouldNotIntersect_WhenTwoRectangles()
{
var firstSize = new Size(2, 1);
var secondSize = new Size(3, 4);
var firstRectangle = layouter.PutNextRectangle(firstSize);
var secondRectangle = layouter.PutNextRectangle(secondSize);
rectangles = new List <Rectangle> {
firstRectangle, secondRectangle
};
RectangleUtils.RectanglesAreIntersected(firstRectangle, secondRectangle)
.Should()
.BeFalse();
}
public Task <TerrainDescriptionOutput> Query(TerrainDescriptionQuery query)
{
var outDict = new Dictionary <TerrainDescriptionElementTypeEnum, TerrainDetailElementOutput>();
foreach (var requestedDetail in query.RequestedElementDetails)
{
var requestedType = requestedDetail.Type;
var alignedArea = RetriveAlignedArea(query.QueryArea.DownLeftPoint, requestedDetail.Resolution);
var uv = RectangleUtils.CalculateSubelementUv(alignedArea, query.QueryArea);
if (requestedType == TerrainDescriptionElementTypeEnum.HEIGHT_ARRAY)
{
outDict.Add(requestedType, new TerrainDetailElementOutput()
{
TokenizedElement = new TokenizedTerrainDetailElement()
{
DetailElement = new TerrainDetailElement()
{
DetailArea = alignedArea,
Resolution = requestedDetail.Resolution,
Texture = _heightTexture
},
Token = new TerrainDetailElementToken(alignedArea, requestedDetail.Resolution, requestedType, CornersMergeStatus.NOT_MERGED)
},
UvBase = uv.ToRectangle()
});
}
else
{
outDict.Add(requestedType, new TerrainDetailElementOutput()
{
TokenizedElement = new TokenizedTerrainDetailElement()
{
DetailElement = new TerrainDetailElement()
{
DetailArea = alignedArea,
Resolution = requestedDetail.Resolution,
Texture = _normalTexture
},
Token = new TerrainDetailElementToken(alignedArea, requestedDetail.Resolution, requestedType, CornersMergeStatus.NOT_MERGED)
},
UvBase = uv.ToRectangle()
});
}
}
return(TaskUtils.MyFromResult(new TerrainDescriptionOutput(outDict)));
}
public void GetRectanglesThatCloserToPoint_ShouldReturnCloserRectangles_OnRectangle(
int x, int y, int dx, int dy)
{
var point = new Point(0, 0);
var size = new Size(3, 2);
var rectangle = new Rectangle(new Point(x, y), size);
var expectedRectangles = new[]
{
new Rectangle(new Point(dx, y), size),
new Rectangle(new Point(x, dy), size),
new Rectangle(new Point(dx, dy), size),
};
var result = RectangleUtils.GetRectanglesThatCloserToPoint(point, rectangle, 1);
result.Should().BeEquivalentTo(expectedRectangles);
}
public static void ResizeToFit(this Image image, Size photoSize, Size containerSize)
{
if (photoSize.Width <= 0.0 || photoSize.Height <= 0.0)
{
return;
}
Rect fill = RectangleUtils.ResizeToFill(containerSize, photoSize);
Rect rect = new Rect(-fill.X, -fill.Y, containerSize.Width, containerSize.Height);
image.Width = fill.Width;
image.Height = fill.Height;
image.Margin = new Thickness(fill.X, fill.Y, 0.0, 0.0);
image.Clip = (Geometry) new RectangleGeometry()
{
Rect = rect
};
}
public void GetClosestRectangleThatDoesNotIntersectWithOthers_ShouldBeNull_WhenAllPossibleRectanglesIntersected()
{
var possibleLocation = new Point(0, 1);
var size = new Size(3, 2);
var center = new Point(0, 0);
var rectangles = new List <Rectangle>
{
new Rectangle(new Point(0, -1), new Size(7, 1)),
new Rectangle(new Point(-6, 1), new Size(5, 3)),
new Rectangle(new Point(-4, -2), new Size(3, 2)),
new Rectangle(new Point(1, 1), new Size(3, 1))
};
var result = RectangleUtils.GetClosestRectangleThatDoesNotIntersectWithOthers(
possibleLocation, size, center, rectangles);
result.Should().BeNull();
}
private SegmentInTexturePlacement CalculateSegmentPlacement(IntVector2 newSegmentPositionInGrid)
{
var uvs = RectangleUtils.CalculateSubelementUv(
new MyRectangle(0, 0, _floorSlotsCount.X, _floorSlotsCount.Y),
new MyRectangle(newSegmentPositionInGrid.X, newSegmentPositionInGrid.Y, 1, 1));
var segmentPixels = new IntRectangle(
Mathf.RoundToInt(uvs.X * _floorTextureSize.X),
Mathf.RoundToInt(uvs.Y * _floorTextureSize.Y),
Mathf.RoundToInt(uvs.Width * _floorTextureSize.X),
Mathf.RoundToInt(uvs.Height * _floorTextureSize.Y)
);
return(new SegmentInTexturePlacement()
{
Pixels = segmentPixels,
Uvs = uvs
});
}
