anchor.diff:      DeltaX = (XRealRight - XRealLeft) / Width,
       DeltaY = (YImaginaryHigh - YImaginaryLow) / Height,
   
  -    makeAllRows(Width,Height,1,XRealLeft,YImaginaryLow,DeltaX,DeltaY,FractalConfig,[],Config).
  -        %% note the 3rd parameter is "CurrentPixelY" which starts at bottom
  -        %% note the 9th parameter is "IterCounts" which starts as empty list
  -		%% makeAllRows returns InterCount, which is then returned by createPointData 
  +    %% create the count data
  +    IterationCountData = createPointData( {XRealLeft,DeltaX,Width},       %info for points in a row
  +                                          {YImaginaryLow,DeltaY,Height},  %info for rows
  +                                          ConfigMap),
  +
  +    %% print some stats on distribution of counts
  +    %% need to do
  +
  +    %% colorize the data using simplest alg
  +    ColorData = imagelib:colorizeData(IterationCountData,simplest,ConfigMap),
  +
  +    %% take the x,y,color data and creates an image
  +    imagelib:makeImageFromData( ColorData, ConfigMap ),
  +
  +    ok.
  +
  +createPointData( {XRealLeft,DeltaX,Width}, {YImaginaryLow,DeltaY,Height}, ConfigMap)
  +        when DeltaX > 0, DeltaY > 0 ->
  +
  +    CurrentPixelY = 1,   % start at bottom and work up (so head of list will be top row)
  +    IterCounts = [],     % start with empty data box
  +    %% makeAllRows returns InterCount, which is then returned by createPointData 
  +    makeAllRows( {XRealLeft,DeltaX,Width}, 
  +                 {YImaginaryLow,DeltaY,Height,CurrentPixelY},
  +                 IterCounts, 
  +                 ConfigMap).
   
   %% make one row at a time, starting at bottom and working up 
   %%  note builds list from tail so this yeilds highest Y nearest front 
   %%  which is useful in case later we might to build file on fly that way 'from top'
   
   % function head for done
  -makeAllRows(_Width,Height, CurrentPixelY,_XRealLeft,_CurrentImaginaryY,_DeltaX,_DeltaY,_FractalConfig,IterCounts,Config)
  +%new
  +makeAllRows( {_XRealLeft,_DeltaX,_Width}, 
  +                 {_CurrentImaginaryY,_DeltaY,Height,CurrentPixelY},
  +                 IterCounts, 
  +                 _ConfigMap)
           when CurrentPixelY > Height ->  
       IterCounts;   %reached bottom so return the iteration count data
   
   % function head for not-done so recurse
  -makeAllRows(Width,Height,CurrentPixelY,XRealLeft,CurrentImaginaryY,DeltaX,DeltaY,FractalConfig,IterCounts,Config) ->
  +makeAllRows( {XRealLeft,DeltaX,Width}, 
  +                 {CurrentImaginaryY,DeltaY,Height,CurrentPixelY},
  +                 IterCounts, 
  +                 ConfigMap) ->
  +
       % reached here so need to make another row
  -    % note Y-1 one since doing top down
  -    % similarly Imaginary& went down by delta
   	% IterCounts is updated with the new row calculated by makePoints and is the returned value
  -    makeAllRows(Width,Height,CurrentPixelY+1,XRealLeft,CurrentImaginaryY+DeltaY,DeltaX,DeltaY,FractalConfig,
  -        makePoints(Width,1,CurrentPixelY,XRealLeft, CurrentImaginaryY,DeltaX,FractalConfig,IterCounts,Config),Config ).
  +    NewIterCounts = makePoints(Width,
  +                               1,                   % set CurrentPixelX to 1
  +                               CurrentPixelY,
  +                               XRealLeft, 
  +                               CurrentImaginaryY,
  +                               DeltaX,
  +                               IterCounts,
  +                               ConfigMap),
  +    makeAllRows( {XRealLeft,DeltaX,Width}, 
  +                 {CurrentImaginaryY+DeltaY,DeltaY,Height,CurrentPixelY+1},   % increment float & pixel Y's
  +                 NewIterCounts,                                   % new counts
  +                 ConfigMap).
       
   % function head for done-with-row
  -makePoints(Width,CurrentPixelX,_CurrentPixelY,_CurrentRealX,_CurrentImaginaryY,_DeltaX,_FractalConfig,IterCounts,Config)
  +makePoints(Width,
  +           CurrentPixelX,
  +           _CurrentPixelY,
  +           _CurrentRealX,
  +           _CurrentImaginaryY,
  +           _DeltaX,
  +           IterCounts,
  +           _ConfigMap)
           when CurrentPixelX > Width ->  
       IterCounts;   %reached end of line so return the iteration count data
   
   % function head for not-done so recurse
  -makePoints(Width,CurrentPixelX,CurrentPixelY,CurrentRealX,CurrentImaginaryY,DeltaX,FractalConfig,IterCounts,Config) ->   
  +makePoints(Width,
  +           CurrentPixelX,
  +           CurrentPixelY,
  +           CurrentRealX,
  +           CurrentImaginaryY,
  +           DeltaX,
  +           IterCounts,
  +           ConfigMap) ->   
       %reached here so need to add another pixel
       % CurrentPixelX starts at 1 increases by 1 each recurse
       % CurrentRealX starts at XRealLeft and increases by DeltaX each recurse
       % IterCounts has point {X,Y,Iter} added by function addOnePoint
       FractalAlg= maps:get(fractalAlg,ConfigMap),
  -    makePoints(Width,CurrentPixelX+1,CurrentPixelY,CurrentRealX+DeltaX,CurrentImaginaryY,DeltaX,FractalConfig,
  -        addOnePoint(CurrentPixelX,
  -                    CurrentPixelY,
  -                    CurrentRealX,
  -                    CurrentImaginaryY,
  -                    FractalAlg,
  -                    IterCounts,
  -                    Config),
  -         Config ).
  -        %% note addOnePoint returns the new value of IterCounts into the recursive call
  +
  +    %% note addOnePoint returns the new value of IterCounts into the recursive call
  +    NewIterCounts = addOnePoint(CurrentPixelX,
  +                                CurrentPixelY,
  +                                CurrentRealX,
  +                                CurrentImaginaryY,
  +                                FractalAlg,
  +                                IterCounts,
  +                                ConfigMap),
  +
  +    makePoints(Width,
  +               CurrentPixelX+1,
  +               CurrentPixelY,
  +               CurrentRealX+DeltaX,
  +               CurrentImaginaryY,
  +               DeltaX, 
  +               NewIterCounts, 
  +               ConfigMap ).
   
   %% Compute fractal (bounded or unbounded)
  -    %% FractalConfig = {FractalAlg,CReal,CImaginary, ZReal,ZImaginary,BailoutThreshold,MaxIterationThreshold}
       %% FractalAlg is which algorithm (only one at moment)
   % this function clause for creating julian fractals. eventually will generalize
   addOnePoint(CurrentPixelX,
  
positive.code: %% test config 1 - eventually make parameterized and move this to test dir
  testConfig1() ->
      % return map of config parameters
      TC = #{ fractalAlg => julian,  % Fractal Algorithm is julian
         fractalImageFileName => "./julian10.10.dot5.dot5.4.100.png",  %image file created
         width => 10, % width=10
         height => 10, % height=10
  
negative.code: 
  
  % create a simple fractal
  simplFrac(ConfigMap) ->
  
      %% simple config
      %%FractalConfig = {julian,0.5,-0.5, 0,0,4,100},
      %%Width = 10,
      %%Height = 10,
  
      %% first create julian data set with some hardcoded configs (add configing later)
          %% XRealRight = 3.0 
          %% XRealLeft = -3.0
          %% YImaginaryLow = -3.0
          %% YImaginaryHigh = 3.0
      %%IterationCountData = createPointData(Width,Height,-3.0, 3.0, -3.0, 3.0, ConfigMap),
  
      %% create box of data for every X,Y
      Width           = maps:get(width,ConfigMap),
      Height          = maps:get(height,ConfigMap),
      XRealRight      = maps:get(xRealRight,ConfigMap),
      XRealLeft       = maps:get(xRealLeft,ConfigMap),
      YImaginaryLow   = maps:get(yImaginaryLow,ConfigMap),
      YImaginaryHigh  = maps:get(yImaginaryHigh,ConfigMap),
      %% box is bounded on left by x > XRealLeft and bounded on right by x < XRealRight
      %% box is bounded on top by y > YImaginaryHigh and bounded on bottom by y > YImaginaryLow
      %% box is width pixels wide and height pixels high
  