ai-lab-one/read_in.py

from emis_funky_funktions import *

from world import Point, Terrain, World

from PIL import Image

from itertools import chain
from typing import List, NamedTuple, Tuple

def meters_to_millimeters(meters: float) -> int:
	"""
	Convert meters (floating point) to millimeters (int)

	>>> meters_to_millimeters(1.9333473e+02)
	193334

	>>> meters_to_millimeters(1.0)
	1000
	"""
	return int(1000 * meters)

def read_single_elevation(dat: str) -> Result[int, str]:
	"""
	Read in a single elevation

	Expects a single, stringified floating point value, in meters, without a unit, e.g.
	"2.057e+02".  If there is a parsing error, returns an error containing the input
	string. Otherwise, returns the elevation in millimeters.

	>>> read_single_elevation("1.9333473e+02")
	Ok(193334)

	>>> read_single_elevation("1.0")
	Ok(1000)

	>>> read_single_elevation("10.0m")
	Err('10.0m')
	"""
	try:
		# fuck floating points
		return Ok(meters_to_millimeters(float(dat)))
	except ValueError:
		return Err(dat)

def read_elevation_line(line: str) -> Result[Sequence[int], Tuple[int, str]]:
	"""
	Reads a line of elevations

	Each elevation should be in the format specified by `read_single_elevation`.  Every
	element of the line is parsed and combined into an iterator, which is returned.  If
	any parsing errors are encountered, the first error is returned.  It takes the form of
	a tuple containing the column of the error (in terms of whitespace-deliniated words,
	not characters) and the string which could not be parsed.

	Recall from the definition of `read_single_elevation()` that the return value is an
	integer number of millimeters.

	As per the problem specification, the last five columns of the line are not read or
	parsed.  Parsing errors in these columns therefor cannot be encountered, and any data
	in these columns will not be returned.

	>>> map_res(list, read_elevation_line("1.9e2 18e1 181 179.1 ignored 170.1 1.8e2 18i+2 20e1"))
	Ok([190000, 180000, 181000, 179100])

	>>> map_res(list, read_elevation_line("1.9e2 18e 181 179.1 ignored 170.1 1.8e2 18i+2 20e1"))
	Err((2, '18e'))
	"""
	return sequence([
		map_err(
			lambda err_text: (col_no + 1, err_text),
			read_single_elevation(elem)
		)
		# As per spec, we drop the last five entries of the file.
		for (col_no, elem) in enumerate(line.split()[:-5])
	])

class UnparsableElevation(NamedTuple):
	"An elevation entry failed to be parsed as a floating point"

	line_no: int
	"The line on which the error occurred"

	col_no: int
	"The column (1-indexed number of whitespace deliniated words) on which the error occurred"

	invalid_entry: str
	"The text which failed to parse as a floating point value"

def read_elevations(lines: Iterable[str]) -> Result[Iterator[int], UnparsableElevation]:
	"""
	Read an entire elevation file into a list

	This parses each line in of the file using `read_elevation_line()`.  Errors
	encountered are reported using an `UnparsableElevation`.  The resulting list is
	single-dimensional, but can be indexed arbitrarily, meaning for an input file with a
	constant number of columns per line, this data can be accessed as if it were a 2d
	square array.

	However, keep in mind that, as with `read_elevation_line()`, the last five columns of
	each line are dropped/ignored, and are therefor not present in the returned data.

	>>> map_res(list, read_elevations('''
	... 1   2   3   4   5   6   7   8   9e  10
	... 11  2.0 3e1 4   5   6   7   bwa 9   10
	... 11  2.0 3e0 4   5   ign err 8   9   10
	... '''.strip().split('\\n')))
	Ok([1000, 2000, 3000, 4000, 5000, 11000, 2000, 30000, 4000, 5000, 11000, 2000, 3000, 4000, 5000])

	>>> map_res(list, read_elevations('''
	... 1   2   3   4   5   6   7   8   9e  10
	... 11  ERR 3e1 4   5   6   7   bwa 9   10
	... 11  2.0 3e0 4   5   ign err 8   9   10
	... '''.strip().split('\\n')))
	Err(UnparsableElevation(line_no=2, col_no=2, invalid_entry='ERR'))
	"""
	return map_res(
		chain.from_iterable,
		sequence([
			map_err(
				lambda err: UnparsableElevation(line_no + 1, *err),
				read_elevation_line(line)
			)
			for (line_no, line) in enumerate(lines)
		])
	)

