fractalstikz-pgf
I am trying to draw a fractal in tikz that is not a 'common' one – so I'm a little stuck.
It is essentially the Sierpinski Casket but with a square instead of a triangle. Start with the (solid) unit square, remove the centre 9-th, and repeat with the remaining 8 squares. So you end up with 8^k squares of size 1/9^k.
I'd like it to look something like:
Preferably the 'last' image will be of stage 5 or 6 but, if possible, a nice definable end stage would be great (like other fractals in LaTeX).
There are certain places where TikZ don't parse the math such as node names and a few other places. Inside a loop you can instead use the evaluate=<var> as <resulting var> using <formula> syntax. You could have used a counter that starts from 1 in this specific case too.
Moreover you need to use (...) to nest the math and {...} to hide it from the parser. Hence the code becomes
\begin{tikzpicture}
\foreach \x in {0,1,2,3,4,5,6,7,8,9,10,11,12}{
\node (P\x) at (-\x/2,0){};
}
\foreach \x in {13,14,15,16,17,18,19,20,21,22,23,24,25,26}{
\node (P\x) at ({(\x-13)/2)},0){};
}
\node (P27) at (14,1){};
\node (P28) at (14,-1){};
\node (P29) at (-14,1){};
\node (P30) at (-14,-1){};
\node (P31) at (-15,0){};
\foreach \x in {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31}{
\fill (P\x) circle (2pt);
}
\foreach \x[evaluate=\x as \evalx using int(\x+1)] in {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25}{
\draw[line width=1 pt] (P\x)--(P\evalx);
}
\draw[line width=1 pt] (P26)--(P27);
\draw[line width=1 pt] (P27)--(P28);
\draw[line width=1 pt] (P28) -- (P26);
\draw[line width=1 pt] (P13)--(P29);
\draw[line width=1 pt] (P29)--(P30);
\draw[line width=1 pt] (P30) -- (P31);
\draw[line width=1 pt] (P31) -- (P13);
\draw (0,-3) node[below]{Figure 3.4};
\end{tikzpicture}
I do not know if this will make you happy, but yes, a kind of Lindenmayer system can work for your problem, using the fact that the cube is made of 20 copies of a 3-times-smaller itself, who themselves are made of a 3-times-smaller cube, and so on. Here is a way you can do it; I let you make the needed adaptations to get a better picture.
First generate a .tex file level0.tex with no \documentclass, \begin{document} or so, whose content just would be:
\fill[yellow] (1, 1, 1) -- (1, -1, 1) -- (-1, -1, 1) -- (-1, 1, 1) -- cycle;
\fill[cyan] (1, 1, 1) -- (1, 1, -1) -- (1, -1, -1) -- (1, -1, 1) -- cycle;
\fill[magenta] (1, 1, 1) -- (1, 1, -1) -- (-1, 1, -1) -- (-1, 1, 1) -- cycle;
Now you create a file level1.tex (again, no \documentclass or so) in which you use the content of level0 twenty times as if you were putting several small cubes near each other. Beware that you have to draw the cubes in a correct order, so that a cube hiding another one will only be drawn after it. Your file level1.tex would be the following:
\begin{scope}[scale=.3333333333]
\begin{scope}[shift={(-2, -2, -2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(0, -2, -2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(2, -2, -2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(-2, 0, -2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(2, 0, -2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(-2, 2, -2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(0, 2, -2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(2, 2, -2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(-2, -2, 0)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(2, -2, 0)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(-2, 2, 0)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(2, 2, 0)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(-2, -2, 2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(0, -2, 2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(2, -2, 2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(-2, 0, 2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(2, 0, 2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(-2, 2, 2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(0, 2, 2)}]
\input{level0}
\end{scope}
\begin{scope}[shift={(2, 2, 2)}]
\input{level0}
\end{scope}
\end{scope}
Next you create a file level2.tex which is the same as level1.tex, except that \input{level0} is replaced by \input{level1}. And finally your final drawing (inside a real .tex source file with \documentclass and so on) will be
\begin{tikzpicture}
\input{level2}
\end{tikzpicture}
Below is the rendering I get. Of course you can go up to level 3, 4 or so, at least theoretically, but do not forget that the amount of computation and memory used will be multiplied by a factor 20 at each further level!
Kind regards, /Nancy-N
EDIT: Paul Gaborit has quite nicely improved my solution by coding a command \mengersponge taking one argument, so that you do not have to create one file per level. Here is his code (where he also chose more relevant colours ;-)):
\documentclass[tikz]{standalone}
\usepackage{luatex85}
\newcommand\mengersponge[1]{
\pgfmathsetmacro\level{int(#1 - 1)}
\ifnum \level = 0 \relax
\filldraw[gray!50!black,line width=0] (1, 1, 1) -- (1, 1, -1) -- (1, -1, -1) -- (1, -1, 1) -- cycle;
\filldraw[gray,line width=0] (1, 1, 1) -- (1, 1, -1) -- (-1, 1, -1) -- (-1, 1, 1) -- cycle;
\filldraw[gray!50,line width=0] (1, 1, 1) -- (1, -1, 1) -- (-1, -1, 1) -- (-1, 1, 1) -- cycle;
\else
\begin{scope}[scale=.3333333333]
\begin{scope}[shift={(-2, -2, -2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(0, -2, -2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(2, -2, -2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(-2, 0, -2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(2, 0, -2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(-2, 2, -2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(0, 2, -2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(2, 2, -2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(-2, -2, 0)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(2, -2, 0)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(-2, 2, 0)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(2, 2, 0)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(-2, -2, 2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(0, -2, 2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(2, -2, 2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(-2, 0, 2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(2, 0, 2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(-2, 2, 2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(0, 2, 2)}]
\mengersponge{\level}
\end{scope}
\begin{scope}[shift={(2, 2, 2)}]
\mengersponge{\level}
\end{scope}
\end{scope}
\fi
}
\begin{document}
\begin{tikzpicture}
\mengersponge{4}
\end{tikzpicture}
\end{document}
With pdflatex, Paul Gaborit could only perform the computations up to level 3 (corresponding to \mengersponge{4} in his code), which took 40 seconds to compilate; but with lualatex he could compile level 4 (corresponding to \mengersponge{5}). Below are his pictures :-)
For level 3:
For level 4:
Regards, /Nancy-N
Best Answer
Use the
lindenmayersystemsof TikZ.