%
% function apfelm( P, b, nZ, nS ) 
%
%   P : Iterations-Umgebung (komplexe Zahl)
%   b : Breite des Berechnungs-Quadrats
%   nZ: Zeilenzahl in Pixeln  (Bild-Auflösung)
%   nS: Spaltenzahl in Pixeln 
%   
% 
%   Apfelmännchen (Mandelbrot-Menge): 
%     Iteration:  C(n+1) = C(n)^2 + P 
%
%     Punkte aktP zu Folgen, die beschränkt bleiben, das heißt, 
%     der Betrag der Folgenglieder wächst nicht über alle Grenzen.
%     Wenn Schleife ganz durchlaufen wurde, ist die Farbe schwarz. 
% 
%     Iteration bricht ab, wenn Folgenglied größer wird als 
%     valDiv = 1000. Die Einfärbung liegt um so stärker bei der 
%     Farbe colDiv, je schneller valDiv überschritten wird. 
%
%  Beispiel-Aufrufe: 
%  >> apfelm( -0.7, 3.5, 250, 300 ) 
%  >> apfelm( -0.8+0.2i, 0.3, 250, 300 )
%  >> apfelm( -1.22+0.35i, 0.15, 250, 300 )
%  >> apfelm( -1.25+0.35i, 0.05, 250, 300 )
%  
%
function apfelm( P, b, nZ, nS ) 

   % Schranke für maximale Zahl der Durchläufe, 
   %   sollte nicht zu groß sein, z.B. 50 
   maxIt = 35;
   
   % Schranke für Divergenz
   valDiv = 1000;   
            
   % Höhe in komplexer Ebene 
   %   aus Verhältnis von Zeilenzahl / Spaltenzahl  
   h = b * nZ/nS; 

   % Bild-Daten vorbelegen
   A = uint8( zeros( nZ, nS, 3 ) );

   for( z=1:nZ )      % alle Zeilen 
      for( s=1:nS )   % alle Spalten 
         % Position in der komplexen Ebene zu Pixel z, s    
         %   Umrechnung: P in Bildmitte, Breite b, Höhe h  
	     aktP = P - b/2 + i*h/2 + s*b/nS - i* z*h/nZ;
         % Farbe zu akt. Bildpunkt bestimmen 
         A( z, s, 1:3 ) = getColor( aktP, maxIt, valDiv ); 
      end
   end 
   
   image( A ); 
   axis image;    
   set( gca, 'XTick', [] )
   set( gca, 'YTick', [] )
   txt = sprintf( 'P = (%.4f,%.4f), b = %.4f, maxIt = %d, valDiv = %d', ... 
                   real(P), imag(P), b, maxIt, valDiv );
   title( txt )
   
end
   
   
% Iteration am Punkt P: 
function  col = getColor( P, maxIt, valDiv ) 
   
   % Farben 
   colKonv = uint8( [0 0 0] );       % schwarz für Konvergenz 
   colDiv  = uint8( [130,5,50] );    % wein-rot für extrem schnelle Divergenz 
   % nächster Farbschritt:  colDiv + 10*colIncr 
   colIncr = uint8( [-12,24,-3] );   % Farbincrement mal Faktor 10   
   
   % vorbelegter Rückgabewert, wenn Schleife ganz durchlaufen wurde 
   col = colKonv; 
   Cv = P;   % Vorgänger C(n) auf Startpunkt setzen 
   
   % maximal maxIt Durchläufe, um über max-Wert valDiv zu wachsen  
   for( n = 1:maxIt )
       
      % nächster Iterations-Schritt  
      Cn = Cv^2 + P; 
      
      bC = abs( Cn );   % Betrag Cn
	  
	  % falls Divergenz, wird die Schleife verlassen: 	
	  if( bC > valDiv )
        % je schneller bC divergiert, also bei klienerem n, 
        %   desto  Farbe näher liegt die Farbe an colDiv, 
        %   ansonsten nimmt sie mit 10 * colIncr zu, 
        %   wobei cast zu uint8, um Farbraum nicht zu verlasssen  
        col = colDiv + uint8( n/maxIt * 10 ) * colIncr; 
		return;
      end
        
	  % Vorgänger für nächsten Durchlauf 
	  Cv = Cn;
   end
   
 end
   