def gb_to_terrain_type(green_blue: Tuple[int, int]) -> Option[Terrain]:
	"""
	Maps the green and blue components of a color to a terrain type.

	If no terrain type exists with that color, then `None` is returned.

	>>> gb_to_terrain_type((192, 0))
	Some(<Terrain.ROUGH_MEADOW: 700>)

	>>> gb_to_terrain_type((192, 1)) is None
	True
	"""
	match green_blue:
		case (148, 18):
			return Some(Terrain.OPEN_LAND)
		case (192, 0):
			return Some(Terrain.ROUGH_MEADOW)
		case (255, 255):
			return Some(Terrain.EASY_FOREST)
		case (208, 60):
			return Some(Terrain.MEDIUM_FOREST)
		case (136, 40):
			return Some(Terrain.WALK_FOREST)
		case (73, 24):
			return Some(Terrain.BRUSH)
		case (0, 255):
			return Some(Terrain.WET)
		case (51, 3):
			return Some(Terrain.ROAD)
		case (0, 0):
			return Some(Terrain.FOOTPATH)
		case (0, 101):
			return Some(Terrain.OOB)
		case _:
			return None

class UnrecognizedColor(NamedTuple):
    "A color in a provided map was not in the list of recognized colors"

    x: int
    "The x coordinate of the unidentifided color"

    y: int
    "The y coordinate of the unidentifided color"

def load_gb_pixels_as_map(pixels: Iterable[Tuple[int, int]]) -> Result[Sequence[Terrain], UnrecognizedColor]:
    """
    Interpret the green and blue bands of an image as pixels on a map

    This assumes that the map follows the specification laid out at
    https://cs.rit.edu/~jro/courses/intelSys/labs/orienteering/

    Namely, the map should be exactly 395 pixels wide, and should follow the color
    conventions laid out in the Terrain Type table.

    This function is only interested in the green and blue channels of the image.  Rather
    than pass a full pixel, it is only necessary to pass the green and blue color values.

    If an error is encountered, the returned `Err` type will contain the x and y
    coordinates of the pixel which could not be identified.
    """
    return sequence([
        note(
			lambda: UnrecognizedColor(pix_no % 395, pix_no // 395),
            gb_to_terrain_type(gb)
        )
        for (pix_no, gb) in enumerate(pixels)
    ])

def load_image(path: str) -> Result[Sequence[Terrain], UnrecognizedColor]:
    "Run `load_gb_pixels_as_map` on an image read from a path"
    with Image.open(path) as im:
        return load_gb_pixels_as_map(zip(im.getdata(1), im.getdata(2)))

def load_elevations(path: str) -> Result[Iterator[int], UnparsableElevation]:
    "Run `read_elevations` on a text file read from a path"
    with open(path) as file:
        return read_elevations(file)

def load_world_from_paths(map_path: str, elevation_path: str) -> Result[World, UnparsableElevation | UnrecognizedColor]:
    """
    Read world information (terrain and elevation) from file paths.

    See `read_elevations` and `load_gb_pixels_as_map` for more information on the format
    that this data should be in.  Note that for this method, you do not need to worry
    about the channels present in the terrain map, just that it align with the colors and
    size of the specified format.
    """
    return bind_res(
        lambda terrain_data:
            map_res(
				lambda elevation_data: World((*zip(terrain_data, elevation_data),)),
                load_elevations(elevation_path)
            ),
        load_image(map_path)
    )

def parse_point(s: str) -> Result[Point, str]:
    """
    Parses a point from a string

    The point is expected to be a string containing two integer values seperated by
    whitespace.

    Any errors in parsing the string will result in an `Err` being returned, containing
    the original string.

    >>> parse_point('230 327')
    Ok((230, 327))

    >>> parse_point('230327')
    Err('230327')

    >>> parse_point('23O 327')
    Err('23O 327')
    """
    match s.strip().split():
        case [p1, p2]:
            try:
                return Ok(Point(int(p1), int(p2)))
            except ValueError:
                return Err(s)
        case _:
            return Err(s)

def parse_points(lines: Iterable[str]) -> Result[Sequence[Point], str]:
    """
    Parse a series of points

    Each point should be in the format specified by `parse_point()`, and each should be on
    it's own "line" (aka, item in an iterable).  Blank lines are ignored and dropped.  If
    any one of the lines in the input string fail to parse, the text of the first failed
    line will be returned in an `Err`.

    >>> parse_points('''
    ... 230 327
    ... 276 279
    ...
    ... 303 240
    ... '''.split('\\n'))
    Ok([(230, 327), (276, 279), (303, 240)])

    >>> parse_points('''
    ... 230 327
    ... 276 2BAD
    ... 3BAD 240
    ... '''.split('\\n'))
    Err('276 2BAD')
    """
    return sequence([
        parse_point(line)
        for line in lines
        if len(line) and not line.isspace()
    ])

def load_points(path: str) -> Result[Sequence[Point], str]:
    """
    Load a file full of points by passing the lines to `parse_points()`

    See `parse_points()` for format specifications
    """
    with open(path) as f:
        return parse_points(f)

if __name__ == '__main__':
	import doctest
	doctest.testmod()