mightyscape-1.2/extensions/fablabchemnitz/apollonian_gasket/apollon.py

#!/usr/bin/env 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)