void AddTunnel()
{
bool addedTunnel = false;
int attemptCount = 0; // to prevent infinite loops
// Keep trying to add a tunnel
do
{
Opening randomOpeningPossibility = openingPossibilities[Random.Range(0, openingPossibilities.Count)];
int tunnelLength = Random.Range(minimumTunnelLength, maximumTunnelLength);
Size tunnelSize;
Vector tunnelRectPositionDelta;
RectangleArea tunnelArea;
switch (randomOpeningPossibility.direction)
{
case Direction.North:
tunnelSize = new Size(5, tunnelLength);
tunnelRectPositionDelta = new Vector(-2, +1);
tunnelArea = new RectangleArea(randomOpeningPossibility.position + tunnelRectPositionDelta, tunnelSize);
break;
case Direction.East:
tunnelSize = new Size(tunnelLength, 5);
tunnelRectPositionDelta = new Vector(+1, -2);
tunnelArea = new RectangleArea(randomOpeningPossibility.position + tunnelRectPositionDelta, tunnelSize);
break;
case Direction.South:
tunnelSize = new Size(5, tunnelLength);
tunnelRectPositionDelta = new Vector(-2, -(tunnelSize.height));
tunnelArea = new RectangleArea(randomOpeningPossibility.position + tunnelRectPositionDelta, tunnelSize);
break;
case Direction.West:
tunnelSize = new Size(tunnelLength, 5);
tunnelRectPositionDelta = new Vector(-(tunnelSize.width), -2);
tunnelArea = new RectangleArea(randomOpeningPossibility.position + tunnelRectPositionDelta, tunnelSize);
break;
default:
Debug.LogError("Tunnel's can't be made in diagonal directions");
tunnelSize = new Size(0, 0);
tunnelRectPositionDelta = new Vector(0, 0);
tunnelArea = new RectangleArea(new Position(-20, -29), new Size(-20, -20));
break;
}
if (RectangleAreaIsEmpty(tunnelArea))
{
tunnels.Add(new Tunnel(randomOpeningPossibility.position + randomOpeningPossibility.direction.ToVector(), tunnelLength, randomOpeningPossibility.direction));
usedOpenings.Add(randomOpeningPossibility);
addedTunnel = true;
}
attemptCount++;
} while(!addedTunnel && attemptCount < 5);
}
public static void Main()
{
RectangleArea calculator = new RectangleArea();
Console.WriteLine("What is the length of the room in feet?");
string lengthEntry = Console.ReadLine();
double length;
while (!double.TryParse(lengthEntry, out length) || length <= 0)
{
Console.WriteLine("Must be greater than 0. Enter length: ");
lengthEntry = Console.ReadLine();
}
Console.WriteLine("What is the width of the room in feet? ");
string widthEntry = Console.ReadLine();
double width;
while (!double.TryParse(widthEntry, out width) || width <= 0)
{
Console.WriteLine("Must be greater than 0. Enter width: ");
widthEntry = Console.ReadLine();
}
Console.WriteLine("You entered dimensions of " + length + " feet by " + width + " feet.");
Console.WriteLine("The area is \n" + calculator.areaInFeet(length, width) + " square feet \n" + calculator.areaInMeters(length, width) + " square meters");
}
public RectangleArea GetDimensionArea(RegionVO region)
{
RectangleArea result = new RectangleArea(short.MaxValue, short.MaxValue, short.MinValue, short.MinValue);
for (int i = 0; i < region.Pixels.Length; i++)
{
int pixelIndex = region.Pixels[i];
var(x, y) = Get_XY(pixelIndex);
if (result.X > x)
{
result.X = x;
}
if (result.X2 < x)
{
result.X2 = x;
}
if (result.Y > y)
{
result.Y = y;
}
if (result.Y2 < y)
{
result.Y2 = y;
}
}
return(result);
}
public APISuccessResponse AddRectangle([FromBody] RectangleArea rectangle)
{
try
{
if (rectangle.Coordinate1.Longitude == rectangle.Coordinate2.Longitude ||
rectangle.Coordinate1.Latitude == rectangle.Coordinate2.Latitude)
{
HttpContext.Response.StatusCode = BadRequest().StatusCode;
return(new APISuccessResponse("The selected shape is not a rectangle"));
}
bool isSuccess = _GPSService.AddRectangle(rectangle);
if (isSuccess)
{
HttpContext.Response.StatusCode = Ok().StatusCode;
return(new APISuccessResponse());
}
else
{
return(new APISuccessResponse("Error in adding rectangle to database"));
}
}
catch (Exception ex)
{
_logger.LogWarning("An error occurs, Exception: {Exception Message}", ex.Message);
HttpContext.Response.StatusCode = 500;
return(new APISuccessResponse("Internal Server Error"));
}
}
public static Shape ToShape(RectangleArea rectangle)
{
var shape = new Shape()
{
TypeId = rectangle.TypeId,
Name = rectangle.Name
};
return(shape);
}
public static Rectangle ToRectangle(RectangleArea rectangleArea)
{
var rectangle = new Rectangle();
rectangle.Longitude1 = rectangleArea.Coordinate1.Longitude;
rectangle.Latitude1 = rectangleArea.Coordinate1.Latitude;
rectangle.Longitude2 = rectangleArea.Coordinate2.Longitude;
rectangle.Latitude2 = rectangleArea.Coordinate2.Latitude;
return(rectangle);
}
/*
* Metodo di controllo attività di ridimensionamento bounding box
*/
private ResizeInfo CheckIfResize(Point coordinateDetected, RectangleArea rectangleArea)
{
rectangleArea.CalculateVertexCoordinate();
rectangleArea.CalculateOneRadiousCoordinate(coordinateDetected, canvasBitMap);
ResizeInfo resizeDetected = MovimentMethods.CheckIfResize(rectangleArea.PixelCoordinateDetected, rectangleArea.OneRadiousPixelCoordinate,
rectangleArea.LeftTopPixelCoordinate, rectangleArea.LeftBottomPixelCoordinate,
rectangleArea.RightTopPixelCoordinate, rectangleArea.RightBottomPixelCoordinate);
return(resizeDetected);
}
private Vector2[] GetPoints(RectangleArea rectangleArea)
{
Vector2[] points = new Vector2[0];
if (rectangleArea.isRectangular())
{
Rect rect = GetRect(rectangleArea.getRectangle());
points = rect.ToPoints();
}
else
{
points = rectangleArea.getPoints().ToArray();
}
return(points);
}
public bool AddRectangle(RectangleArea rectangleArea)
{
var rectangle = ObjectMapper.ToRectangle(rectangleArea);
var shape = ObjectMapper.ToShape(rectangleArea);
var shapeResult = _repository.InsertShape(shape);
rectangle.ShapeId = shapeResult.Id;
var circleResult = _repository.InsertRectangle(rectangle);
if (shapeResult == null || rectangle == null)
{
return(false);
}
return(true);
}
private void Crop_MouseDown(object sender, MouseEventArgs e)
{
Area area = IsAreaIntersect();
if (e.Button == MouseButtons.Left)
{
if (area != null)
{
IsMoving = true;
positionOnClick = e.Location;
CurrentArea = area;
SelectArea();
}
else if (!IsMouseDown)
{
IsMouseDown = true;
DeselectArea();
RectangleArea newArea = new RectangleArea();
Areas.Add(newArea);
positionOnClick = e.Location;
newArea.Rectangle = new Rectangle(positionOnClick, new Size(25, 25));
CurrentArea = newArea;
}
}
else if (e.Button == MouseButtons.Right)
{
if (area != null)
{
Areas.Remove(area);
DeselectArea();
}
else if (CurrentArea != null && CurrentArea.Selected)
{
DeselectArea();
}
else
{
Crop.Close(false);
}
}
}
void drawArea()
{
IArea area = gs.area;
switch (area.type)
{
case GameArea.AreaType.circle:
CircleArea cr = area as CircleArea;
rectMat.SetFloat("_HalfWidth", cr.R);
rectMat.SetFloat("_Ang", 360f);
rectMesh.get(2 * area.R, 2 * area.R, new Vector3(0, 0.02f, 0));
rectMesh.draw(sticker.localToWorldMatrix * mLocalMX, rectMat);
break;
case GameArea.AreaType.Fan:
FanArea fr = area as FanArea;
rectMat.SetFloat("_HalfWidth", fr.R);
rectMat.SetFloat("_Ang", fr.ang);
rectMesh.get(2 * area.R, 2 * area.R, new Vector3(0, 0.02f, 0));
rectMesh.draw(sticker.localToWorldMatrix * mLocalMX, rectMat);
break;
case GameArea.AreaType.Rectangle:
RectangleArea rar = area as RectangleArea;
rectMat.SetFloat("_HalfWidth", rar.w / 2);
rectMat.SetFloat("_HalfHeight", rar.R / 2);
rectMat.SetFloat("_Ang", 0);
rectMesh.get(area.R, area.R, new Vector3(0, 0.02f, rar.R / 2));
rectMesh.draw(sticker.localToWorldMatrix * mLocalMX, rectMat);
break;
case GameArea.AreaType.Square:
SquareArea sr = area as SquareArea;
rectMat.SetFloat("_HalfWidth", sr.R / 2);
rectMat.SetFloat("_HalfHeight", sr.R / 2);
rectMat.SetFloat("_Ang", 0);
rectMesh.get(area.R, area.R, new Vector3(0, 0.02f, sr.R / 2));
rectMesh.draw(sticker.localToWorldMatrix * mLocalMX, rectMat);
break;
}
}
bool RectangleAreaIsEmpty(RectangleArea rectangleArea)
{
for (int x = 0; x < rectangleArea.size.width; x++)
{
for (int y = 0; y < rectangleArea.size.height; y++)
{
// If position is out of bounds, then the area isn't Empty
if (!PositionIsInLevel(new Position(rectangleArea.position.x + x, rectangleArea.position.y + y)))
{
return(false);
}
// If one tile is not void, then the area isn't empty
if (!(tiles[rectangleArea.position.x + x, rectangleArea.position.y + y] == "void"))
{
return(false);
}
}
}
return(true);
}
/*
* Conferma inserimento ID e creazione rettangolo
*/
private void OnButtonConfirmIDRectangleClicked(object sender, EventArgs e)
{
if (rectangleIDText.Text != null && !DupplicatedIDValue(rectangleIDText.Text))
{
gridLayout.Children.Remove(rectangleInsertIDLayout);
RectangleArea rectangleArea = new RectangleArea(rectangleIDText.Text);
rectangleArea.Top = bitMapArea.Top;
rectangleArea.Left = bitMapArea.Left;
rectangleArea.Right = rectangleArea.Left + rectangleArea.OffSetRectWidth;
rectangleArea.Bottom = rectangleArea.Top + rectangleArea.OffSetRectHeight;
allRectangleArea.Add(rectangleArea);
Scale = actualScale;
canvasBitMap.InvalidateSurface();
}
else
{
DisplayAlert("ID non valido", "Inserire un ID valido", "OK");
}
}
private void Crop_MouseDown(object sender, MouseEventArgs e)
{
Area area = IsAreaIntersect();
if (e.Button == MouseButtons.Left)
{
if (area != null)
{
IsMoving = true;
positionOnClick = e.Location;
CurrentArea = area;
SelectArea();
}
else if (!IsMouseDown)
{
IsMouseDown = true;
DeselectArea();
RectangleArea newArea = new RectangleArea();
Areas.Add(newArea);
positionOnClick = e.Location;
newArea.Rectangle = new Rectangle(positionOnClick, new Size(25, 25));
CurrentArea = newArea;
}
}
else if (e.Button == MouseButtons.Right)
{
if (area != null)
{
Areas.Remove(area);
DeselectArea();
}
else if (CurrentArea != null && CurrentArea.Selected)
{
DeselectArea();
}
else
{
Crop.Close(false);
}
}
}
void AddRoom()
{
bool addedRoom = false;
int attemptCount = 0; // to prevent infinite loops
do
{
List <Opening> tunnelOpeningPossibilities = GetOpeningsConnectedTo(openingPossibilities, "tunnel");
Opening randomOpeningPossibility = tunnelOpeningPossibilities[Random.Range(0, tunnelOpeningPossibilities.Count)];
Position openingPosition = randomOpeningPossibility.position;
Direction openingDirection = randomOpeningPossibility.direction;
Size roomSize = new Size(Random.Range(minimumRoomSize.width, maximumRoomSize.width), Random.Range(minimumRoomSize.height, maximumRoomSize.height));
Position roomPosition;
RectangleArea roomArea;
switch (randomOpeningPossibility.direction)
{
case Direction.North:
roomPosition = new Position(openingPosition.x - (roomSize.width / 2), openingPosition.y + 2);
// with margin
roomArea = new RectangleArea(new Position(roomPosition.x - 1, roomPosition.y + 1),
new Size(roomSize.width + 2, roomSize.height + 2));
break;
case Direction.East:
roomPosition = new Position(openingPosition.x + 2, openingPosition.y - (roomSize.height / 2));
// with margin
roomArea = new RectangleArea(new Position(roomPosition.x, roomPosition.y - 1),
new Size(roomSize.width + 2, roomSize.height + 2));
break;
case Direction.South:
roomPosition = new Position(openingPosition.x - (roomSize.width / 2), openingPosition.y - 1 - roomSize.height);
// with margin
roomArea = new RectangleArea(new Position(roomPosition.x - 1, roomPosition.y - 2),
new Size(roomSize.width + 2, roomSize.height + 2));
break;
case Direction.West:
roomPosition = new Position(openingPosition.x - 1 - roomSize.width, openingPosition.y - (roomSize.height / 2));
// with margin
roomArea = new RectangleArea(new Position(roomPosition.x - 2, roomPosition.y - 1),
new Size(roomSize.width + 2, roomSize.height + 2));
break;
default:
Debug.LogError("Openings's can't be made in diagonal directions");
roomPosition = new Position(-1, -1);
roomArea = new RectangleArea(new Position(-20, -29), new Size(-20, -20));
break;
}
if (RectangleAreaIsEmpty(roomArea))
{
rooms.Add(new Room(roomPosition, roomSize));
usedOpenings.Add(randomOpeningPossibility);
usedOpenings.Add(new Opening(openingPosition + openingDirection.ToVector(), openingDirection.Inverted(), randomOpeningPossibility.connectedTo));
addedRoom = true;
}
attemptCount++;
} while(!addedRoom && attemptCount < 5);
}
public override string ToString()
{
return(base.ToString() + $"\n- Width: {Width}m\n- Height: {Height}m\n- Area: {RectangleArea.ToString("0.00")}m^2," +
$"\n- Circumference: {RectangleCircumference.ToString("0.00")}m\n");
}
/*
* Metodo resize bounding box con chiamata al vertice in questione
*/
private void ResizeRect(SKPoint coordinatePixelDetected, ResizeInfo resizeDetected, RectangleArea rectangleArea)
{
MovimentInfo resizeMovimentDetected = MovimentMethods.GetResizeInfo(coordinatePixelDetected.X, coordinatePixelDetected.Y,
bitMapArea.Left, bitMapArea.Top, bitMapArea.Right, bitMapArea.Bottom);
switch (resizeDetected)
{
case ResizeInfo.LeftTopAround:
LeftTopResizeCase(coordinatePixelDetected, resizeMovimentDetected, rectangleArea);
break;
case ResizeInfo.LeftBottomAround:
LeftBottomResizeCase(coordinatePixelDetected, resizeMovimentDetected, rectangleArea);
break;
case ResizeInfo.RightTopAround:
RightTopResizeCase(coordinatePixelDetected, resizeMovimentDetected, rectangleArea);
break;
case ResizeInfo.RightBottomAround:
RightBottomResizeCase(coordinatePixelDetected, resizeMovimentDetected, rectangleArea);
break;
}
rectangleArea.OffSetRectHeight = rectangleArea.Bottom - rectangleArea.Top;
rectangleArea.OffSetRectWidth = rectangleArea.Right - rectangleArea.Left;
rectangleArea.ResizeMove = true;
canvasBitMap.InvalidateSurface();
}
/*
* Metodo per la gestione del movimento del rettangolo mediante la gesture "pan" con contemplazione dei
* vari casi presenti e conseguente ricalcolo delle varie coordinate
*/
private void RectangleMoveArea(Point pointMove, RectangleArea rectangleArea)
{
SKPoint pixelMove = UtilityFunctions.ConvertToPixel(pointMove, canvasBitMap);
MovimentInfo actualMoviment = MovimentMethods.GetMovimentInfo(pixelMove.X, pixelMove.Y,
bitMapArea.Left, bitMapArea.Top, bitMapArea.Right,
bitMapArea.Bottom, rectangleArea.OffSetRectWidth, rectangleArea.OffSetRectHeight);
switch (actualMoviment)
{
case MovimentInfo.InsideArea:
rectangleArea.Bottom = pixelMove.Y + rectangleArea.OffSetRectHeight / 2;
rectangleArea.Top = rectangleArea.Bottom - rectangleArea.OffSetRectHeight;
rectangleArea.Right = pixelMove.X + rectangleArea.OffSetRectWidth / 2;
rectangleArea.Left = rectangleArea.Right - rectangleArea.OffSetRectWidth;
break;
case MovimentInfo.OutSideRightOverTop:
rectangleArea.Bottom = bitMapArea.Top + rectangleArea.OffSetRectHeight;
rectangleArea.Top = bitMapArea.Top;
rectangleArea.Right = bitMapArea.Right;
rectangleArea.Left = rectangleArea.Right - rectangleArea.OffSetRectWidth;
break;
case MovimentInfo.OutSideRight:
rectangleArea.Bottom = pixelMove.Y + rectangleArea.OffSetRectHeight / 2;
rectangleArea.Top = rectangleArea.Bottom - rectangleArea.OffSetRectHeight;
rectangleArea.Right = bitMapArea.Right;
rectangleArea.Left = rectangleArea.Right - rectangleArea.OffSetRectWidth;
break;
case MovimentInfo.OutSideLeftOverTop:
rectangleArea.Bottom = bitMapArea.Top + rectangleArea.OffSetRectHeight;
rectangleArea.Top = bitMapArea.Top;
rectangleArea.Left = bitMapArea.Left;
rectangleArea.Right = bitMapArea.Left + rectangleArea.OffSetRectWidth;
break;
case MovimentInfo.OverTop:
rectangleArea.Bottom = bitMapArea.Top + rectangleArea.OffSetRectHeight;
rectangleArea.Top = bitMapArea.Top;
rectangleArea.Right = pixelMove.X + rectangleArea.OffSetRectWidth / 2;
rectangleArea.Left = rectangleArea.Right - rectangleArea.OffSetRectWidth;
break;
case MovimentInfo.OutSideLeftUnderBottom:
rectangleArea.Bottom = bitMapArea.Bottom;
rectangleArea.Top = rectangleArea.Bottom - rectangleArea.OffSetRectHeight;
rectangleArea.Left = bitMapArea.Left;
rectangleArea.Right = bitMapArea.Left + rectangleArea.OffSetRectWidth;
break;
case MovimentInfo.UnderBottom:
rectangleArea.Bottom = bitMapArea.Bottom;
rectangleArea.Top = rectangleArea.Bottom - rectangleArea.OffSetRectHeight;
rectangleArea.Right = pixelMove.X + rectangleArea.OffSetRectWidth / 2;
rectangleArea.Left = rectangleArea.Right - rectangleArea.OffSetRectWidth;
break;
case MovimentInfo.OutSideLeft:
rectangleArea.Bottom = pixelMove.Y + rectangleArea.OffSetRectHeight / 2;
rectangleArea.Top = rectangleArea.Bottom - rectangleArea.OffSetRectHeight;
rectangleArea.Left = bitMapArea.Left;
rectangleArea.Right = bitMapArea.Left + rectangleArea.OffSetRectWidth;
break;
case MovimentInfo.OutSideRightUnderBottom:
rectangleArea.Bottom = bitMapArea.Bottom;
rectangleArea.Top = bitMapArea.Bottom - rectangleArea.OffSetRectHeight;
rectangleArea.Right = bitMapArea.Right;
rectangleArea.Left = bitMapArea.Right - rectangleArea.OffSetRectWidth;
break;
}
canvasBitMap.InvalidateSurface();
}
/*
* Resize a destra in basso
*/
private void RightBottomResizeCase(SKPoint coordinatePixelDetected, MovimentInfo resizeMovimentDetected, RectangleArea rectangleArea)
{
switch (resizeMovimentDetected)
{
case MovimentInfo.OutSideRight:
rectangleArea.Right = bitMapArea.Right;
rectangleArea.Bottom = coordinatePixelDetected.Y;
break;
case MovimentInfo.UnderBottom:
rectangleArea.Bottom = bitMapArea.Bottom;
rectangleArea.Right = coordinatePixelDetected.X;
break;
case MovimentInfo.OutSideRightOverTop:
rectangleArea.Right = bitMapArea.Right;
rectangleArea.Bottom = bitMapArea.Bottom;
break;
case MovimentInfo.InsideArea:
rectangleArea.Right = coordinatePixelDetected.X;
rectangleArea.Bottom = coordinatePixelDetected.Y;
break;
}
}
/*
* Resize a sinistra in alto
*/
private void LeftTopResizeCase(SKPoint coordinatePixelDetected, MovimentInfo resizeMovimentDetected, RectangleArea rectangleArea)
{
switch (resizeMovimentDetected)
{
case MovimentInfo.OutSideLeft:
rectangleArea.Left = bitMapArea.Left;
rectangleArea.Top = coordinatePixelDetected.Y;
break;
case MovimentInfo.OverTop:
rectangleArea.Top = bitMapArea.Top;
rectangleArea.Left = coordinatePixelDetected.X;
break;
case MovimentInfo.OutSideLeftOverTop:
rectangleArea.Top = bitMapArea.Top;
rectangleArea.Left = bitMapArea.Left;
break;
case MovimentInfo.InsideArea:
rectangleArea.Left = coordinatePixelDetected.X;
rectangleArea.Top = coordinatePixelDetected.Y;
break;
}
}
