{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Advanced example: parsing PLY files\n", "\n", "PLY is a file format storing 3D polygonal data that has support for both ASCII and binary formats. Some references: [Wikipedia entry](https://en.wikipedia.org/wiki/PLY_(file_format)) and [Paul Bourke's pages](http://paulbourke.net/dataformats/ply/). The specification of the PLY format is a bit vague and allows for liberal interpretation and custom user defined fields. We take a look at the example on Paul Bourke's page:\n", "\n", "```\n", "ply\n", "format ascii 1.0 { ascii/binary, format version number }\n", "comment made by Greg Turk { comments keyword specified, like all lines }\n", "comment this file is a cube\n", "element vertex 8 { define \"vertex\" element, 8 of them in file }\n", "property float x { vertex contains float \"x\" coordinate }\n", "property float y { y coordinate is also a vertex property }\n", "property float z { z coordinate, too }\n", "element face 6 { there are 6 \"face\" elements in the file }\n", "property list uchar int vertex_index { \"vertex_indices\" is a list of ints }\n", "end_header { delimits the end of the header }\n", "0 0 0 { start of vertex list }\n", "0 0 1\n", "0 1 1\n", "0 1 0\n", "1 0 0\n", "1 0 1\n", "1 1 1\n", "1 1 0\n", "4 0 1 2 3 { start of face list }\n", "4 7 6 5 4\n", "4 0 4 5 1\n", "4 1 5 6 2\n", "4 2 6 7 3\n", "4 3 7 4 0\n", "```\n", "\n", "We see a header that is always ASCII encoded. The header specifies a list of *elements*, each containing a list of *properties*. The listed elements determine how to parse the data section of the PLY file. The data section maybe encoded in ASCII or binary." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "from __future__ import annotations\n", "from typing import Optional\n", "from dataclasses import dataclass\n", "from functools import partial\n", "import numpy as np\n", "import pprint\n", "\n", "from byteparsing import (parse_bytes, Parser, parser)\n", "from byteparsing.parsers import (\n", " sequence, named_sequence, choice, optional, value, repeat_n,\n", " text_literal, char, text_one_of, text_end_by,\n", " byte_none_of, byte_one_of,\n", " flush, flush_decode,\n", " push, pop, char_pred,\n", " many, some, many_char, some_char, many_char_0, some_char_0,\n", " integer, scientific_number, array, binary_value,\n", " fmap, construct)\n", "\n", "pp = pprint.PrettyPrinter(indent=2, width=80)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Header\n", "\n", "The header starts with a \"magic number\", a line containing `ply`." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "eol = choice(text_literal(\"\\n\"), text_literal(\"\\n\\r\"))\n", "ply_magic_number = sequence(text_literal(\"ply\"), eol)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The second line indicates which variation of the PLY format this is. We will store header information in data classes and enums." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "from enum import Enum\n", "\n", "class PlyFormat(Enum):\n", " ASCII = 1\n", " BINARY_LE = 2\n", " BINARY_BE = 3\n", " \n", " @staticmethod\n", " def from_string(format_str: str) -> PlyFormat:\n", " if format_str == \"ascii\":\n", " return PlyFormat.ASCII\n", " if format_str == \"binary_little_endian\":\n", " return PlyFormat.BINARY_LE\n", " if format_str == \"binary_big_endian\":\n", " return PlyFormat.BINARY_BE\n", " else:\n", " raise ValueError(f\"Unrecognized format string: {s}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Since each item in the header is seperated by a newline, we need a `tokenize` function that doesn't skip newlines. From that we can define what we may consider to be a `word` in a PLY header. We `flush` the cursor, expect a `ascii_alpha` character (words don't start with numbers) and then many characters that are letters, numbers or underscores. At the end we `flush` the cursor again, decoding to a Python string. We see here both `many_char` and `many_char_0` being used: `many_char` automatically flushes the cursor before and after which is not what we want when parsing a word. In fact, the only thing `many_char_0` does, is to move the cursor end until the given parser no longer matches the input." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "ascii_alpha = char_pred(lambda c: 64 < c < 91 or 96 < c < 123)\n", "ascii_num = char_pred(lambda c: 48 <= c < 58)\n", "ascii_alpha_num = choice(ascii_alpha, ascii_num)\n", "ascii_underscore = char(95)\n", "\n", "\n", "def tokenize(p: Parser) -> Parser:\n", " return sequence(p >> push, many_char(text_one_of(\" \")), pop())\n", "\n", "word = sequence(\n", " flush(), ascii_alpha, many_char_0(choice(ascii_alpha_num, ascii_underscore)),\n", " flush_decode())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The format line specifies the used data encoding: one of `ascii`, `binary_little_endian` or `binary_big_endian`, and a version number. The version number is always \"1.0\"." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "ply_format = named_sequence(\n", " _1 = tokenize(text_literal(\"format\")),\n", " format_str = tokenize(word),\n", " _2 = sequence(tokenize(text_literal(\"1.0\")), eol)) \\\n", ">> construct(PlyFormat.from_string)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "parse_bytes(ply_format, b\"format binary_little_endian 1.0\\n\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Comments may be placed in the header by using the word comment at the start of the line. Everything from there until the end of the line should then be ignored." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "ply_comment = sequence(\n", " tokenize(text_literal(\"comment\")), flush(),\n", " text_end_by(\"\\n\") >> push, optional(char(\"\\r\")), pop())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we need a parser for a data type, and given a data type we need to be able to parse that data either in ASCII or binary. There are two classes of types: primitive types and list types." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "ply_type_table = {\n", " \"char\": \"int8\",\n", " \"uchar\": \"uint8\",\n", " \"short\": \"int16\",\n", " \"ushort\": \"uint16\",\n", " \"int\": \"int32\",\n", " \"uint\": \"uint32\",\n", " \"float\": \"float32\",\n", " \"double\": \"float64\"\n", "}\n", "\n", "class PlyType:\n", " pass\n", "\n", "@dataclass\n", "class PlyPrimitiveType(PlyType):\n", " dtype: np.dtype\n", " \n", " @staticmethod\n", " def from_string(s: str) -> PlyPrimitiveType:\n", " sanitized_name = ply_type_table.get(s, s)\n", " return PlyPrimitiveType(np.dtype(sanitized_name))\n", " \n", " @property\n", " def byte_size(self) -> int:\n", " return self.dtype.itemsize\n", " \n", " def ascii(self) -> Parser:\n", " return sequence(\n", " flush(), some_char_0(byte_none_of(b\"\\n \")),\n", " many_char_0(byte_one_of(b\"\\n \")), flush(self.dtype.type))\n", " \n", " def binary(self) -> Parser:\n", " return binary_value(self.dtype)\n", " \n", "@dataclass\n", "class PlyListType(PlyType):\n", " size_type: PlyPrimitiveType\n", " value_type: PlyPrimitiveType\n", " \n", " def ascii(self) -> Parser:\n", " return self.size_type.ascii() >> partial(repeat_n, self.value_type.ascii())\n", " \n", " def binary(self) -> Parser:\n", " return binary_value(self.size_type.dtype) >> partial(array, self.value_type.dtype)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "primitive_type = tokenize(word) >> fmap(PlyPrimitiveType.from_string)\n", "\n", "list_type = named_sequence(\n", " _1=tokenize(text_literal(\"list\")),\n", " size_type=primitive_type,\n", " value_type=primitive_type) >> construct(PlyListType)\n", "\n", "ply_type = choice(list_type, primitive_type)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "PlyPrimitiveType(dtype=dtype('float32'))" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "parse_bytes(ply_type, b\"float float\")" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PlyListType(size_type=PlyPrimitiveType(dtype=dtype('uint8')),\n", " value_type=PlyPrimitiveType(dtype=dtype('float32')))\n" ] } ], "source": [ "pp.pprint(parse_bytes(ply_type, b\"list uint8 float\"))" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "@dataclass\n", "class PlyProperty:\n", " dtype: PlyType\n", " name: str\n", "\n", "ply_property = named_sequence(\n", " _1=tokenize(text_literal(\"property\")),\n", " dtype=ply_type,\n", " name=tokenize(word),\n", " _2=eol) >> construct(PlyProperty)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')), name='x')" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "parse_bytes(\n", " ply_property,\n", " b\"property float x\\n\")" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "end_header = sequence(text_literal(\"end_header\"), eol)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "@dataclass\n", "class PlyElement:\n", " name: str\n", " size: int\n", " properties: List[PlyProperty]\n", " \n", " def ascii(self) -> Parser:\n", " single_item = named_sequence(\n", " **{p.name: p.dtype.ascii() for p in self.properties})\n", " return repeat_n(single_item, self.size)\n", " \n", " @property\n", " def afine(self) -> bool:\n", " return all(isinstance(p.dtype, PlyPrimitiveType)\n", " for p in self.properties)\n", " \n", " def binary(self) -> Parser:\n", " if self.afine:\n", " compound_type = [(p.name, p.dtype.dtype) for p in self.properties]\n", " return array(compound_type, self.size)\n", " else:\n", " single_item = named_sequence(\n", " **{p.name: p.dtype.binary() for p in self.properties})\n", " return repeat_n(single_item, self.size)\n", " \n", "\n", "ply_element = named_sequence(\n", " _1=tokenize(text_literal(\"element\")),\n", " name=tokenize(word),\n", " size=tokenize(integer),\n", " _2=eol,\n", " properties=some(ply_property)) >> construct(PlyElement)" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ PlyElement(name='vertex',\n", " size=8,\n", " properties=[ PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')),\n", " name='x'),\n", " PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')),\n", " name='y'),\n", " PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')),\n", " name='z')]),\n", " PlyElement(name='face',\n", " size=6,\n", " properties=[ PlyProperty(dtype=PlyListType(size_type=PlyPrimitiveType(dtype=dtype('uint8')),\n", " value_type=PlyPrimitiveType(dtype=dtype('int32'))),\n", " name='vertex_index')])]\n" ] } ], "source": [ "pp.pprint(\n", " parse_bytes(\n", " some(ply_element), \n", " b\"element vertex 8\\nproperty float x\\nproperty float y\\nproperty float z\\n\" +\n", " b\"element face 6\\nproperty list uchar int vertex_index\\n\"))" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PlyElement(name='face',\n", " size=6,\n", " properties=[ PlyProperty(dtype=PlyListType(size_type=PlyPrimitiveType(dtype=dtype('uint8')),\n", " value_type=PlyPrimitiveType(dtype=dtype('int32'))),\n", " name='vertex_index')])\n" ] } ], "source": [ "pp.pprint(parse_bytes(ply_element, b\"element face 6\\nproperty list uchar int vertex_index\\n\"))" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "@dataclass\n", "class PlyHeader:\n", " format: PlyFormat\n", " comment: List[str]\n", " elements: List[PlyElement]\n", " \n", " def parser(self) -> Parser:\n", " if self.format == PlyFormat.ASCII:\n", " return named_sequence(\n", " **{e.name: e.ascii() for e in self.elements})\n", " if self.format == PlyFormat.BINARY_LE:\n", " return named_sequence(\n", " **{e.name: e.binary() for e in self.elements})\n", " else:\n", " raise NotImplementedError()\n", "\n", "ply_header = named_sequence(\n", " _1=ply_magic_number,\n", " format=ply_format,\n", " comment=many(ply_comment),\n", " elements=some(ply_element),\n", " _2=sequence(text_literal(\"end_header\"), eol)) >> construct(PlyHeader)\n", "\n", "def ply_data(header):\n", " return named_sequence(header=value(header), data=header.parser())\n", "\n", "ply_file = ply_header >> ply_data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following ASCII example is given on Paul Bourke's page." ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "ascii_example = b\"\"\"ply\n", "format ascii 1.0\n", "comment made by Greg Turk\n", "comment this file is a cube\n", "element vertex 8\n", "property float x\n", "property float y\n", "property float z\n", "element face 6\n", "property list uchar int vertex_index\n", "end_header\n", "0 0 0\n", "0 0 1\n", "0 1 1\n", "0 1 0\n", "1 0 0\n", "1 0 1\n", "1 1 1\n", "1 1 0\n", "4 0 1 2 3\n", "4 7 6 5 4\n", "4 0 4 5 1\n", "4 1 5 6 2\n", "4 2 6 7 3\n", "4 3 7 4 0\n", "\"\"\"" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PlyHeader(format=,\n", " comment=['made by Greg Turk', 'this file is a cube'],\n", " elements=[ PlyElement(name='vertex',\n", " size=8,\n", " properties=[ PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')),\n", " name='x'),\n", " PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')),\n", " name='y'),\n", " PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')),\n", " name='z')]),\n", " PlyElement(name='face',\n", " size=6,\n", " properties=[ PlyProperty(dtype=PlyListType(size_type=PlyPrimitiveType(dtype=dtype('uint8')),\n", " value_type=PlyPrimitiveType(dtype=dtype('int32'))),\n", " name='vertex_index')])])\n" ] } ], "source": [ "pp.pprint(parse_bytes(ply_header, ascii_example))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "No for the fun part! The header that we read actually encodes the parser for the rest of the file!" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{ 'data': { 'face': [ {'vertex_index': [0, 1, 2, 3]},\n", " {'vertex_index': [7, 6, 5, 4]},\n", " {'vertex_index': [0, 4, 5, 1]},\n", " {'vertex_index': [1, 5, 6, 2]},\n", " {'vertex_index': [2, 6, 7, 3]},\n", " {'vertex_index': [3, 7, 4, 0]}],\n", " 'vertex': [ {'x': 0.0, 'y': 0.0, 'z': 0.0},\n", " {'x': 0.0, 'y': 0.0, 'z': 1.0},\n", " {'x': 0.0, 'y': 1.0, 'z': 1.0},\n", " {'x': 0.0, 'y': 1.0, 'z': 0.0},\n", " {'x': 1.0, 'y': 0.0, 'z': 0.0},\n", " {'x': 1.0, 'y': 0.0, 'z': 1.0},\n", " {'x': 1.0, 'y': 1.0, 'z': 1.0},\n", " {'x': 1.0, 'y': 1.0, 'z': 0.0}]},\n", " 'header': PlyHeader(format=,\n", " comment=['made by Greg Turk', 'this file is a cube'],\n", " elements=[ PlyElement(name='vertex',\n", " size=8,\n", " properties=[ PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')),\n", " name='x'),\n", " PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')),\n", " name='y'),\n", " PlyProperty(dtype=PlyPrimitiveType(dtype=dtype('float32')),\n", " name='z')]),\n", " PlyElement(name='face',\n", " size=6,\n", " properties=[ PlyProperty(dtype=PlyListType(size_type=PlyPrimitiveType(dtype=dtype('uint8')),\n", " value_type=PlyPrimitiveType(dtype=dtype('int32'))),\n", " name='vertex_index')])])}\n" ] } ], "source": [ "pp.pprint(parse_bytes(ply_file, ascii_example))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The Stanford Bunny\n", "Now that we have the capability to parse binary PLY files, we can load the Stanford Bunny. For visualisation purposes it helps to know that all faces in this file are triangles." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "from pathlib import Path\n", "\n", "bunny = parse_bytes(ply_file, Path(\"_static/stanford_bunny.ply\").open(mode=\"rb\").read())" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "vertices = bunny[\"data\"][\"vertex\"].view((np.float32, 3))\n", "triangles = np.array([row[\"vertex_indices\"] for row in bunny[\"data\"][\"face\"]])" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "from mpl_toolkits import mplot3d\n", "from matplotlib import pyplot as plt\n", "# For interactive use: install ipympl and run:\n", "# %matplotlib widget" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig = plt.figure(figsize=(12,12))\n", "ax = plt.axes(projection=\"3d\")\n", "ax.azim = -18\n", "ax.elev = 15\n", "ax.plot_trisurf(*vertices.T[[2,0,1]], triangles=triangles);" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.2" } }, "nbformat": 4, "nbformat_minor": 4 }