Module:    brain-viewer
Synopsis:  Brain Viewer application for Creatures 2
Author:    Chris Double
Copyright: (C) 1998, Chris Double.  All rights reserved.

define class <dendrite> (<object>)
    slot dendrite-id, init-keyword: id:;
    slot dendrite-width-offset, init-keyword: width-offset:;
    slot dendrite-height-offset, init-keyword: height-offset:;
    slot dendrite-stw, init-keyword: stw:;
    slot dendrite-ltw, init-keyword: ltw:;
    slot dendrite-str, init-keyword: str:;
    slot dendrite-unknown-data;
end class <dendrite>;

define class <cell> (<object>)
    slot cell-width-offset, init-keyword: width-offset:;
    slot cell-height-offset, init-keyword: height-offset:;
    slot cell-output, init-keyword: output:;
    slot cell-state, init-keyword: state:;
    slot cell-unknown-data, init-keyword: unknown:;
    slot cell-dendrites, init-keyword: dendrites:;
end class <cell>;

define class <dendrite-gene-data> (<object>)
    slot dendrite-source-lobe;
    slot dendrite-minimum;
    slot dendrite-maximum;
    slot dendrite-pattern;
    slot dendrite-fanout;
    slot dendrite-min-ltw;
    slot dendrite-max-ltw;
    slot dendrite-min-str;
    slot dendrite-max-str;     
end class <dendrite-gene-data>;

define class <lobe> (<object>)
    slot lobe-x, init-keyword: x:;
    slot lobe-y, init-keyword: y:;
    slot lobe-width, init-keyword: width:;
    slot lobe-height, init-keyword: height:;
    slot lobe-leakage-rate;
    slot lobe-rest-state;
    slot lobe-input-gain;
    slot lobe-dendrite-gene-data;
    slot lobe-number-of-cells;
    slot lobe-number-of-dendrites;
    slot lobe-cells, init-keyword: cells:;      

    virtual constant slot lobe-size;
end class <lobe>;

define method lobe-size( lobe :: <lobe> ) 
    lobe.lobe-width * lobe.lobe-height;
end method lobe-size;

define class <brain> (<object>)
    slot brain-lobes, init-keyword: lobes:;
end class <brain>;

define constant *brain-marker* = "CBrain";

define method load-brain-from-file( filename )
    with-open-file ( fs = filename, element-type: <byte> )
      while( as(<string>, read( fs, *brain-marker*.size)) ~= *brain-marker* )
        adjust-stream-position(fs, - ( *brain-marker*.size - 1 ));
        // Look for CBrain string...
      end while;

      // C2: Skip 36 bytes
      read( fs, 54 );

      // Found marker, next byte is number of lobes
      let number-of-lobes = read-32-bits( fs );
      let brain = make(<brain>, lobes: map-into(make(<vector>, size: number-of-lobes), 
                                                method(x) make(<lobe>) end,
                                                range(from: 1, to: number-of-lobes)));
      for( lobe in brain.brain-lobes)
        load-lobe-header( fs, lobe );
      end for;

      // Load cell information
      for( lobe in brain.brain-lobes )
        for(cell in lobe.lobe-cells)
          load-cell-header( fs, cell );
        end for;
      end for;
      brain;
    end with-open-file;

end method load-brain-from-file;

define method load-lobe-header( fs, lobe )
    
    lobe.lobe-x := read-32-bits( fs );
    lobe.lobe-y := read-32-bits( fs );
    lobe.lobe-width := read-32-bits( fs );
    lobe.lobe-height := read-32-bits( fs );
    
    // Start: C2 Only
    read( fs, 12);
    lobe.lobe-leakage-rate := read-8-bits( fs );
    lobe.lobe-rest-state := read-8-bits( fs );
    lobe.lobe-input-gain := read-8-bits( fs );
    read( fs, 16);
    lobe.lobe-dendrite-gene-data := make(<vector>, size: 2);
    for(i from 0 below 2)
      let gene-data = make(<dendrite-gene-data>);
      lobe.lobe-dendrite-gene-data[i] := gene-data;
      gene-data.dendrite-source-lobe := read-32-bits( fs );
      gene-data.dendrite-minimum := read-8-bits( fs );
      gene-data.dendrite-maximum := read-8-bits( fs );
      gene-data.dendrite-pattern := read-8-bits( fs );
      gene-data.dendrite-fanout := read-8-bits( fs );
      gene-data.dendrite-min-ltw := read-8-bits( fs );
      gene-data.dendrite-max-ltw := read-8-bits( fs );
      gene-data.dendrite-min-str := read-8-bits( fs );
      gene-data.dendrite-max-str := read-8-bits( fs );
      read( fs, 96 );
    end for;
    lobe.lobe-number-of-cells := read-32-bits( fs );
    lobe.lobe-number-of-dendrites := read-32-bits( fs );

    lobe.lobe-cells := map-into(make(<vector>, size: lobe.lobe-size),
                                method(x) make(<cell>) end,
                                range(from: 1, to: lobe.lobe-size));
end method load-lobe-header;

define method load-cell-header( fs, cell )
    cell.cell-width-offset := read-8-bits( fs );
    cell.cell-height-offset := read-8-bits( fs );
    cell.cell-output := read-8-bits( fs );
    cell.cell-state := read-8-bits( fs );
    // C1
    //    cell.cell-unknown-data := read( fs, 2 );
    // C2
    cell.cell-unknown-data := read( fs, 4 );
    cell.cell-dendrites := make(<vector>, size: 2);

   for( dendrite-header-count from 0 below 2 )
    let number-of-dendrites = read-8-bits( fs );
    let dendrite-type = read-8-bits( fs );
    let unknown-data = read( fs, 3 );
    cell.cell-dendrites[dendrite-header-count] := make(<stretchy-vector>);
    
    for(dendrite-count from 0 below number-of-dendrites)
      let dendrite = make(<dendrite>);
      add!(cell.cell-dendrites[dendrite-header-count], dendrite);

      dendrite.dendrite-id := read-32-bits( fs );
      dendrite.dendrite-width-offset := read-8-bits( fs );
      dendrite.dendrite-height-offset := read-8-bits( fs );
      dendrite.dendrite-unknown-data := read-8-bits( fs );
      dendrite.dendrite-stw := read-8-bits( fs );
      dendrite.dendrite-ltw := read-8-bits( fs );
      dendrite.dendrite-str := read-8-bits( fs );
    end for;
      
   end for;
end method load-cell-header;