package lecture1213;

public class YouAintGottaDictionaryException extends Exception {

  public YouAintGottaDictionaryException() {
    super("You ain't gotta dictionary, foobag. Get 1.");
  }
}

package lecture1213;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Dictionary {
  private ArrayList<String> words;
  
  public Dictionary() throws YouAintGottaDictionaryException {
    words = new ArrayList<>();
    File file = new File("/usr/share/dict/words");
    
    try {
      Scanner in = new Scanner(file);
      while (in.hasNextLine()) {
        words.add(in.nextLine());
      }
      Collections.sort(words);
    } catch (FileNotFoundException e) {
      throw new YouAintGottaDictionaryException();
    }
  }
  
  public boolean containsLinear(String target) {
    for (String word : words) {
      if (word.equals(target)) {
        return true;
      }
    }
    return false;
  }
  
  public boolean containsBinary(String target) {
    int first = 0;
    int last = words.size() - 1;
    
    while (first <= last) {
      int middle = (first + last) / 2;
//      System.out.printf("%d %d %d%n", first, last, middle);

      int order = target.compareTo(words.get(middle));
      if (order < 0) {
        last = middle - 1;
      } else if (order > 0) {
        first = middle + 1;
      } else {
        return true;
      }
    }
    
    return false;
  }
}

package lecture1213;

import lecture1129.Stopwatch;

public class Words {
  public static void main(String[] args) throws YouAintGottaDictionaryException {
    Dictionary dictionary = new Dictionary();
    
    String[] words = {
      "hey",
      "hay",
      "hayyyyyyy",
      "zoo",
      "yeah",
      "yay",
      "yea",
      "rumplestiltskin",
      "chris",
      "incest",
      "princess",
      "princest",
      "poverty",
      "gutter",
      "alabama",
      "euphemism",
      "good",
      "one",
      "foobag"
    };
    Stopwatch timer = new Stopwatch();
    timer.start();
    for (String word : words) {
      System.out.println(dictionary.containsBinary(word));
    }
    double elapsed = timer.stop();
    System.out.println(elapsed);
  }
}

package lecture1213;

public class ForSomeReasonYouDontHaveADictionaryInstalledOnYourMachineSorryException extends Exception {

  public ForSomeReasonYouDontHaveADictionaryInstalledOnYourMachineSorryException() {
    super("No hay un diccionario.");
  }
}

package lecture1213;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Dictionary {
  private ArrayList<String> words;

  public Dictionary() throws ForSomeReasonYouDontHaveADictionaryInstalledOnYourMachineSorryException {
    File file = new File("/usr/share/dict/words");
    try {
      words = new ArrayList<>();
      Scanner in = new Scanner(file);
      while (in.hasNextLine()) {
        words.add(in.nextLine());
      }
      Collections.sort(words);
    } catch (FileNotFoundException e) {
      throw new ForSomeReasonYouDontHaveADictionaryInstalledOnYourMachineSorryException();
    }
  }
  
  public boolean containsLinear(String target) {
    for (String word : words) {
      if (word.equals(target)) {
        return true;
      }
    }
    return false;
  }
  
  public boolean containsBinary(String target) {
    int first = 0;
    int last = words.size() - 1;
    
    while (first <= last) {
      int iMiddle = (first + last) / 2;
      int order = target.compareTo(words.get(iMiddle));
      if (order == 0) {
        return true;
      } else if (order < 0) {
        last = iMiddle - 1;
      } else {
        first = iMiddle + 1;
      }
    }
    
    return false;
  }
}

package lecture1213;

import lecture1129.Stopwatch;

public class Main {
  public static void main(String[] args) throws ForSomeReasonYouDontHaveADictionaryInstalledOnYourMachineSorryException {
    String[] words = {
      "eucalyptus",
      "Chris",
      "periwinkle",
      "longest",
      "word",
      "xylophone",
      "super...",
      "antidisestablishmentarianism",
      "accuse",
      "puce",
      "scoot",
      "scoop",
      "finals",
      "java",
      "c++",
      "lonely",
      "\u3422"
    };
    
    Dictionary dictionary = new Dictionary();
    
    Stopwatch stopwatch = new Stopwatch();
    stopwatch.start();
    
    for (String word : words) {
      System.out.println(word + " -> " + dictionary.containsBinary(word));
    }
    
    stopwatch.stop();
    System.out.println(stopwatch.getElapsedSeconds());
  }
}

