# Question: write a java program within the given template and read...

###### Question details

**Write a java program within the given template and read
the instruction below:**

**Preliminaries:** An ๐-sided polygon ๐ (๐ โฅ 3) is
a cyclic sequence ๐ฃ0, ๐ฃ1, โฏ , ๐ฃ๐โ1 of vertices as we walk around
the polygon boundary. Each vertex ๐ฃ๐ (the ๐th vertex) is a point in
the plane represented by its ๐๐จ๐ฎ๐๐ฅ๐ ๐ฅ and ๐ฆ coordinates. The
line-segment ๐๐ between vertex ๐ฃ๐ and the next vertex ๐ฃ ๐+1 ๐๐๐ ๐
(in cyclic order around the boundary) is called the ๐th edge of ๐,
for ๐ = 0. . ๐ โ 1. You may use the *Point2D.Double* class
in the java.awt.geom package of the Java API to represent polygon
vertices. The polygon is said to be **simple** if no
two non-adjacent pair of edges intersect. That is, two edges ๐๐ and
๐๐ are completely disjoint from each other whenever 1 < ๐ โ ๐
< ๐ โ 1. A simple polygon is said to be **convex**
if the internal angle of every vertex is at most 180ยฐ.
Equivalently, the simple polygon is convex if every turn is
consistently in the same orientation (clockwise or
counter-clockwise) as we walk around the polygon boundary. This
latter condition is computationally more useful (see the
description of the Delta Test on the next page). The main methods
we are interested in is polygon **perimeter** and
**area**. Note that polygon area may not be well
defined if the polygon is non-simple, since the notion of polygon
โinteriorโ may not be well defined in that case. We obviously need
the boolean methods **isSimple** and
**isConvex** as well.

*Useful information:*

**Delta Test:** Suppose we are given an ordered
sequence of three points ๐, ๐, ; each point given by its ๐ฅ and ๐ฆ
coordinates (e.g., ๐ฅ๐ and ๐ฆ๐). We want to know what is the
orientation as we go from ๐ to ๐ to ๐ and back to ๐: is it
clockwise (i.e., right turn), counter-clockwise (i.e., left turn),
or collinear? The answer is given by the determinant of the 3 ร 3
matrix shown below: ๐๐๐๐ก๐ (๐, ๐, ๐) = ๐๐๐ก [๐ฅ๐ ๐ฆ๐ 1 ๐ฅ๐ ๐ฆ๐ 1 ๐ฅ๐ ๐ฆ๐ 1]
This expression can be computed in ๐(1) time with arithmetic
operations on the xy-coordinates of the three given points and is a
very useful quantity with many geometric applications. (It is
analogous to the *compareTo* method on *Comparable*
types.) So, itโs worth providing a static helper method to compute
๐๐๐๐ก๐ (๐, ๐, ๐)

**Triangle Signed Area:** The *signed area*
of the oriented triangle (๐, ๐, ๐) is 1/2 ๐๐๐๐ก๐ (๐, ๐, ๐) , where
the sign is positive, negative, or zero if the orientation is
counter-clockwise, clockwise, or collinear, respectively.

**Line-Segment Disjointness Test:** A line-segment
can be represented by a pair of delimiting points. We want to know
whether a given pair of (closed) line segments (๐, ๐) and (๐, ๐)
are disjoint. The possible cases are depicted in the figure
below.

This test can be done in (1) time (e.g., using the Delta Test).
(How?) You would need repeated use of such a test in the polygon
simplicity checking method. So, itโs worth providing a static
helper method for line-segment disjointness test.
*Note:**You must implement this method
yourself. You are not allowed to use the line intersection method
provided by the Java API. Exercise your logical and analytical
thinking and problem solving skills.*

**Polygon Area:** Consider the simple polygon ๐ฃ0,
๐ฃ1, โฏ , ๐ฃ๐โ1 , where we denote the xy-coordinates of vertex ๐ฃ๐ by
the pair ๐ฅ๐ , ๐ฆ๐ . For notational simplicity, we assume ๐ฃ๐โก ๐ฃ0 and
๐ฃโ1 โก ๐ฃ๐โ1 (i.e., index arithmetic is modulo n). Then the area of
the simple polygon is: 1/2 ๐๐๐๐ก(๐, ๐ฃ๐ , ๐โ1 ๐=0 ๐ฃ๐+1) = 1/2 ๐ฅ๐ ๐ฆ๐+1
โ ๐ฆ๐โ1 ๐โ1 ๐=0 , where ๐ = (0,0) denotes the origin.
(**Note:** itโs absolute value of the sum, not the sum
of absolute values!) This expression can be evaluated in (๐) time
using arithmetic operations.

**Interface Polygon:**

**getSize()** returns n, the number of edges of the
polygon.

**getVertex(i)** returns the ๐th vertex of the
polygon with precondition 0 โค ๐ < ๐.

Throws IndexOutOfBoundsException if the precondition is violated.

**perimeter()** returns the sum of the lengths of
the edges of the polygon.

**area()** returns area of the interior of the
polygon if this notion is well defined;

throws an exception if itโs not.

**Class SimplePolygon (implements Polygon):**

**getNewPoly()** constructs & returns a
polygon, initialized by user provided data in O(n) time.

**toString()** returns a String representation of
the polygon in O(n) time.

**delta(a,b,c)** returns twice the signed area of
oriented triangle (a,b,c) in O(1) time.

**disjointSegments (a,b,c,d)** returns true iff
closed line-segments (๐, ๐) and (๐, ๐) are disjoint.

Runs in (1) time.

**disjointEdges(i, j)** returns true iff edges ๐๐
and ๐๐ of the polygon are disjoint.

Runs in (1) time.

**isSimple()** returns true iff the polygon is
simple. Running time is (๐^2).

**area()** returns area of the interior of the
polygon with precondition that the polygon is

simple. Throws NonSimplePolygonException if the polygon is not simple (since in

that case the polygon โinteriorโ may not be well defined). Runs in (๐) time, not

counting the simplicity test.

**Class ConvexPolygon (extends
SimplePolygon):**

**isConvex()** returns true iff the polygon is
convex, with precondition that the polygon is simple.

This method runs in (๐) time. If the polygon is non-simple, the correctness of the

returned result is not guaranteed.

**Class NonSimplePolygonException (extends
Exception):**

Thrown to indicate that the polygon is non-simple.

**Class PolygonTester:**

This class has a main method that allows the user to input a variety of polygons and thoroughly test all aspects of the above types and methods, and displays or logs informative input-output.

**The template is given in the link below, please see it,
thank you**

Please use the template given in the link: https://mega.nz/#!B08i0Srb!WKE-MaQFYPo_aZIOoA15xufMyuPLz1QOztho0rQ77oc