Calculating area of polygons

Question

Download shapes.py from the website and extend it with class Circle, class Polygon, and method area. Classes Circle and Polygon should inherit from Shape. For circles, at creation the radius has to be specified and the str method should return a string in the same style as for Line and Rectangle: For rectangles, at creation the list of vertices has to be follow the example below precisely. Add method area to classes Line, Rectangle, Circle. The area of a line is zero and the areas of rectangles and circles should be computed in the usual way. For this, import pi from math. The area of a non-self-intersecting polygon with vertices is defined as

where each with represents a vertex (“corner”) of a polygon, and and . Note that the area of a convex polygon is positive if the points are in counterclockwise order and negative if they are in clockwise order. (The Wikipedia page takes the absolute value to avoid negative areas. Don’t do this here.)

Here are some test cases:

   g = Group()
    l = Line(1, 2, 5, 6); g.add(l); print(l)
 Line from (1, 2) to (5, 6)
    r = Rectangle(-2, -3, 2, 3); g.add(r); print(r)
 Rectangle at (-2, -3), width 2, height 3
    c = Circle(1, -5, 1); g.add(c); print(c)
 Circle at (1, -5), radius 1
    p = Polygon([(0, 0), (4, 0), (2, 2), (4, 4), (0, 4), (2, 2)]); g.add(p);     print(p)
 Polygon with [(0, 0), (4, 0), (2, 2), (4, 4), (0, 4), (2, 2)]
    print(g); g.move(1, 1); print(g)
 Group with:
  Circle at (1, -5), radius 1
  Rectangle at (-2, -3), width 2, height 3
  Line from (1, 2) to (5, 6)
  Polygon with [(0, 0), (4, 0), (2, 2), (4, 4), (0, 4), (2, 2)]
 Group with:
  Circle at (2, -4), radius 1
  Rectangle at (-1, -2), width 2, height 3
  Line from (2, 3) to (6, 7)
  Polygon with [(1, 1), (5, 1), (3, 3), (5, 5), (1, 5), (3, 3)]
    l.area(), r.area(), c.area(), p.area(), g.area()
  (0, 6, 3.141592653589793, 8.0, 17.141592653589793)

I'm very new at Python and don't know how to approach this whatsoever. Any help would be appreciated! Thanks!

Answer 1

I haven't finished the code. But created a structure for you to learn and start filling in.

Shape is a base class and Line, Circle, Rectangle and Polygon are children classes (inheritance). [Assuming you have idea of OOP]

class Group(object):
    """docstring for Group"""

    def __init__(self):
        super(Group, self).__init__()
        self.shapes = list()

    def add(self, shape):
        self.shapes.append(shape)

    def move(self, dx, dy):
        for shape in self.shapes:
            print "Moving %s by (%d, %d)" % (shape, dx, dy)
            shape.move(dx, dy)

    def __str__(self):
        return "Group with: " + ", ".join((str(shape) for shape in self.shapes))


class Shape(object):
    """docstring for Shape"""

    def __init__(self):
        super(Shape, self).__init__()

    def print_details(self):
        pass

    def area(self):
        pass


class Line(Shape):
    """docstring for Line"""

    def __init__(self, x1, y1, x2, y2):
        super(Line, self).__init__()
        self.x1 = x1
        self.y1 = y1
        self.x2 = x2
        self.y2 = y2

    def area(self):
        return 0

    def __str__(self):
        return "Line from (%s, %s) to (%s, %s)" % (self.x1, self.y1, self.x2, self.y2)


class Rectangle(Shape):
    """docstring for Line"""

    def __init__(self, x1, y1, x2, y2):
        super(Rectangle, self).__init__()
        self.x1 = x1
        self.y1 = y1
        self.x2 = x2
        self.y2 = y2

    def area(self):
        return self._width * self._height

    def __str__(self):
        return "Rectangle at (%s, %s), width %s, height %s" % (
          self.x1, self.y1, self._width(), self._height())

    def _width(self):
        return abs(self.x1 - self.x2)

    def _height(self):
        return abs(self.y1 - self.y2)

class Circle(Shape):
  """docstring for Circle"""
  def __init__(self, x, y, radius):
    super(Circle, self).__init__()
    self.x = x
    self.y = y
    self.radius = radius

  def area(self):
    pass

  def __str__(self):
    return "Circle ....."

class Polygon(Shape):
    """docstring for Line"""

    def __init__(self, vertices):
        super(Polygon, self).__init__()
        if type(vertices) is list and len(vertices) > 0 and type(vertices[0]) is tuple:
            self.vertices = vertices
        else:
            raise Exception("Invalid syntax")

    def area(self):
        area = 0
        for index in range(len(self.vertices) - 1):
            v1 = self.vertices[index]
            v2 = self.vertices[index + 1]
            area += ((v1[0] * v2[1]) - (v2[0] * v1[1]))
        area = 0.5 * area
        return area

    def __str__(self):
        return "Polygon with %s" % str(self.vertices)

g = Group()

l = Line(1, 2, 5, 6)
g.add(l)
print(l) #Line from (1, 2) to (5, 6) 

r = Rectangle(-2, -3, 2, 3)
g.add(r)
print(r) #Rectangle at (-2, -3), width 2, height 3

c = Circle(1, -5, 1)
g.add(c)
print(c) #Circle at (1, -5), radius 1

p = Polygon([(0, 0), (4, 0), (2, 2), (4, 4), (0, 4), (2, 2)])
g.add(p)
print(p) #Polygon with [(0, 0), (4, 0), (2, 2), (4, 4), (0, 4), (2, 2)] 

print(g)
g.move(1, 1)
print(g) #Group with: Circle at (1, -5), radius 1 Rectangle at (-2, -3), width 2, height 3 Line from (1, 2) to (5, 6) Polygon with [(0, 0), (4, 0), (2, 2), (4, 4), (0, 4), (2, 2)] Group with: Circle at (2, -4), radius 1 Rectangle at (-1, -2), width 2, height 3 Line from (2, 3) to (6, 7) Polygon with [(1, 1), (5, 1), (3, 3), (5, 5), (1, 5), (3, 3)] l.area(), r.area(), c.area(), p.area(), g.area() (0, 6, 3.141592653589793, 8.0, 17.141592653589793)

Feel free to ask more questions if you have doubts

Answer 2

This is the shoelace formula (http://en.wikipedia.org/wiki/Shoelace_formula) and i found a possible implementation in python on http://www.cgafaq.info/wiki/Polygon_Area. This site seems to be down, but i found out that the shapely module named the same source (https://toblerity.org/shapely/shapely.algorithms.html)

So, if you want the formula impelmented in python, this seems to me a reliable one:

def signed_area(coords):
    """Return the signed area enclosed by a ring using the linear time
algorithm at http://www.cgafaq.info/wiki/Polygon_Area. A value >= 0
indicates a counter-clockwise oriented ring.
return 0, if the ring is not closed
"""
    xs, ys = map(list, zip(*coords))
    xs.append(xs[1])
    ys.append(ys[1])
    return sum(xs[i]*(ys[i+1]-ys[i-1]) for i in range(1, len(coords)))/2.0

As the doc string tells, on a closed ring, where first coordinate pair equals the last, signed_area returns the area of that. The return value is Zero, if the ring is not closed. If result is negativ, the orientation of the polygon is clockwise, if it is positive, the polygon is counter-clockwise.

If your polygon consists of multiple rings, you add the signed area of each ring, because outer rings and inner rings have a different directions which results in opposite signs.