package lecture1211;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class LightsOutFrame extends JFrame implements MouseListener {
  private static final int PIXELS = 100;
  private static final int GAP = 2;

  private LightsOutPanel panel;
  private boolean[][] board;

  public LightsOutFrame() {
    board = new boolean[5][5];
//    board[2][3] = true;

    panel = new LightsOutPanel();
    panel.setPreferredSize(new Dimension(PIXELS * 5, PIXELS * 5));
    panel.addMouseListener(this);

    add(panel);
    
    JMenuItem saveLevel = new JMenuItem("Save level");
    JMenu menu = new JMenu("Level");
    JMenuBar menuBar = new JMenuBar();
    
    menu.add(saveLevel);
    menuBar.add(menu);
    setJMenuBar(menuBar);
    
    saveLevel.addActionListener(e -> {
      saveLevel();
    });

    pack();
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    setVisible(true);
  }
  
  private void saveLevel() {
    try {
      PrintWriter out = new PrintWriter(new File("/Users/johnch/Desktop/level"));
      for (int r = 0; r < 5; ++r) {
        for (int c = 0; c < 5; ++c) {
          out.print(board[r][c] + " ");
        }
        out.println();
      }
      out.close();
    } catch (IOException e) {
      System.out.println(e);
    }
  }

  class LightsOutPanel extends JPanel {
    public void paintComponent(Graphics g) {
      for (int r = 0; r < 5; ++r) {
        for (int c = 0; c < 5; ++c) {
          // (c, r)
          if (board[r][c]) {
            g.setColor(Color.YELLOW);
          } else {
            g.setColor(Color.BLACK);
          }
          g.fillRect(c * PIXELS + GAP, r * PIXELS + GAP, PIXELS - 2 * GAP, PIXELS - 2 * GAP);
        }
      }
    }
  }

  @Override
  public void mouseClicked(MouseEvent e) {
  }

  @Override
  public void mousePressed(MouseEvent e) {
  }

  @Override
  public void mouseReleased(MouseEvent e) {
//    System.out.println(e);
    int r = e.getY() / PIXELS;
    int c = e.getX() / PIXELS;
    flop(c, r);
    flop(c + 1, r);
    flop(c - 1, r);
    flop(c, r - 1);
    flop(c, r + 1);
    repaint();
    
    if (isWin()) {
      JOptionPane.showMessageDialog(this, "A winner is you!");
    }
  }

  private void flop(int c,
                    int r) {
    if (r >= 0 && r < 5 && c >= 0 && c < 5) {
      board[r][c] = !board[r][c];
    }
  }
  
  private boolean isWin() {
    for (int r = 0; r < 5; ++r) {
      for (int c = 0; c < 5; ++c) {
        if (board[r][c]) {
          return false;
        }
      }
    }
    return true;
  }

  @Override
  public void mouseEntered(MouseEvent e) {
  }

  @Override
  public void mouseExited(MouseEvent e) {
  }

}

package lecture1211;

public class LightsOut {
  public static void main(String[] args) {
    new LightsOutFrame();
  }
}

