From dfd1841e2f78ad1e7388d07eb34388b92f2791ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Christian=20Gr=C3=BCnhage?= Date: Tue, 10 Feb 2015 17:51:44 +0100 Subject: [PATCH] PythagorasTree impementation, not working New pythagoras Tree implementation, not fully working yet --- .idea/uiDesigner.xml | 124 ++++++++ .idea/workspace.xml | 289 ++++++++++++------ out/production/Fractals/DrawingTools.class | Bin 0 -> 605 bytes out/production/Fractals/Main.class | Bin 0 -> 7449 bytes out/production/Fractals/Numbers.class | Bin 0 -> 1219 bytes ...PythagorasTree$PythagorasTreeVariant.class | Bin 0 -> 1616 bytes out/production/Fractals/PythagorasTree.class | Bin 0 -> 2566 bytes .../Fractals/PythagorasTreeQueue.class | Bin 0 -> 1070 bytes .../Fractals/PythagorasTriangle$1.class | Bin 0 -> 1315 bytes .../Fractals/PythagorasTriangle.class | Bin 0 -> 1980 bytes .../Fractals/PythagorasTriangleList.class | Bin 0 -> 1639 bytes src/DrawingTools.java | 12 + src/Main.java | 202 ++++++++++++ src/Numbers.java | 27 ++ src/PythagorasTree.java | 82 +++++ src/PythagorasTreeQueue.java | 16 + src/PythagorasTriangle.java | 79 +++++ src/PythagorasTriangleList.java | 31 ++ src/TurtleState.java | 16 + 19 files changed, 781 insertions(+), 97 deletions(-) create mode 100644 .idea/uiDesigner.xml create mode 100644 out/production/Fractals/DrawingTools.class create mode 100644 out/production/Fractals/Main.class create mode 100644 out/production/Fractals/Numbers.class create mode 100644 out/production/Fractals/PythagorasTree$PythagorasTreeVariant.class create mode 100644 out/production/Fractals/PythagorasTree.class create mode 100644 out/production/Fractals/PythagorasTreeQueue.class create mode 100644 out/production/Fractals/PythagorasTriangle$1.class create mode 100644 out/production/Fractals/PythagorasTriangle.class create mode 100644 out/production/Fractals/PythagorasTriangleList.class create mode 100644 src/DrawingTools.java create mode 100644 src/Main.java create mode 100644 src/Numbers.java create mode 100644 src/PythagorasTree.java create mode 100644 src/PythagorasTreeQueue.java create mode 100644 src/PythagorasTriangle.java create mode 100644 src/PythagorasTriangleList.java create mode 100644 src/TurtleState.java diff --git a/.idea/uiDesigner.xml b/.idea/uiDesigner.xml new file mode 100644 index 0000000..e96534f --- /dev/null +++ b/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/workspace.xml b/.idea/workspace.xml index 75f0af4..a5801a7 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -40,18 +40,54 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - + + + + + @@ -59,14 +95,13 @@ - - + + - @@ -75,24 +110,18 @@ - - - - - - - - - - - - - - - + + + + + + + + + @@ -105,11 +134,13 @@ @@ -118,10 +149,10 @@ true - @@ -196,13 +227,16 @@ + + + - + @@ -441,7 +475,32 @@ - + + + + + + @@ -453,72 +512,45 @@ 1423576956527 - - + - + - + + - - + + - - + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + - + + + + + + + - + + + + - - - - - - - - @@ -557,16 +587,47 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + - @@ -576,24 +637,58 @@ - - - + + + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + - - + + diff --git a/out/production/Fractals/DrawingTools.class b/out/production/Fractals/DrawingTools.class new file mode 100644 index 0000000000000000000000000000000000000000..86b057e1ea29eccc58488acb49fbc38188992f04 GIT binary patch literal 605 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 hVdexSGhdv<9wB)^^pds0<>$Oj!}6{{bzh_ZI*F literal 0 HcmV?d00001 diff --git a/out/production/Fractals/PythagorasTree$PythagorasTreeVariant.class b/out/production/Fractals/PythagorasTree$PythagorasTreeVariant.class new file mode 100644 index 0000000000000000000000000000000000000000..9e59bd925fd2dffed9eb7302bdf158020bc5950c GIT binary patch literal 1616 zcma)6ZBNrs6n^ej)~*y7<8^@YHedq*Q9xvfLj*+zBNRy%Kb28ON!KOahVrj;Bw{cc zKKmp5DaLc}7Fls7Y{_}@oR@oE?z#Q>`|1aPdF%xtA)#Ug&t$}8JXg_&Bo}K6`c*Qn zagP@Y205-P7~=R+!7#@S1tT0c6^wFxr69`jwSqB@TMEWGzLBxb(5;{6&5~tLZzJ1gq3kj=Hd$wsOD#J^(>Aju z^O!-79fd{LVqrdf}Lox1}t{+%4yiO!vSzvPmP0)6(x5 zmSd??S#)8bR;@Giv+ zAB2Vp{$^qtQrMBP%W!KWZ_(O0HHoUIXY275OGX`VT#xYA^)irurKgk!~cmG z!vm55VcRDEY0T98=iw7tH7rejMbkAT?(g&X&yq%~df_4FgqCqBRN9B1mgM zkTyX=vLNk(gcU(L1nCS_{kjC}t~vGy)*GsNMnb{wl-XaQw~&!4Xx1}L6}0G?Km~1j zMy{Y;&nOji=$R0yx(G0O3n8cKhx5E^;B%EoX-Vy4uNL>-? zs!;FB#Wh*p6Kn5_=5@I+wgij0CbNQ_7mQN(9dyGvLk^n1~KDmupNIlhf?xg{oDxM&*s*Eg@Oe1{W=> zE}=npS-x{cN+@b-v817G(lxVlXUy`lJ2}T(Y<{yBf=M}P8sugKVEY;h|*S*ki&YoZ`wcQ(E;A_fiYMZv%>3>tU^F#|)0 z8yLoJ1A8!HAb}AbHx10eHZYH(j*@{gZW(Z3>!=uTQDxN|O&d6Zg9a8*G%$uY4J_ie zfjgphR}6h1R8mCt;#C9NvBSWJ_{hM=ahp>^QJ&M8+bv#g@atoFs$m+M}emQ~!c zA@Y`+Vf!AF_G7hT=^^$`Q1$%33Z<~bK6I@4(gLNs_+oSXghNZYRQ7z@P_f+eR?&mc zP^=j{>wDZr$1cj`S@ukZ3_E6-J;_F2K^$9!sr0O`DaPo~6*iI=;#v(OMNk)t`KeOL zX0L?>;YA2M{PBg2X zfL1#(%{>53(8qNjPd~y>o4{cF3AFg|5`6L9OYq0{EFlo@4J;uTkA{{IibwS&=#Q11 z*SKz1TAj4kg;qq-j&5|K2Yu+pR<66y&o2>h3c6Uw0p+Vu;;p85;;&Cp;;~;*;&VVz z;&n(-;K_zg?ZY_%xq)+wyT^RVHJ;a0-fdny2klaX8fOX1bxMrzvdMBhPC>R)skGs>oKq7 z@*!TwA!g(VKeul%zdmY3FiOgg!|G+NU0r)=!|w>Igx`-pL)&G>;Pc{8Sz8+uX)mu& z(7lA7VKRDZ=$-x_&Az!N&3@7BSDIdNo?>7XM*XV9`x)Q?hLGgAJ;=d&2=^FC zcO~TeUdXL7Uh81Mp9F(|%spcRt4?3XZ7&CsH zbsZC6Xg?PK literal 0 HcmV?d00001 diff --git a/out/production/Fractals/PythagorasTreeQueue.class b/out/production/Fractals/PythagorasTreeQueue.class new file mode 100644 index 0000000000000000000000000000000000000000..c8fcd6ca4b32ad644ae8cc36a14a32f37ff9cdaf GIT binary patch literal 1070 zcmZ`&Yi|-!5Iq-=1zh_COY6JV3iPqQs);m>Nl6nD;;W=a{d5aAuyt9Q1@_5;8pJjo%8I~JC6NZ@V`8I+7D8?$1>iiK4R zYXa#_*LU@ng>`|#%VXV@oqiw(%|NL=8MxBd0(RZ^Rj}>J!9WcJ-j^Ejz@@l3%B#kr zh}7{^!yV{qqt$ifp%*$j478`5W^`0*^?G?vAhq3ZD}l*|>#OHsZ(jvXx$n_4)9AOP z7lG3rIa9jpvZX?-mQt@m6{@O$b@X?J<*|r!dKSoPGc|i9Y%!K}W(4v!Y+hjQoN+kG z!2Qg=MNMF$*Y7D`%iy@C4t1B#I%)06Pi{|oBUeh3bAhQ?O=YIY?z$acvLLTZjRSck zolv`;LyA7Aw&8ShJZXz*x!rykwA7Ak*ek|&6cMy;plsyeu*3Mh@lM#dhx;}j;GxYo zwPE8iHUwtlkr9$W{(o%=jL|%1{(E7`l39IHw%gq0Xhe@&a9->msFtpl-;wb^_4-E~ zC0{BJNjMw9_t6gI$9QiXd;F~qUxukR&1&&*+~Oa}@&f_fkYRvwlGa!1#_v>4Au8XI zc)PN?R!kMr1?v>a6Qtf$PH^ET5>GSp8LH_>T3?uwz!c>I(v&%*a1rycv4~435q_QU z)4X}j!i2{RW_cPdj{=Ju?K0+wVzeT2laaQ7E5tIstGE_nJGf5GijZ&MCh?LS$JAfM S?dV)$P1A#54++@M=KlcL!x6~< literal 0 HcmV?d00001 diff --git a/out/production/Fractals/PythagorasTriangle$1.class b/out/production/Fractals/PythagorasTriangle$1.class new file mode 100644 index 0000000000000000000000000000000000000000..7878c41b62f39a0804e9201805f2f776c7df89b2 GIT binary patch literal 1315 zcma)6ZBNrs6n^eD)@^oBC$RCNqD)|@OjPg%LGHtO@KiCs)h3{G9NtGO(Ta9ee|C}N5mSMEC&yRTC z;&wH^;gsuot!N6%D7dcUE-)m^KG)w+UyU4kDuzVask^!;nzC@ZwOwkhYKa+HkeVpi zy5)GLU0oM`%`p_rD7dHMJ|3v(gQn8a&8e8jBZlFNdrh19i6aQO5aa_Z+xz!j4nve8~cR|UKZBeaT+}-B3;T&{s znBFoyZaeMnO}p{ByR1}>9fqN9Ih7iXFhi!>T9Kycq9yZ)vU=P1*T(1z>!mM_X&E^` z(n1WEks`iALLf{Q@bNp?>CePhgucit{0))F<|jm6He{4!Pg5!+qfHqjsWfGrWUMI@ zB(;|4OH#Llt5W}s|4gmL(T_BGkij@6h$m_G=ZNRAf)~UEY@tkC!E5Nm1`gp7`*?@< z#9_(@qK$`2Vu0*zs+u7lq`IJbXV!dR6#}agSVmy^f%PGvLOcur literal 0 HcmV?d00001 diff --git a/out/production/Fractals/PythagorasTriangle.class b/out/production/Fractals/PythagorasTriangle.class new file mode 100644 index 0000000000000000000000000000000000000000..dafa0ae1e985d9fdcb8dc1350cb38bb4f3264765 GIT binary patch literal 1980 zcma)7OK%%h6#lMbdtztOq`_@mlopyM!Ew{1r2z^_Q0gw2#-?ewLP^bab}Y7 zq^OmUkl1yLL@Ob&VS$8@sv;7q3b8{%?ARjl2iPL9K|H=Yk2G<-z|y(*Jnuc{eCLjT z{^#)z0LI}Yk-=O7!?={hDO`@{@*mLvB=8)rBykn<@!XQHN@4+v@m#^PBc2=g8Kr(B z=JSY#OfqDSgiIu4w2+B~%rhaA2${p`{-q?|#9L~4TZ!+e<(h_fHC)&5o`7DkEW??u z%SOX!2<)pHH{AvEj**vT*LDQNj6gyu&s){HA<*TR)!HtPq^AkY+AZmr(sDK25IAt< zwp)``+mVe$$1s+BlfY1Mw_#wn82C*H#3xP5bf*MnGygB7P`tFUS~8r*L~&W(l4Esg zRmW!RjZ)p17+w;HPTLh#MA5Vi-*ZvYCeTx~%d+m>OgT_S-I~dsq;}oS>evV-w{O*6 zH7r*;w`Ytsx5ic#1T@RPpH16NMIh$Is9W}ACD6Ix%JRybT=Q=Apt+$zYA6ZpuNrQ# z36ZwUFfq{sOVIZoiu29LbcV{nDY;;8IAtSms)~DeHr+33RAr}gqRToeFm&8RRmTa8 zFc%#)Twq!{Of2hIL0!j~vaIT`VCz^@%W;h87{v%n-Fv)1_mlE3mzIsP%jWL&8#tw5 zU7%?yn#Ap4(gMVHo$f;}z+Mscv4MpTOt)NPkDE?u61NYHTvJ%uPQ|oj-8+VIN5vbY zC0XBK|GHIkjp{~SI`h)1*sGkbOhG}@$w?~b&5~`&a@q9N7dbCail38eUJ|Z7FDq<4 zXDphTQK4-O)1v3jo)`v>^37)Wafl(JI!rF2Q1Ny)+uMnSx1Ypm?lB0$_yX4#0r3}Q zeiXz|_B)7g5IMeuw$ZQX#^3KGL24(RB)vkqPFg43C4E8qp7cvLh3F>YU*hqh=oYkn z_di3I$EDDI?{h>SWAF(rUQeONOd%!jdWPlDaFB-7 z4#U;Zkf!139fmWZp-)8w#~cflN2u(k_p^Z^8D!3_J^L-<)lKwg74rzk9${b;gG%ZT zrJ;wcwhb?FEg{Xd15tEh68kZY9^`S5{psb?Nb@E1;SLVtLn8DE`td1-@HMe|K$LzY z9zU_8zw#g9HzM%|k@yoY<8Mrg1kQ?HOo>69!x`Q%?xRDi>OOH|+-Zdhxe4AJ@wl^? zVqQvj4msv@o~}os|4WCMhF3LA3k@?GX8Ff+03A=I)9F+?&SUbp;12>HY{UaQ#)1bQ zFh1hdshq&`R4%&j5ac58TFc;gbMS1-;6lsbq2}O1%ixPGgZrC<=UN0u@VZxA5n1j% REOVGUy4wlH`*=Qg=s$frlL-I- literal 0 HcmV?d00001 diff --git a/out/production/Fractals/PythagorasTriangleList.class b/out/production/Fractals/PythagorasTriangleList.class new file mode 100644 index 0000000000000000000000000000000000000000..65a16f3f04fee03525ca105c719fcaa21099f059 GIT binary patch literal 1639 zcma)6TTc^F5dKbYOP7TLTIC{M0b5Y;f_Nz++5%R~wML_FOM57bWoz24L7z?h3qJVn zqcKr1ni!vrzrdg3gZiCq!BP-RlQ}bIX1@8(%xu5?`t$|BFw#2Oa7n|64i7E`(Td9& zuITVrjH?>1>4;%eM+2^_m@y@8D05tin@ZeLBCa8!VL~A26fM)vjvPw>jL1`;zn@+hX1emAF3^;A%*^9y^NGvD9SIv^43DHQq0&6wItJzXdlGjh^Wpk1}i`}@K{wEzY>a9iNuZp&cc01k4h z)lnKajCR)BiKZcG;12F8u#|ym%ov!(oPo2LH*ijg^GaO6JQr_gzUsF?i_0O;b`8xg zuE>m|VL_m7@^$9c0(m296KWt5g|fQ?9AdsKXP3Bpkwmnz&u)!M0QYm^KbI}JwbMIM zRB^AF&8jLj-pV^-(MR-hOv;Tt^JCX|PW5j<^nZru;Rd`P;G^oN8u$RsI}!*7UPfNMMo<5H_&%fI;XpV* zRcrTsL~sN8IvO9m2#7bof4n1<7sn`%y0AKYJVPwfiAMCoz&OuIG~+m9hDoLyQIbB1 z0PQK9LJv=+^`egym3A5tl2=-knh*Wd!|?oOs$au^hBIC-BY)BM~L7Vdz%<5QfN!Un5s>Z@}hy!0 0) newPythagorasTree(args[0]); + else newPythagorasTree(null); + } + } + + public static Turtle newTurtle() { + Playground playground = new Playground(); + playground.setAntiAliasing(true); + playground.setAutoscrolls(true); + playground.setPreferredSize(new Dimension(2160, 1440)); + playground.setMinimumSize(new Dimension(2160, 1440)); + playground.add(new Turtle(Color.GREEN)); + Turtle turtle = playground.getTurtle(0); + turtle.setFillColor(Color.BLACK).fill(); + turtle.setPenColor(Color.GREEN); + turtle.hideTurtle(); + + turtle.penUp(); + turtle.right(180); + turtle.forward(350); + turtle.left(90); + turtle.forward(50); + turtle.left(90); + turtle.penDown(); + return turtle; + } + + public static void newPythagorasTree(String input) { + PythagorasTree.PythagorasTreeVariant variant; + + Scanner scanner = new Scanner(System.in); + + if (input != null) variant = variantFromString(input); + else variant = variantInput(scanner); + + double size = squareSizeInput(scanner); + int loopSize = loopSizeInput(scanner); + int depth = depthInput(scanner); + double angle = 45; + + if (variant == PythagorasTree.PythagorasTreeVariant.AsymetricPythagorasTree) angle = angleInput(scanner); + + for (int i = 0; i < loopSize; i++) { + new PythagorasTreeQueue(variant, new PythagorasTriangleList(variant, depth, angle), newTurtle(), size, 0, depth); + } + } + + public static PythagorasTree.PythagorasTreeVariant variantFromString(String input) { + PythagorasTree.PythagorasTreeVariant variant; + + if (input.equalsIgnoreCase("SymetricPythagorasTree")) { + variant = PythagorasTree.PythagorasTreeVariant.SymetricPythagorasTree; + } else if (input.equalsIgnoreCase("AsymetricPythagorasTree")) { + variant = PythagorasTree.PythagorasTreeVariant.AsymetricPythagorasTree; + } else if (input.equalsIgnoreCase("RegularRandomPythagorasTree")) { + variant = PythagorasTree.PythagorasTreeVariant.RegularRandomPythagorasTree; + } else if (input.equalsIgnoreCase("PisanoPythagorasTreeOne")) { + variant = PythagorasTree.PythagorasTreeVariant.PisanoPythagorasTreeOne; + } else if (input.equalsIgnoreCase("PisanoPythagorasTreeTwo")) { + variant = PythagorasTree.PythagorasTreeVariant.PisanoPythagorasTreeTwo; + } else if (input.equalsIgnoreCase("PisanoPythagorasTreeThree")) { + variant = PythagorasTree.PythagorasTreeVariant.PisanoPythagorasTreeThree; + } else if (input.equalsIgnoreCase("PisanoPythagorasTreeFour")) { + variant = PythagorasTree.PythagorasTreeVariant.PisanoPythagorasTreeFour; + } else if (input.equalsIgnoreCase("PisanoPythagorasTreeFive")) { + variant = PythagorasTree.PythagorasTreeVariant.PisanoPythagorasTreeFive; + } else variant = PythagorasTree.PythagorasTreeVariant.unselected; + return variant; + } + + public static void playgroundSettings() { + Scanner scanner = new Scanner(System.in); + Options.setFrameTitle("PythagorasTree"); + + System.out.println("How wide should the window be?"); + int width = Integer.parseInt(scanner.nextLine()); + + System.out.println("How high should the window be?"); + int height = Integer.parseInt(scanner.nextLine()); + + Options.setPlaygroundSize(width, height); + Options.setFramePosition(0, 0); + } + + public static Double squareSizeInput(Scanner scanner) { + System.out.println("Size of First Square:"); + return Double.parseDouble(scanner.nextLine()); + } + + public static Integer loopSizeInput(Scanner scanner) { + System.out.println("Create Loop? Type '1' for no loop and any larger number for a loop of that length:"); + return Integer.parseInt(scanner.nextLine()); + } + + public static Integer depthInput(Scanner scanner) { + System.out.println("How many levels should the tree be deep?"); + return Integer.parseInt(scanner.nextLine()); + } + + public static Double angleInput(Scanner scanner) { + System.out.println("What angle should the triangles of the tree have?"); + System.out.println("The angle put into here will be used as the left angle."); + return Double.parseDouble(scanner.nextLine()); + } + + public static PythagorasTree.PythagorasTreeVariant variantInput(Scanner scanner) { + PythagorasTree.PythagorasTreeVariant variant = PythagorasTree.PythagorasTreeVariant.unselected; + while (variant == PythagorasTree.PythagorasTreeVariant.unselected) { + System.out.println("No variant selected! Type in variant (To get the variants, type in 'help'):"); + String variantString = scanner.nextLine(); + if (variantString.equals("help")) variantHelp(); + variant = variantFromString(variantString); + } + System.out.println(variant); + return variant; + } + public static void variantHelp() { + System.out.println("SymetricPythagorasTree:"); + System.out.println(""); + System.out.println("This creates a normal symetric Pythagoras Tree."); + System.out.println(""); + System.out.println(""); + System.out.println(""); + + System.out.println("AsymetricPythagorasTree:"); + System.out.println(""); + System.out.println("This creates an asymetric Pythagoras Tree."); + System.out.println("The used angle will be adjustable later."); + System.out.println(""); + System.out.println(""); + System.out.println(""); + + System.out.println("RegularRandomPythagorasTree:"); + System.out.println(""); + System.out.println("This creates an asymetric Pythagoras Tree."); + System.out.println("Each level of the tree will have it's own randomly generated angle."); + System.out.println("The generated angles will be between 20 and 70 degree."); + System.out.println(""); + System.out.println(""); + System.out.println(""); + + System.out.println("PisanoPythagorasTreeOne:"); + System.out.println(""); + System.out.println("This creates an asymetric Pythagoras Tree."); + System.out.println("The angles used in this tree are generated from the Fibonacci Numbers."); + System.out.println("This (and the following variants) are similar to the regular random trees, "); + System.out.println("just with angles generated from the Fibonacci Numbers."); + System.out.println("The angles of this variant calculated like this: "); + System.out.println("Fibonacci number of the Level modulo 4 multiplied by 10 plus 30"); + System.out.println(""); + System.out.println(""); + System.out.println(""); + + System.out.println("PisanoPythagorasTreeTwo:"); + System.out.println(""); + System.out.println("The angles of this variant calculated like this: "); + System.out.println("Fibonacci number of the Level modulo 2 multiplied by 30 plus 30"); + System.out.println(""); + System.out.println(""); + System.out.println(""); + + System.out.println("PisanoPythagorasTreeThree:"); + System.out.println(""); + System.out.println("The angles of this variant calculated like this: "); + System.out.println("Fibonacci number of the Level modulo 7 multiplied by 5 plus 30"); + System.out.println(""); + System.out.println(""); + System.out.println(""); + + System.out.println("PisanoPythagorasTreeFour:"); + System.out.println(""); + System.out.println("The angles of this variant calculated like this: "); + System.out.println("Fibonacci number of the Level modulo 31 plus 30"); + System.out.println(""); + System.out.println(""); + System.out.println(""); + + System.out.println("PisanoPythagorasTreeFive:"); + System.out.println(""); + System.out.println("The angles of this variant calculated like this: "); + System.out.println("Fibonacci number of the Level modulo 9 multiplied by 4 plus 29"); + System.out.println(""); + System.out.println(""); + System.out.println(""); + } +} diff --git a/src/Numbers.java b/src/Numbers.java new file mode 100644 index 0000000..26d2292 --- /dev/null +++ b/src/Numbers.java @@ -0,0 +1,27 @@ +import java.util.LinkedList; + +/** + * Created by Christian on 10.02.2015. + */ +public class Numbers { + LinkedList fibonacci = new LinkedList(); + LinkedList regularRandom = new LinkedList(); + + public Numbers() { + fibonacci.add((long) 1); + fibonacci.add((long) 1); + regularRandom.add(Math.random()); + } + + public long calcFibonacci(int index) { + if (index < fibonacci.size()) return fibonacci.get(index); + else return calcFibonacci(index - 1) + calcFibonacci(index - 2); + } + + public double getRegularRandom(int index){ + while (regularRandom.size() <= index) { + regularRandom.add(Math.random()); + } + return regularRandom.get(index); + } +} diff --git a/src/PythagorasTree.java b/src/PythagorasTree.java new file mode 100644 index 0000000..c4128f1 --- /dev/null +++ b/src/PythagorasTree.java @@ -0,0 +1,82 @@ +import ch.aplu.turtle.Turtle; + +import java.awt.*; +import java.util.LinkedList; + +/** + * Created by Christian on 10.02.2015. + */ +public class PythagorasTree { + private PythagorasTree rightSubTree; + private PythagorasTree leftSubTree; + private PythagorasTreeVariant variant; + private PythagorasTriangleList triangles; + private Turtle turtle; + private double size; + private int momentaryDepth; + private int maximalDepth; + + public PythagorasTree(PythagorasTreeVariant variant, PythagorasTriangleList triangles, Turtle turtle, double size, int momentaryDepth, int maximalDepth) { + this.variant = variant; + this.triangles = triangles; + this.turtle = turtle; + this.size = size; + this.momentaryDepth = momentaryDepth; + this.maximalDepth = maximalDepth; + } + + public void addPythagorasTree(PythagorasTreeQueue queue) { + if (momentaryDepth + 1 >= maximalDepth) return; + + turtle.forward(size); + + turtle.pushState(); + turtle.right(triangles.getLeftAngle(momentaryDepth)); + PythagorasTree treeOne = queue.remove(); + treeOne.drawPythagorasTree(queue); + + + turtle.popState(); + + + + turtle.setPenColor(drawColor(momentaryDepth, maximalDepth)); + + turtle.left(triangles.getRightAngle(momentaryDepth)); + turtle.forward(size * triangles.getRightSizeFactor(momentaryDepth)); + PythagorasTree treeTwo = queue.remove(); + treeTwo.drawPythagorasTree(queue); + treeOne.addPythagorasTree(queue); + treeTwo.addPythagorasTree(queue); + } + + public void drawPythagorasTree(PythagorasTreeQueue queue) { + rightSubTree = new PythagorasTree(variant, triangles, turtle, size * triangles.getRightSizeFactor(momentaryDepth), momentaryDepth + 1, maximalDepth); + queue.add(rightSubTree); + leftSubTree = new PythagorasTree(variant, triangles, turtle, size * triangles.getLeftSizeFactor(momentaryDepth), momentaryDepth + 1, maximalDepth); + queue.add(leftSubTree); + + DrawingTools.drawSquare(turtle, size); + + } + + public static Color drawColor(int momentaryDepth, int maximalDepth) { + + double colorFactor = 255 / maximalDepth; + + int red = (int) (colorFactor * (maximalDepth - momentaryDepth)); + if (red > 139) red = 139; + if (red < 0) red = 0; + int green = 255 - (int) (colorFactor * (maximalDepth - momentaryDepth)); + if (green < 69) green = 69; + int blue = (int) (colorFactor * ((maximalDepth - momentaryDepth) / 5)); + if (blue > 19) blue = 19; + return new Color(red, green, blue); + } + + public enum PythagorasTreeVariant { + SymetricPythagorasTree, AsymetricPythagorasTree, RegularRandomPythagorasTree, + PisanoPythagorasTreeOne, PisanoPythagorasTreeTwo, PisanoPythagorasTreeThree, PisanoPythagorasTreeFour, PisanoPythagorasTreeFive, + unselected, + } +} diff --git a/src/PythagorasTreeQueue.java b/src/PythagorasTreeQueue.java new file mode 100644 index 0000000..61cb404 --- /dev/null +++ b/src/PythagorasTreeQueue.java @@ -0,0 +1,16 @@ +import ch.aplu.turtle.Turtle; + +import java.util.LinkedList; + +/** + * Created by Christian on 10.02.2015. + */ +public class PythagorasTreeQueue extends LinkedList { + public PythagorasTreeQueue(PythagorasTree.PythagorasTreeVariant variant, PythagorasTriangleList triangles, Turtle turtle, double size, int momentaryDepth, int maximalDepth) { + super(); + add(new PythagorasTree(variant, triangles, turtle, size, momentaryDepth, maximalDepth)); + PythagorasTree tree = remove(); + tree.drawPythagorasTree(this); + tree.addPythagorasTree(this); + } +} diff --git a/src/PythagorasTriangle.java b/src/PythagorasTriangle.java new file mode 100644 index 0000000..b339330 --- /dev/null +++ b/src/PythagorasTriangle.java @@ -0,0 +1,79 @@ +/** + * Created by Christian on 10.02.2015. + */ +public class PythagorasTriangle { + private double leftSizeFactor; + private double leftAngle; + private double rightSizeFactor; + private double rightAngle; + private PythagorasTree.PythagorasTreeVariant variant; + + public PythagorasTriangle(PythagorasTree.PythagorasTreeVariant variant, int momentaryDepth, Numbers numbers, Double angle) { + + switch (variant) { + + + case SymetricPythagorasTree: + leftAngle = 45; + break; + + + case AsymetricPythagorasTree: + if (angle < 0 || angle > 90) return; + leftAngle = angle; + break; + + + case RegularRandomPythagorasTree: + leftAngle = numbers.getRegularRandom(momentaryDepth) * 50 + 20; + break; + + + case PisanoPythagorasTreeOne: + leftAngle = (numbers.calcFibonacci(momentaryDepth) % 4) * 10 + 30; + break; + + + case PisanoPythagorasTreeTwo: + leftAngle = (numbers.calcFibonacci(momentaryDepth) % 2) * 30 + 30; + break; + + + case PisanoPythagorasTreeThree: + leftAngle = (numbers.calcFibonacci(momentaryDepth) % 7) * 5 + 30; + break; + + + case PisanoPythagorasTreeFour: + leftAngle = (numbers.calcFibonacci(momentaryDepth) % 31) + 30; + break; + + + case PisanoPythagorasTreeFive: + leftAngle = (numbers.calcFibonacci(momentaryDepth) % 9) * 4 + 29; + break; + + default: + leftAngle = 45; + break; + } + rightAngle = (double) 90 - leftAngle; + leftSizeFactor = Math.sin(Math.toRadians(leftAngle)); + rightSizeFactor = Math.sin(Math.toRadians(rightAngle)); + } + public double getLeftSizeFactor() { + return leftSizeFactor; + } + + public double getLeftAngle() { + return leftAngle; + } + + public double getRightSizeFactor() { + return rightSizeFactor; + } + + public double getRightAngle() { + return rightAngle; + } +} diff --git a/src/PythagorasTriangleList.java b/src/PythagorasTriangleList.java new file mode 100644 index 0000000..839cc97 --- /dev/null +++ b/src/PythagorasTriangleList.java @@ -0,0 +1,31 @@ +import java.util.LinkedList; + +/** + * Created by Christian on 10.02.2015. + */ +public class PythagorasTriangleList { + private LinkedList triangles = new LinkedList(); + private Numbers numbers = new Numbers(); + + public PythagorasTriangleList(PythagorasTree.PythagorasTreeVariant variant, double maximalDepth, double angle) { + for (int i = 0; i < maximalDepth; i++) { + triangles.add(new PythagorasTriangle(variant, i, numbers, angle)); + } + } + + public double getLeftAngle(int index) { + return triangles.get(index).getLeftAngle(); + } + + public double getRightAngle(int index) { + return triangles.get(index).getRightAngle(); + } + + public double getLeftSizeFactor(int index) { + return triangles.get(index).getLeftSizeFactor(); + } + + public double getRightSizeFactor(int index) { + return triangles.get(index).getRightSizeFactor(); + } +} diff --git a/src/TurtleState.java b/src/TurtleState.java new file mode 100644 index 0000000..87579c0 --- /dev/null +++ b/src/TurtleState.java @@ -0,0 +1,16 @@ +import ch.aplu.turtle.Turtle; + +/** + * Created by Christian on 10.02.2015. + */ +public class TurtleState { + private double x; + private double y; + private double heading; + + public TurtleState(Turtle turtle) { + x = turtle.getX(); + y = turtle.getY(); + heading = turtle.heading(); + } +}