# a flexible polygon goes through an iteration of side numbers
# finally showing a circle and then repeating the progression

import math

def rotateX(x, y, angle):
  return (x*math.cos(angle)-y*math.sin(angle))

def rotateY(x, y, angle):
  return (y*math.cos(angle)+x*math.sin(angle))

def makePoint(x, y):
  data = []
  data.append(x)
  data.append(y)
  return data
  
def getX(p):
  if len(p) == 2:
    return p[0]
  print "Error: not a point"

def getY(p):
  if len(p) == 2:
    return p[1]
  print "Error: not a point"

def makeString(numPoints, radius):
  cx = 50
  cy = 50
  data = [numPoints]
  for a in range(0, numPoints): 
    data.append(makePoint(cx+radius*math.cos(a*2*math.pi/numPoints), cy+radius*math.sin(a*2*math.pi/numPoints)))
  return data

def getNum(s):
  if len(s) > 0:
    return s[0]
  print "Error: not a string"

def stringPoint(s, i):
  if i >= 0:
    if i < len(s)-1:
      return s[i+1]
  print "stringPoint Error: out of range"
  error

def setStrPoint(s, i, newP):
  if i >= 0:
    if i < len(s)-1:
      s[i+1] = newP  

def drawLine(p1, p2):
  g.line(int(getX(p1)), int(getY(p1)), int(getX(p2)), int(getY(p2)))
  
def drawString(s, numPoints):
  g.pen(100)
  jump = int(getNum(s)/numPoints)
  off = jump/2
  for a in range(0, getNum(s)-1):
    sa = stringPoint(s,a)
    if numPoints <> getNum(s):
      if jump <> 0:
        if int(a-off)%jump == 0:
          g.setPixel(int(getX(sa)-1), int(getY(sa)), 100)
          g.setPixel(int(getX(sa)+1), int(getY(sa)), 100)
          g.setPixel(int(getX(sa)), int(getY(sa)-1), 100)
          g.setPixel(int(getX(sa)), int(getY(sa)+1), 100)
          g.setPixel(int(getX(sa)-2), int(getY(sa)), 100)
          g.setPixel(int(getX(sa)+2), int(getY(sa)), 100)
          g.setPixel(int(getX(sa)), int(getY(sa)-2), 100)
          g.setPixel(int(getX(sa)), int(getY(sa)+2), 100)
          g.setPixel(int(getX(sa)-1), int(getY(sa)-1), 100)
          g.setPixel(int(getX(sa)-1), int(getY(sa)+1), 100)
          g.setPixel(int(getX(sa)-1), int(getY(sa)-2), 100)
          g.setPixel(int(getX(sa)-1), int(getY(sa)+2), 100)
          g.setPixel(int(getX(sa)+1), int(getY(sa)-1), 100)
          g.setPixel(int(getX(sa)+1), int(getY(sa)+1), 100)
          g.setPixel(int(getX(sa)+1), int(getY(sa)-2), 100)
          g.setPixel(int(getX(sa)+1), int(getY(sa)+2), 100)
          g.setPixel(int(getX(sa)-2), int(getY(sa)-1), 100)
          g.setPixel(int(getX(sa)-2), int(getY(sa)+1), 100)
          g.setPixel(int(getX(sa)-2), int(getY(sa)-2), 100)
          g.setPixel(int(getX(sa)-2), int(getY(sa)+2), 100)
          g.setPixel(int(getX(sa)+2), int(getY(sa)-1), 100)
          g.setPixel(int(getX(sa)+2), int(getY(sa)+1), 100)
          g.setPixel(int(getX(sa)+2), int(getY(sa)-2), 100)
          g.setPixel(int(getX(sa)+2), int(getY(sa)+2), 100)
    drawLine(sa, stringPoint(s,a+1))
  drawLine(stringPoint(s,0), stringPoint(s,getNum(s)-1))

def sqr(x):
  return x*x

def pullStringPoint(s, i, focusPoint, strength):
  p = stringPoint(s, i)
  length = math.sqrt(sqr(getX(p)-getX(focusPoint))+sqr(getY(p)-getY(focusPoint)))
  attract = sqr(length)*strength/100
  if attract > 50:
    attract = 50
  normal = makePoint(0,0)
  if length <> 0:
    normal = makePoint((getX(focusPoint)-getX(p))/length, (getY(focusPoint)-getY(p))/length)
  setStrPoint(s, i, makePoint(getX(p)+attract*getX(normal),getY(p)+attract*getY(normal)))

theAngle = 0

def stretchString(s, numSides, radius, strength):
  jump = int(getNum(s)/numSides)
  off = jump/2
  for a in range(0, numSides):
    i = off+a*jump
    focusPoint = makePoint(50+radius*math.cos(a*2*math.pi/numSides+theAngle),50+ radius*math.sin(a*2*math.pi/numSides+theAngle))
    pullStringPoint(s, i, focusPoint, strength/getNum(s))

def conformString(s, strength):
  for a in range(0, getNum(s)):
    pullStringPoint(s, a, stringPoint(s, (a+getNum(s)+1)%getNum(s)), strength/getNum(s))
    pullStringPoint(s, a, stringPoint(s, (a+getNum(s)-1)%getNum(s)), strength/getNum(s))

str = makeString(25, 40)
while 1:
  curPolySides = 0
  time = 0
  intensity = 0
  polySidesList = []
  polySidesList.append(25)
  polySidesList.append(3)
  polySidesList.append(3)
  polySidesList.append(4)
  polySidesList.append(5)
  polySidesList.append(6)
  polySidesList.append(8)
  while curPolySides < len(polySidesList):
    theAngle = theAngle - math.pi/1000
    if theAngle < 0:
      theAngle = theAngle + 2*math.pi
    g.norefresh()
    g.paper(0)
    drawString(str, polySidesList[curPolySides])
    g.refresh()
    stretchString(str, polySidesList[curPolySides], 50, 50.0*intensity/35)
    conformString(str, 50.0*intensity/35)
    time = time + 1
    if intensity < 40:
      intensity = intensity + 4
    if time%35 == 0:
      curPolySides = curPolySides + 1
      if curPolySides < len(polySidesList):
        if polySidesList[curPolySides] <> polySidesList[curPolySides-1]:
          intensity = 0
      if curPolySides >= len(polySidesList):
        intensity = 0