untested cleanup

generators/apollon/apollon.py

@@ -0,0 +1,195 @@
+#!/usr/bin/python3
+
+# Generate Apollonian Gaskets -- the math part.
+
+# Copyright (c) 2014 Ludger Sandig
+# This file is part of apollon.
+
+# Apollon is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Apollon is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Apollon.  If not, see <http://www.gnu.org/licenses/>.
+
+from cmath import *
+import random
+
+class Circle(object):
+    """
+    A circle represented by center point as complex number and radius.
+    """
+    def __init__ ( self, mx, my, r ):
+        """
+        @param mx: x center coordinate
+        @type mx: int or float
+        @param my: y center coordinate
+        @type my: int or float
+        @param r: radius
+        @type r: int or float
+        """
+        self.r = r
+        self.m = (mx +my*1j)
+
+    def __repr__ ( self ):
+        """
+        Pretty printing
+        """
+        return "Circle( self, %s, %s, %s )" % (self.m.real, self.m.imag, self.r)
+
+    def __str__ ( self ):
+        """
+        Pretty printing
+        """
+        return "Circle x:%.3f y:%.3f r:%.3f [cur:%.3f]" % (self.m.real, self.m.imag, self.r.real, self.curvature().real)
+
+    def curvature (self):
+        """
+        Get circle's curvature.
+        @rtype: float
+        @return: Curvature of the circle.
+        """
+        return 1/self.r
+
+def outerTangentCircle( circle1, circle2, circle3 ):
+    """
+    Takes three externally tangent circles and calculates the fourth one enclosing them.
+    @param circle1: first circle
+    @param circle2: second circle
+    @param circle3: third circle
+    @type circle1: L{Circle}
+    @type circle2: L{Circle}
+    @type circle3: L{Circle}
+    @return: The enclosing circle
+    @rtype: L{Circle}
+    """
+    cur1 = circle1.curvature()
+    cur2 = circle2.curvature()
+    cur3 = circle3.curvature()
+    m1 = circle1.m
+    m2 = circle2.m
+    m3 = circle3.m
+    cur4 = -2 * sqrt( cur1*cur2 + cur2*cur3 + cur1 * cur3 ) + cur1 + cur2 + cur3
+    m4 = ( -2 * sqrt( cur1*m1*cur2*m2 + cur2*m2*cur3*m3 + cur1*m1*cur3*m3 ) + cur1*m1 + cur2*m2 + cur3*m3 ) /  cur4
+    circle4 = Circle( m4.real, m4.imag, 1/cur4 )
+    
+    return circle4
+    
+
+def tangentCirclesFromRadii( r2, r3, r4 ):
+    """
+    Takes three radii and calculates the corresponding externally
+    tangent circles as well as a fourth one enclosing them. The enclosing
+    circle is the first one.
+
+    @param r2, r3, r4: Radii of the circles to calculate
+    @type r2: int or float
+    @type r3: int or float
+    @type r4: int or float
+    @return: The four circles, where the first one is the enclosing one.
+    @rtype: (L{Circle}, L{Circle}, L{Circle}, L{Circle})
+    """
+    circle2 = Circle( 0, 0, r2 )
+    circle3 = Circle( r2 + r3, 0, r3 )
+    m4x = (r2*r2 + r2*r4 + r2*r3 - r3*r4) / (r2 + r3)
+    m4y = sqrt( (r2 + r4) * (r2 + r4) - m4x*m4x )
+    circle4 = Circle( m4x, m4y, r4 )
+    circle1 = outerTangentCircle( circle2, circle3, circle4 )
+    return ( circle1, circle2, circle3, circle4 )
+
+def secondSolution( fixed, c1, c2, c3 ):
+    """
+    If given four tangent circles, calculate the other one that is tangent
+    to the last three.
+    
+    @param fixed: The fixed circle touches the other three, but not
+    the one to be calculated.
+    
+    @param c1, c2, c3: Three circles to which the other tangent circle
+    is to be calculated.
+
+    @type fixed: L{Circle}
+    @type c1: L{Circle}
+    @type c2: L{Circle}
+    @type c3: L{Circle}
+    @return: The circle.
+    @rtype: L{Circle}
+    """
+    
+    curf = fixed.curvature()
+    cur1 = c1.curvature()
+    cur2 = c2.curvature()
+    cur3 = c3.curvature()
+
+    curn = 2 * (cur1 + cur2 + cur3) - curf
+    mn = (2 * (cur1*c1.m + cur2*c2.m + cur3*c3.m) - curf*fixed.m ) / curn
+    return Circle( mn.real, mn.imag, 1/curn )
+
+class ApollonianGasket(object):
+    """
+    Container for an Apollonian Gasket.
+    """
+    def __init__(self, c1, c2, c3):
+        """
+        Creates a basic apollonian Gasket with four circles.  
+
+        @param c1, c2, c3: The curvatures of the three inner circles of the
+        starting set (i.e. depth 0 of the recursion). The fourth,
+        enclosing circle will be calculated from them.
+        @type c1: int or float
+        @type c2: int or float
+        @type c3: int or float
+        """
+        self.start = tangentCirclesFromRadii( 1/c1, 1/c2, 1/c3 )
+        self.genCircles = list(self.start)
+
+    def recurse(self, circles, depth, maxDepth):
+        """Recursively calculate the smaller circles of the AG up to the
+        given depth. Note that for depth n we get 2*3^{n+1} circles.
+
+        @param maxDepth: Maximal depth of the recursion.
+        @type maxDepth: int
+
+        @param circles: 4-Tuple of circles for which the second
+        solutions are calculated
+        @type circles: (L{Circle}, L{Circle}, L{Circle}, L{Circle})
+
+        @param depth: Current depth
+        @type depth: int
+        """
+        if( depth == maxDepth ):
+            return
+        (c1, c2, c3, c4) = circles
+        if( depth == 0 ):
+            # First recursive step, this is the only time we need to
+            # calculate 4 new circles.
+            del self.genCircles[4:]
+            cspecial = secondSolution( c1, c2, c3, c4 )
+            self.genCircles.append( cspecial )
+            self.recurse( (cspecial, c2, c3, c4), 1, maxDepth )
+
+        cn2 = secondSolution( c2, c1, c3, c4 )
+        self.genCircles.append( cn2 )
+        cn3 = secondSolution( c3, c1, c2, c4 )
+        self.genCircles.append( cn3 )
+        cn4 = secondSolution( c4, c1, c2, c3 )
+        self.genCircles.append( cn4 )               
+
+        self.recurse( (cn2, c1, c3, c4), depth+1, maxDepth )
+        self.recurse( (cn3, c1, c2, c4), depth+1, maxDepth )
+        self.recurse( (cn4, c1, c2, c3), depth+1, maxDepth )
+
+    def generate(self, depth):
+        """
+        Wrapper for the recurse function. Generate the AG,
+        @param depth: Recursion depth of the Gasket
+        @type depth: int
+        """
+        self.recurse(self.start, 0, depth)
+