Pythagoras Tree

While casually browsing the net I came across this implementation of Pythagoras tree in F#. Just for fun, I have recreated this in Scala.

The Pythagoras Tree is a fractal constructed by geometric methods. It is rather easy to program since no substitution is involved. You can just pile on the newly created squares onto the existing ones, since they don't overlap immediately.

Eye candy

Here is the output of my Scala script:

Depth=10, No Skew

Depth=14, Skew = 0.8

The source code

« Click here to see the Scala script »

import java.lang.Math.{hypot, atan, cos, sin, pow}                                                            
 
// Attempt to make an abstract (generic) tree
abstract class Tree[+T] {                    
  def forEach (f :(T,Int) => Unit):Unit = forEach (f, 0)
  def forEach (f :(T,Int) => Unit, level:Int):Unit = {} 
}                                                       
 
case class TreeNode[+T] (value:T, left:Tree[T], right:Tree[T]) extends Tree[T] {
  override def forEach (f : (T,Int) => Unit, level:Int) = {                     
    f(value, level)                                                             
    left.forEach(f, level+1)                                                    
    right.forEach(f, level+1)                                                   
  }                                                                             
}                                                                               
case object EmptyTree extends Tree[Nothing]                                     
 
////////////////
case class Point (x:Double, y:Double)
case class Square (topLeft:Point, topRight:Point, bottomLeft:Point, bottomRight:Point, angle:Double)
 
val base = Square(Point(0,0), Point(100,0), Point(0,100), Point(100,100), 0)
val skew = 1                                                                
 
// math constants
val halfPi = java.lang.Math.PI / 2
val quarterPi = java.lang.Math.PI / 4
val sqrt2 = java.lang.Math.pow(2, 0.5)
 
def makeTree (base:Square, goFor:Int):Tree[Square] = {
  if (goFor > 0) {                                    
    val sideLength = hypot (base.topLeft.x - base.topRight.x, base.topLeft.y - base.topRight.y)
    val newSideLength = (sideLength / sqrt2) * skew                                            
    val otherSideLength = pow(pow(sideLength,2) - pow(newSideLength,2), 0.5)                   
 
    val angle = base.angle + atan(otherSideLength/newSideLength)
    val otherAngle = angle - halfPi                             
 
    val midPointX = base.topLeft.x + newSideLength * cos(angle)
    val midPointY = base.topLeft.y - newSideLength * sin(angle)
    val midPoint = Point(midPointX, midPointY)                 
 
    TreeNode(base, makeSubTree(newSideLength, base.topLeft, midPoint, angle, goFor),
                   makeSubTree(otherSideLength, midPoint, base.topRight, otherAngle, goFor))
 
  } else {
    EmptyTree
  }          
}            
 
def makeSubTree (length:Double, start:Point, end:Point, angle:Double, goFor:Int):Tree[Square] = {
  val newSquare = Square (
                    Point(start.x - length*sin(angle), start.y - length * cos(angle)),
                    Point(end.x - length*sin(angle), end.y - length * cos(angle)),
                    start, end, angle)
  makeTree(newSquare, goFor-1)
}
 
val maxLevel = 10
val newRoot = makeTree(base, maxLevel)
 
// Output to SVG
var count = 0
def showLine(start:Point, end:Point,color:String) = {
  println("""<line id="%d" style="stroke:rgb(%s);stroke-width:1;fill:none;" x1="%f" y1="%f" x2="%f" y2="%f" />""".format
      (count, color, start.x+300, start.y+300, end.x+300, end.y+300))
  count += 1
}
 
println("""<svg x="0" y="0" width="800" height="600">""")
newRoot forEach {(square,level) =>
  val color =
    if (level == maxLevel - 1) "255,0,255"
    else "0,0,128"
 
  showLine(square.topLeft, square.topRight, color)
  showLine(square.topLeft, square.bottomLeft, color)
  showLine(square.bottomRight, square.topRight, color)
  showLine(square.bottomLeft, square.bottomRight, color)
}
println("</svg>")

Conclusion

This script is a bit more configurable than the F# one linked above, and hence is a bit more lengthy. I was quite happy with the script and the end result.

---

RSS feed