anchor.diff:  
   
   % create a simple fractal
  -simplFrac(Config) ->
  -
  -    %% FractalConfig = {FractalAlg,CReal,CImaginary, ZReal,ZImaginary,BailoutThreshold,MaxIterationThreshold}
  +simplFrac(ConfigMap) ->
  +
       %% simple config
  -    FractalConfig = {julian,0.5,-0.5, 0,0,4,100},
  -    Width = 10,
  -    Height = 10,
  +    %%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, FractalConfig,Config),
  -
  -    %% print some stats on distribution of counts
  -    %% need to do
  -
  -    %% colorize the data using simplest alg
  -    ColorData = imagelib:colorizeData(IterationCountData,simplest,{}),
  -
  -    %% take the x,y,color data and creates an image
  -    imagelib:makeImageFromData( ColorData, Config ),
  -
  -    ok.
  -
  -createPointData(Width,Height, XRealLeft, XRealRight, YImaginaryLow, YImaginaryHigh, FractalConfig,Config) 
  -    when XRealLeft < XRealRight, YImaginaryLow < YImaginaryHigh ->
  +    %%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
  
positive.code:             Yimaginary,
              FractalAlg,
              IterCounts,
              Config) 
      when FractalAlg == julian ->
  
      CReal = dict:fetch(cReal,Config),
      CImaginary = dict:fetch(cImaginary,Config),
      MaxIterationThreshold = dict:fetch(maxIterationThreshold,Config),
      BailoutThreshold = dict:fetch(bailoutThreshold,Config),
      %% return IterCounts with new point added. Note 3rd item in tuple is Count, and 4th item in compute call is initial iteration
      Count = computeIterationValue(CReal,
                                    CImaginary,
                                    Xreal,
                                    Yimaginary,
  
negative.code:     DeltaX = (XRealRight - XRealLeft) / Width,
      DeltaY = (YImaginaryHigh - YImaginaryLow) / Height,
  
      %% 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
  %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( {XRealLeft,DeltaX,Width}, 
                   {CurrentImaginaryY,DeltaY,Height,CurrentPixelY},
                   IterCounts, 
                   ConfigMap) ->
  
      % reached here so need to make another row
  	% IterCounts is updated with the new row calculated by makePoints and is the returned value
      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,
             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,
             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),
  
      %% 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)
      %% FractalAlg is which algorithm (only one at moment)
  % this function clause for creating julian fractals. eventually will generalize
  addOnePoint(CurrentPixelX,
  