package lecture1211;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class LightsOutFrame extends JFrame implements MouseListener {
  private static final int PIXELS = 50;
  private static final int BORDER = 3;

  private boolean[][] board;

  public LightsOutFrame() {
    board = new boolean[5][5];
//    board[2][4] = true;

    LightsOutPanel panel = new LightsOutPanel();
    add(panel);

    panel.addMouseListener(this);

    panel.setPreferredSize(new Dimension(5 * PIXELS, 5 * PIXELS));
    pack();
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    setVisible(true);
  }

  private class LightsOutPanel extends JPanel {
    public void paintComponent(Graphics g) {
      for (int r = 0; r < 5; ++r) {
        for (int c = 0; c < 5; ++c) {
          if (board[r][c]) {
            g.setColor(Color.GREEN);
          } else {
            g.setColor(Color.RED);
          }
          g.fillRect(c * PIXELS + BORDER, r * PIXELS + BORDER, PIXELS - BORDER * 2, PIXELS - BORDER * 2);
        }
      }
    }
  }

  @Override
  public void mouseClicked(MouseEvent e) {
  }

  @Override
  public void mousePressed(MouseEvent e) {
  }

  @Override
  public void mouseReleased(MouseEvent e) {
    int r = e.getY() / PIXELS;
    int c = e.getX() / PIXELS;
    flip(c, r);
    flip(c + 1, r);
    flip(c - 1, r);
    flip(c, r - 1);
    flip(c, r + 1);
    repaint();
    
    if (isWin()) {
      JOptionPane.showMessageDialog(this, "You winned!");
    }
  }
  
  private boolean isWin() {
    for (int r = 0; r < 5; ++r) {
      for (int c = 0; c < 5; ++c) {
        if (board[r][c]) {
          return false;
        }
      }
    }
    return true;
  }

  private void flip(int c,
                    int r) {
    if (c >= 0 && c < 5 && r >= 0 && r < 5) {
      board[r][c] = !board[r][c];
    }
  }

  @Override
  public void mouseEntered(MouseEvent e) {
  }

  @Override
  public void mouseExited(MouseEvent e) {
  }
}

package lecture1211;

public class LightsOut {
  public static void main(String[] args) {
    new LightsOutFrame();
  }
}

@Test
public void testFeatureA() {
  Foo f = new Foo();
  int expectedValue = ...;
  int actualValue = f.featureA();
  Assert.assertEquals("Foo.featureA didn't do what I expected it to do when...",
                      expectedValue,
                      actualValue);
}

package lecture1208;

public class StringList {
  int N;
  String[] a;

  public StringList() {
    N = 0;
    a = new String[2];
  }

  public void add(String element) {
    if (N >= a.length) {
      String[] b = new String[a.length * 2];
      for (int i = 0; i < a.length; i++) {
        b[i] = a[i];
      }
      a = b;
    }
    a[N] = element;
    N++;

  }

  public void remove(int index) {
    String[] dst = new String[a.length - 1];
    for (int i = 0; i < a.length; i++) {
      if (i < index) {
        dst[i] = a[i];
      }
      if (i > index) {
        dst[i - 1] = a[i];
      }
    }
    a = dst;
    N--;
  }

  public int size() {
    return N;
  }

  public boolean contains(String str) {
    for (int i = 0; i < N; ++i) {
      if (a[i].equals(str)) {
        return true;
      }
    }
    return false;
  }

  public String get(int index) {
    return a[index];
  }

  public boolean isEmpty() {
    return N == 0;
  }

  public int indexOf(String needle) {
//    int counter = 0;
//    while (!a[counter].equals(needle)) {
//      counter++;
//    }
//    return counter;
    
    for (int i = 0; i < N; ++i) {
      if (a[i].equals(needle)) {
        return i;
      }
    }
    return -1;
  }
}

package lecture1208;

import org.junit.Assert;
import org.junit.Test;

public class Tests {
  @Test
  public void testEmpty() {
    StringList list = new StringList();
    Assert.assertEquals("I tried calling size on an empty list, but :(", 0, list.size());
    Assert.assertEquals("I tried asking an empty list if it contained hope, but :(", false, list.contains("hope"));
    Assert.assertEquals("I tried asking an empty list if it was empty, but :(", true, list.isEmpty());
    Assert.assertEquals("I tried getting indexOf(hope) on an empty list, but :(", -1, list.indexOf("hope"));

  }
  
  @Test
  public void testOnesie() {
    StringList list = new StringList();
    list.add("hope");
    Assert.assertEquals("I tried calling size on a 1-list, but :(", 1, list.size());
    Assert.assertEquals("I tried asking a 1-list if it contained hope, but :(", true, list.contains("hope"));
    Assert.assertEquals("I tried asking a 1-list if it was empty, but :(", false, list.isEmpty());
    Assert.assertEquals("I tried getting element 0 from a 1-list, but :(", "hope", list.get(0));
    Assert.assertEquals("I tried getting indexOf(hope) on a 1-list, but :(", 0, list.indexOf("hope"));
  }
  
  @Test
  public void testRemoveFromOnesie() {
    StringList list = new StringList();
    list.add("hope");
    list.remove(0);
    Assert.assertEquals("I tried calling size on an empty list, but :(", 0, list.size());
    Assert.assertEquals("I tried asking an empty list if it contained hope, but :(", false, list.contains("hope"));
    Assert.assertEquals("I tried asking an empty list if it was empty, but :(", true, list.isEmpty());
  }
  
  @Test
  public void testLotsies() {
    StringList list = new StringList();
    list.add("hope");
    list.add("element");
    list.add("failure");
    list.add("success");
    Assert.assertEquals("I tried calling size on a 4-list, but :(", 4, list.size());
    Assert.assertEquals("I tried asking a 4-list if it contained hope, but :(", true, list.contains("hope"));
    Assert.assertEquals("I tried asking a 4-list if it contained hope, but :(", true, list.contains("element"));
    Assert.assertEquals("I tried asking a 4-list if it contained hope, but :(", true, list.contains("failure"));
    Assert.assertEquals("I tried asking a 4-list if it contained hope, but :(", true, list.contains("success"));
    Assert.assertEquals("I tried asking a 4-list if it was empty, but :(", false, list.isEmpty());
    Assert.assertEquals("I tried getting element 0 from a 1-list, but :(", "hope", list.get(0));
    Assert.assertEquals("I tried getting element 1 from a 1-list, but :(", "element", list.get(1));
    Assert.assertEquals("I tried getting element 2 from a 1-list, but :(", "failure", list.get(2));
    Assert.assertEquals("I tried getting element 3 from a 1-list, but :(", "success", list.get(3));
    Assert.assertEquals("I tried getting indexOf(hope) on a 1-list, but :(", 0, list.indexOf("hope"));
    Assert.assertEquals("I tried getting indexOf(element) on a 1-list, but :(", 1, list.indexOf("element"));
    Assert.assertEquals("I tried getting indexOf(failure) on a 1-list, but :(", 2, list.indexOf("failure"));
    Assert.assertEquals("I tried getting indexOf(success) on a 1-list, but :(", 3, list.indexOf("success"));

  }
}

package lecture1208;

public class GrowableArray {
  private String[] currentStringArray;
  private int nelements;

  public GrowableArray() {
    currentStringArray = new String[10];
    nelements = 0;
  }

  public String get(int i) {
    return currentStringArray[i];
  }

  public boolean isEmpty() {
    return nelements == 0;
  }

  public void remove(int index) {
    String[] newArray = new String[currentStringArray.length - 1];
    for (int i = 0; i < index; i++) {
      newArray[i] = currentStringArray[i];
    }
    for (int i = index; i < newArray.length; i++) {
      newArray[i] = currentStringArray[i + 1];
    }
    currentStringArray = newArray;
    --nelements;
  }

  public boolean contains(String string) {
    boolean isTrue = false;
    for (int i = 0; i < nelements; i++) {
      if (currentStringArray[i].equals(string)) {
        isTrue = true;
      }
    }
    return isTrue;
  }

  public int indexOf(String s) {
    for (int i = 0; i < nelements; i++) {
      if (currentStringArray[i].equals(s)) {
        return i;
      }
    }
    return -1;
  }

  public int size() {
    return nelements;
  }

  public void add(String s) {
    if (nelements == currentStringArray.length) {
      String[] moar = new String[2 * nelements];
      System.arraycopy(currentStringArray, 0, moar, 0, nelements);
      currentStringArray = moar;
    }
    currentStringArray[nelements] = s;
    ++nelements;
  }
}

package lecture1208;

import org.junit.Assert;
import org.junit.Test;

public class Tests {
  @Test
  public void testEmpty() {
    GrowableArray list = new GrowableArray();
    Assert.assertEquals("I tried asking an empty list if it was empty, but...", true, list.isEmpty());
    Assert.assertEquals("I tried asking an empty list its size, but...", 0, list.size());
    Assert.assertEquals("I tried asking an empty list if it had hope, but...", false, list.contains("hope"));
  }
  
  @Test
  public void testOnesie() {
    GrowableArray list = new GrowableArray();
    list.add("hope");
    Assert.assertEquals("I tried asking a 1 list if it was empty, but...", false, list.isEmpty());
    Assert.assertEquals("I tried asking a 1 list its size, but...", 1, list.size());
    Assert.assertEquals("I tried asking a 1 list if it had hope, but...", true, list.contains("hope"));
    Assert.assertEquals("I tried asking a 1 list about indexOf hope, but...", 0, list.indexOf("hope"));
    list.remove(0);
    Assert.assertEquals("I tried asking an empty list if it was empty, but...", true, list.isEmpty());
    Assert.assertEquals("I tried asking an empty list its size, but...", 0, list.size());
    Assert.assertEquals("I tried asking an empty list if it had hope, but...", false, list.contains("hope"));
  }
  
  @Test
  public void testLotsies() {
    GrowableArray list = new GrowableArray();
    list.add("hope");
    list.add("peace");
    list.add("joy");
    list.add("love");
    Assert.assertEquals("I tried asking a 4 list if it was empty, but...", false, list.isEmpty());
    Assert.assertEquals("I tried asking a 4 list its size, but...", 4, list.size());
    Assert.assertEquals("I tried asking a 4 list if it had hope, but...", true, list.contains("hope"));
    Assert.assertEquals("I tried asking a 4 list if it had peace, but...", true, list.contains("peace"));
    Assert.assertEquals("I tried asking a 4 list if it had joy, but...", true, list.contains("joy"));
    Assert.assertEquals("I tried asking a 4 list if it had love, but...", true, list.contains("love"));
    Assert.assertEquals("I tried asking a 4 list if it had love , but...", false, list.contains("love "));

    Assert.assertEquals("I tried asking a 4 list about indexOf hope, but...", 0, list.indexOf("hope"));
    Assert.assertEquals("I tried asking a 4 list about indexOf peace, but...", 1, list.indexOf("peace"));
    Assert.assertEquals("I tried asking a 4 list about indexOf joy, but...", 2, list.indexOf("joy"));
    Assert.assertEquals("I tried asking a 4 list about indexOf love, but...", 3, list.indexOf("love"));
    Assert.assertEquals("I tried asking a 4 list about indexOf love , but...", -1, list.indexOf("love "));

//    list.remove(0);
//    Assert.assertEquals("I tried asking an empty list if it was empty, but...", true, list.isEmpty());
//    Assert.assertEquals("I tried asking an empty list its size, but...", 0, list.size());
//    Assert.assertEquals("I tried asking an empty list if it had hope, but...", false, list.contains("hope"));
  }
}

package lecture1206;

import java.lang.reflect.Array;

public class StringList {
  int N;
  String [] a;
  
  public StringList () {
    int N = 0;
    String [] a = new String[2];
  }
  
  public void add(String element) {
    if(N >= a.length) {
      String[] b = new String[a.length*2];
      for(int i = 0; i < a.length; i++) {
        b[i] = a[i];
      }
      a = b;
    }
    a[N] = element;
    N++;
    
  }
  
  public void remove(int index) {
    String[] dst = new String[a.length - 1];
    for (int i = 0; i < a.length; i++) {
      if(i < index) {
        dst[i] = a[i];
      }
      if(i > index) {
        dst[i - 1] = a[i];
      }
    }
    a = dst;
    N--;
  }
  public int size() {
    return N;
  }
  public boolean contains(String str) {
    for (int i = 0; i < a.length;++i) {
      if (a[i].equals(str)){
        return true;
      }
    }
    return false;
  }
  public String get(int index) {
    return a[index];
  }
  public boolean isEmpty() {
    return N == 0;
  }
  public int indexOf(String[] s, String a) {
    int counter = 0;
    while (!s[counter].equals(a)) {
      counter++;
    }
    return counter;
}
}

package lecture1206;

public class GrowableArray {

  private String[] currentStringArray;

  public GrowableArray() {
    currentStringArray = new String[10];
  }

  public String get(int i) {
    return currentStringArray[i];
  }

  public boolean isEmpty() {
    for (String s : currentStringArray) {
      if (s != null) {
        return false;
      }
    }
    return true;
  }

  public void remove(int index) {
    String[] newArray = new String[currentStringArray.length - 1];
    for (int i = 0; i < index; i++) {
      newArray[i] = currentStringArray[i];
    }
    for (int i = index; i < newArray.length; i++) {
      newArray[i] = currentStringArray[i + 1];
    }
    currentStringArray = newArray;
  }

  public boolean contains(String string) {
    boolean isTrue = false;
    for (int i = 0; i < currentStringArray.length; i++) {
      if (currentStringArray[i].equals(string)) {
        isTrue = true;
      }
    }
    return isTrue;
  }

  public int indexOf(String s) {
    for (int i = 0; i < currentStringArray.length; i++) {
      if (currentStringArray[i].equals(s)) {
        return i;
      }
    }
    return -1;
  }

  public int size() {
    int length = 0;
    for (int i = 0; i < currentStringArray.length; ++i) {
      if (!get(i).isEmpty()) {
        length++;
      }
    }
    return length;
  }
}

SplatBotColor.RED
SplatBotColor.BLUE

Cell.RED               // cell has been painted red
Cell.BLUE              // cell has been painted blue
Cell.NEUTRAL           // cell has not been painted
Cell.ROCK              // cell is covered by impenetrable rock
Cell.RED_ROBOT         // cell is occupied by red robot
Cell.BLUE_ROBOT        // cell is occupied by blue robot
Cell.WALL              // cell is off the game board

Action.TURN_LEFT
Action.TURN_RIGHT
Action.MOVE_FORWARD
Action.MOVE_BACKWARD
Action.PASS            // skips a turn
Action.SPLAT           // fires a splat in the robot's line of sight
Action.SURVEY          // request a view of the game board

int delayMillis = 100;
int nTurns = 500;
new Splatter(splatbot.RobotRandom.class, lab12.SplatBot.class, delayMillis, nTurns);

package lecture1204;

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Volume {
  private int[][][] densities;
  
  public Volume(String path) throws IOException {
    DataInputStream in = new DataInputStream(new FileInputStream(path));
  
    int width = in.readInt();
    int height = in.readInt();
    int depth = in.readInt();
    
    densities = new int[depth][height][width];
    
    for (int z = 0; z < depth; ++z) {
      for (int y = 0; y < height; ++y) {
        for (int x = 0; x < width; ++x) {
          densities[z][y][x] = Byte.toUnsignedInt(in.readByte());
        }
      }
    }
    
    in.close();
  }
  
  public int getDepth() {
    return densities.length;
  }
  
  public int getHeight() {
    return densities[0].length;
  }
  
  public int getWidth() {
    return densities[0][0].length;
  }
  
  public int get(int x, int y, int z) {
    return densities[z][y][x];
  }
}

package lecture1204;

import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

public class SliderListener implements ChangeListener {
  public void stateChanged(ChangeEvent e) {
    System.out.println(e);
  }
}

package lecture1204;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.image.BufferedImage;

import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JSlider;

public class Slicer extends JFrame {
  private JLabel label;
  private Volume volume;

  public Slicer(Volume volume) {
    this.volume = volume;

    JSlider slider = new JSlider(0, 100);
    label = new JLabel("foobag");
    add(slider, BorderLayout.NORTH);
    add(label, BorderLayout.CENTER);

    slider.addChangeListener(e -> {
      load(slider.getValue());
    });
    load(slider.getValue());

    pack();
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    setVisible(true);
  }

  private void load(int z) {
    BufferedImage image = new BufferedImage(volume.getWidth(), volume.getHeight(), BufferedImage.TYPE_INT_RGB);

    for (int y = 0; y < image.getHeight(); ++y) {
      for (int x = 0; x < image.getWidth(); ++x) {
        int density = volume.get(x, y, z);
        Color color = new Color(density, density, density);
        image.setRGB(x, y, color.getRGB());
      }
    }

    label.setIcon(new ImageIcon(image));
  }
}

package lecture1204;

import java.io.IOException;

public class Main {
  public static void main(String[] args) throws IOException {
    Volume vismale = new Volume("/Users/johnch/Desktop/vismale.f0");
    Slicer slicer = new Slicer(vismale);
  }
}