Represent polygons using ordered arrays of points. Each point is itself an array of doubles, where the
Question:
Represent polygons using ordered arrays of points. Each point is itself an array of
doubles, where the doubles represent the coordinates of the point. A point may have varying
numbers of coordinates, depending on how many dimensions the polygon is in. For example, a
2D polygon has points with 2 coordinates (x, y), a 3D polygon has points with 3 coordinates (x, y,
z) and an n-dimensional polygon has points with n coordinates (x0, x1, x2, ... , xn).
Below is a triangle, which we can consider 2-dimensional polygon consisting of 3 points.
For this 2D polygon, we have 3 points, {A, B, C} = { {2, 1}, {7, 1}, {7, 4} }.
The bounding box for this polygon can be represented as { {2, 1}, {7, 4} }.
The total length of the lines connecting the points, which we will refer to as the length of the
polygon, is ~13.8 units.
Make the following changes to the file Asso1.java and Polygon.java which are given below:
a. (1 Mark) we need to Complete the constructor and setter for the Polygon class. These methods should
both accept an array of points and save it to the corresponding field on the Polygon class.
b. (3 Marks) Write the code for the calculateDistance() method. This method will accept two
points as input, with each point being represented by a 1-dimensional array of doubles. You
can calculate the distance between two points using Euclidean Distance.
c. (3 Marks) Complete the calculateLength() method. This method will determine the total
length of the polygon if we were to connect each point to the next point in order. Note that
our polygon is considered to be closed. This means that the last point should connect back
to the first point.
d. (3 Marks) Write the calculateBoundingBox() method. This method should return an array of
points that can be used to represent the maximum extents of the polygon. A bounding box
for a shape can be determined using only two points. The first point will represent the
minimum coordinates for the polygon in each dimension, while the second point represents
the maximums.
e. (3 Marks) Write the code for the append() method. The append method of a Polygon should
accept another Polygon as input. The method will then combine the Polygons together by
adding all of the points from the input polygon to the array of the second polygon.
f. (3 Marks) Complete the checkDimensions() method. This method will accept an array of
points as input. The method will then check that there is at least one point in the array, and
that all of the points in the array exist in the same number of dimensions. (Eg: one array of
points should not have points that are 2D as well as points that are 3D) Return true if the
array passes the check.
g. (2 Marks) Finally, we are going to add some validation to our class. If a validation ever fails,
an IllegalArgumentException should be thrown. Here are our validation rules:
a. Anywhere that the points field on the Polygon class may be changed, we must check
that all of the points in the array have the same number of dimensions.
b. If we are to append two polygons together, we must ensure the two polygons are in
the same number of dimensions.
c. To calculate the distance between two points, the points must have the same
number of dimensions.
Asso1.java :
import java.util.Arrays;
/**
* This is a driver class for Assignment 01
* It will instantiate and run some operations on Polygon objects
*/
public class Ass01
{
public static void main(String[] args){
// A 2 dimensional square
System.out.println("Square:");
double[][] sqPoints = {{0.0, 1.0}, {1.0, 1.0}, {1.0, 0.0}, {0.0, 0.0}};
Polygon square = new Polygon(sqPoints);
System.out.println("\tPoints: " + square);
System.out.println("\tLength: " + square.calculateLength());
System.out.println("\tBounding Box: " + Arrays.deepToString(square.calculateBoundingBox()));
// A 2 dimensional triangle
System.out.println("Triangle:");
double[][] trPoints = {{-1.0, 0.0}, {-2.0, 0.0}, {-1.0, 1.0}};
Polygon triangle = new Polygon(trPoints);
System.out.println("\tPoints: " + triangle);
System.out.println("\tLength: " + triangle.calculateLength());
System.out.println("\tBounding Box: " + Arrays.deepToString(triangle.calculateBoundingBox()));
// Combine the square and triangle into 1 2D poly
System.out.println("Square append Triangle:");
square.append(triangle);
System.out.println("\tPoints: " + square);
System.out.println("\tLength: " + square.calculateLength());
System.out.println("\tBounding Box: " + Arrays.deepToString(square.calculateBoundingBox()));
// A polygon in 3 dimensions
System.out.println("3D Poly:");
double[][] poly3Points = {{0.0, 1.0, 1.0}, {1.0, 1.0, 2.0}, {1.0, 0.0, 2.0}, {0.0, 0.0, 1.0}};
Polygon poly3D = new Polygon(poly3Points);
System.out.println("\tPoints: " + poly3D);
System.out.println("\tLength: " + poly3D.calculateLength());
System.out.println("\tBounding Box: " + Arrays.deepToString(poly3D.calculateBoundingBox()));
// A polygon in n-dimensions (n=5)
System.out.println("n-Dimensional Poly:");
double[][] polyNPoints = {{-6.5, 1.0, 1.0, 10.2, 5.0}, {-3.0, 1.0, 2.0, 10.0, 5.2}, {1.0, 0.0, 2.0, 8.8, 4.4}, {0.0, 0.0, 1.0, 8.0, 4.0}};
Polygon polyN = new Polygon(polyNPoints);
System.out.println("\tPoints: " + polyN);
System.out.println("\tLength: " + polyN.calculateLength());
System.out.println("\tBounding Box: " + Arrays.deepToString(polyN.calculateBoundingBox()));
// A polygon where the points don't have a consistent dimension
System.out.println("Broken Dimension Poly:");
double[][] brokenPoints = {{-6.5, 1.0, 1.}, {-3.0}, {1.0, 0.0}};
try{
Polygon polyBroken = new Polygon(brokenPoints);
System.out.println("\tPoints: " + polyN);
System.out.println("\tLength: " + polyN.calculateLength());
System.out.println("\tBounding Box: " + Arrays.deepToString(polyN.calculateBoundingBox()));
}catch(IllegalArgumentException e){
System.out.println("\tInvalid polygon");
}
// Try to merge a 2d poly with a 3d poly
System.out.println("Append different dimensions:");
try{
triangle.append(poly3D);
System.out.println("\tPoints: " + triangle);
System.out.println("\tLength: " + triangle.calculateLength());
System.out.println("\tBounding Box: " + Arrays.deepToString(triangle.calculateBoundingBox()));
}catch(IllegalArgumentException e){
System.out.println("\tInvalid polygon");
}
}
}
Polygon.java :
import java.util.Arrays;
public class Polygon
{
private double[][] points;
public Polygon(double[][] points){
// Your code goes here
}
private boolean checkDimensions(double[][] points){
/* This method will check that all of the points in an array have the same dimensions (length) */
// Your code goes here
}
public void append(Polygon p){
/* The points of a second polygon to this polygon */
// Your code goes here
}
public double[][] getPoints(){return this.points;}
public void setPoints(double[][] points){
// Your code goes here
}
public double calculateLength(){
/* Calculate the total length of all the polygon's sides */
// Your code goes here
}
public static double calculateDistance(double[] p1, double[] p2){
/* Calculate the euclidean distance between two given points */
// Your code goes here
}
public double[][] calculateBoundingBox(){
/* to create a bounding box which contains the minimum values for each dimension, and the maximum values */
// Your code goes here
}
public String toString(){
return Arrays.deepToString(this.points);
}
}
Expert Answer:
