Initial project import

tools/v/examples/pendulum-simulation/modules/sim/img/ppm.v

@@ -0,0 +1,74 @@
+module img
+
+import gg
+import os
+import sim
+
+@[params]
+pub struct ImageSettings {
+pub:
+	width      int = sim.default_width
+	height     int = sim.default_height
+	cache_size int = 200
+}
+
+pub fn new_image_settings(settings ImageSettings) ImageSettings {
+	return ImageSettings{
+		...settings
+	}
+}
+
+pub fn image_settings_from_grid(grid sim.GridSettings) ImageSettings {
+	return ImageSettings{
+		width:  grid.width
+		height: grid.height
+	}
+}
+
+pub fn (s ImageSettings) to_grid_settings() sim.GridSettings {
+	return sim.GridSettings{
+		width:  s.width
+		height: s.height
+	}
+}
+
+pub struct PPMWriter {
+mut:
+	file       os.File
+	cache      []u8
+	cache_size int
+}
+
+pub fn ppm_writer_for_fname(fname string, settings ImageSettings) !&PPMWriter {
+	mut writer := &PPMWriter{
+		cache_size: settings.cache_size
+		cache:      []u8{cap: settings.cache_size}
+	}
+	writer.start_for_file(fname, settings)!
+	return writer
+}
+
+pub fn (mut writer PPMWriter) start_for_file(fname string, settings ImageSettings) ! {
+	writer.file = os.create(fname)!
+	writer.file.writeln('P6 ${settings.width} ${settings.height} 255')!
+}
+
+pub fn (mut writer PPMWriter) handle_pixel(p gg.Color) ! {
+	if writer.cache.len >= writer.cache_size {
+		writer.write()!
+		writer.flush()!
+	}
+	writer.cache << [p.r, p.g, p.b]
+}
+
+pub fn (mut writer PPMWriter) flush() ! {
+	writer.cache.clear()
+}
+
+pub fn (mut writer PPMWriter) write() ! {
+	writer.file.write(writer.cache)!
+}
+
+pub fn (mut writer PPMWriter) close() {
+	writer.file.close()
+}

tools/v/examples/pendulum-simulation/modules/sim/img/worker.v

@@ -0,0 +1,40 @@
+module img
+
+import benchmark
+import sim
+
+pub fn image_worker(mut writer PPMWriter, result_chan chan &sim.SimResult, settings ImageSettings) {
+	width := settings.width
+	height := settings.height
+	total_pixels := width * height
+
+	// as new pixels come in, write them to the image file
+	mut current_index := u64(0)
+	mut pixel_buf := []ValidColor{len: total_pixels, init: ValidColor{
+		valid: false
+	}}
+
+	mut bmark := benchmark.new_benchmark()
+	for {
+		result := <-result_chan or { break }
+
+		// find the closest magnet
+		pixel_buf[result.id].Color = compute_pixel(result)
+		pixel_buf[result.id].valid = true
+
+		for current_index < total_pixels && pixel_buf[current_index].valid {
+			bmark.step()
+			writer.handle_pixel(pixel_buf[current_index].Color) or {
+				bmark.fail()
+				sim.log(@MOD + '.' + @FN + ': pixel handler failed. Error ${err}')
+				break
+			}
+			bmark.ok()
+			current_index++
+		}
+	}
+	bmark.stop()
+	println(bmark.total_message(@FN))
+
+	writer.write() or { panic('Could not write image') }
+}

tools/v/examples/pendulum-simulation/modules/sim/img/writer.v

@@ -0,0 +1,68 @@
+module img
+
+import gg
+import sim
+
+pub struct ValidColor {
+	gg.Color
+pub mut:
+	valid bool
+}
+
+pub struct ImageWriter {
+	settings ImageSettings
+pub mut:
+	writer        PPMWriter
+	current_index int
+	buffer        []ValidColor
+}
+
+pub fn new_image_writer(mut writer PPMWriter, settings ImageSettings) &ImageWriter {
+	total_pixels := settings.width * settings.height
+	mut buffer := []ValidColor{len: total_pixels, init: ValidColor{
+		valid: false
+	}}
+	return &ImageWriter{
+		writer:   writer
+		settings: settings
+		buffer:   buffer
+	}
+}
+
+pub fn (mut iw ImageWriter) handle(result sim.SimResult) !int {
+	total_pixels := iw.settings.width * iw.settings.height
+
+	// find the closest magnet
+	iw.buffer[result.id].Color = compute_pixel(result)
+	iw.buffer[result.id].valid = true
+
+	for iw.current_index < total_pixels && iw.buffer[iw.current_index].valid {
+		iw.writer.handle_pixel(iw.buffer[iw.current_index].Color) or {
+			sim.log(@MOD + '.' + @FN + ': pixel handler failed. Error ${err}')
+			break
+		}
+		iw.current_index++
+	}
+
+	if iw.current_index == total_pixels {
+		iw.writer.write() or { panic('Could not write image') }
+		return error('none')
+	}
+
+	return iw.current_index
+}
+
+pub fn compute_pixel(result sim.SimResult) gg.Color {
+	closest_to_m1 := result.magnet1_distance < result.magnet2_distance
+		&& result.magnet1_distance < result.magnet3_distance
+	closest_to_m2 := result.magnet2_distance < result.magnet1_distance
+		&& result.magnet2_distance < result.magnet3_distance
+
+	if closest_to_m1 {
+		return gg.red
+	} else if closest_to_m2 {
+		return gg.green
+	} else {
+		return gg.blue
+	}
+}