move json to api, change tile loading api

lib/mound_hunters/mound_parser.ex

@@ -0,0 +1,269 @@
+defmodule MoundHunters.MoundParser do
+  @moduledoc """
+  Parser for .mound binary lidar files.
+
+  Supports:
+  - Header-only parsing
+  - Full file parsing (header + vertices + indices)
+  - Batch header parsing for directories
+  """
+
+  defmodule Header do
+    @moduledoc "Represents a .mound file header"
+
+    defstruct [
+      :magic,
+      :version,
+      :point_count,
+      :triangle_count,
+      :min_x,
+      :min_y,
+      :min_z,
+      :max_x,
+      :max_y,
+      :max_z
+    ]
+
+    @type t :: %__MODULE__{
+            magic: binary(),
+            version: non_neg_integer(),
+            point_count: non_neg_integer(),
+            triangle_count: non_neg_integer(),
+            min_x: float(),
+            min_y: float(),
+            min_z: float(),
+            max_x: float(),
+            max_y: float(),
+            max_z: float()
+          }
+  end
+
+  defmodule MoundFile do
+    @moduledoc "Represents a complete parsed .mound file"
+
+    defstruct [
+      :header,
+      :vertices,
+      :indices
+    ]
+
+    @type vertex :: {float(), float(), float()}
+    @type triangle :: {non_neg_integer(), non_neg_integer(), non_neg_integer()}
+
+    @type t :: %__MODULE__{
+            header: Header.t(),
+            vertices: [vertex()],
+            indices: [triangle()]
+          }
+  end
+
+  @header_size 64
+  @magic "LIDR"
+
+  @doc """
+  Parse only the header of a .mound file.
+
+  ## Examples
+
+      iex> MoundHunters.MoundParser.parse_header("path/to/file.mound")
+      {:ok, %MoundParser.Header{...}}
+      
+      iex> MoundHunters.MoundParser.parse_header("nonexistent.mound")
+      {:error, :enoent}
+  """
+  @spec parse_header(Path.t()) :: {:ok, Header.t()} | {:error, term()}
+  def parse_header(path) do
+    with {:ok, file} <- File.open(path, [:read, :binary]),
+         {:ok, header_data} <- :file.pread(file, 0, @header_size),
+         :ok <- File.close(file),
+         {:ok, header} <- decode_header(header_data) do
+      {:ok, header}
+    end
+  end
+
+  @doc """
+  Parse a complete .mound file including header, vertices, and indices.
+
+  ## Examples
+
+      iex> MoundHunters.MoundParser.parse_file("path/to/file.mound")
+      {:ok, %MoundParser.MoundFile{...}}
+  """
+  @spec parse_file(Path.t()) :: {:ok, MoundFile.t()} | {:error, term()}
+  def parse_file(path) do
+    with {:ok, data} <- File.read(path),
+         {:ok, mound_file} <- decode_file(data) do
+      {:ok, mound_file}
+    end
+  end
+
+  @doc """
+  Parse headers for all .mound files in a directory.
+
+  Returns a list of tuples with filename and header.
+
+  ## Examples
+
+      iex> MoundHunters.MoundParser.parse_directory_headers("tiles/")
+      {:ok, [
+        {"tile_001.mound", %MoundParser.Header{...}},
+        {"tile_002.mound", %MoundParser.Header{...}}
+      ]}
+  """
+  @spec parse_directory_headers(Path.t()) :: {:ok, [{String.t(), Header.t()}]} | {:error, term()}
+  def parse_directory_headers(dir_path) do
+    case File.ls(dir_path) do
+      {:ok, files} ->
+        results =
+          files
+          |> Enum.filter(&String.ends_with?(&1, ".mound"))
+          |> Enum.map(fn filename ->
+            full_path = Path.join(dir_path, filename)
+
+            case parse_header(full_path) do
+              {:ok, header} -> {:ok, {filename, header}}
+              {:error, reason} -> {:error, {filename, reason}}
+            end
+          end)
+
+        # Separate successes from failures
+        {successes, failures} =
+          Enum.split_with(results, fn
+            {:ok, _} -> true
+            {:error, _} -> false
+          end)
+
+        successes = Enum.map(successes, fn {:ok, result} -> result end)
+
+        case failures do
+          [] -> {:ok, successes}
+          _ -> {:ok, successes, Enum.map(failures, fn {:error, err} -> err end)}
+        end
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  # Private functions
+
+  defp decode_header(
+         <<magic::binary-size(4), version::little-unsigned-32, point_count::little-unsigned-32,
+           triangle_count::little-unsigned-32, min_x::little-float-32, min_y::little-float-32,
+           min_z::little-float-32, max_x::little-float-32, max_y::little-float-32,
+           max_z::little-float-32, _reserved::binary-size(24)>>
+       ) do
+    if magic == @magic do
+      {:ok,
+       %Header{
+         magic: magic,
+         version: version,
+         point_count: point_count,
+         triangle_count: triangle_count,
+         min_x: min_x,
+         min_y: min_y,
+         min_z: min_z,
+         max_x: max_x,
+         max_y: max_y,
+         max_z: max_z
+       }}
+    else
+      {:error, {:invalid_magic, magic}}
+    end
+  end
+
+  defp decode_header(_), do: {:error, :invalid_header}
+
+  defp decode_file(data) when byte_size(data) < @header_size do
+    {:error, :file_too_small}
+  end
+
+  defp decode_file(data) do
+    <<header_data::binary-size(@header_size), rest::binary>> = data
+
+    with {:ok, header} <- decode_header(header_data),
+         {:ok, vertices, indices_data} <- decode_vertices(rest, header.point_count),
+         {:ok, indices} <- decode_indices(indices_data, header.triangle_count) do
+      {:ok,
+       %MoundFile{
+         header: header,
+         vertices: vertices,
+         indices: indices
+       }}
+    end
+  end
+
+  defp decode_vertices(data, point_count) do
+    vertex_size = point_count * 12
+    expected_size = point_count * 12
+
+    if byte_size(data) < expected_size do
+      {:error, :insufficient_vertex_data}
+    else
+      <<vertex_data::binary-size(vertex_size), rest::binary>> = data
+      vertices = parse_vertices(vertex_data, point_count, [])
+      {:ok, Enum.reverse(vertices), rest}
+    end
+  end
+
+  defp parse_vertices(<<>>, 0, acc), do: acc
+
+  defp parse_vertices(
+         <<x::little-float-32, y::little-float-32, z::little-float-32, rest::binary>>,
+         count,
+         acc
+       )
+       when count > 0 do
+    parse_vertices(rest, count - 1, [{x, y, z} | acc])
+  end
+
+  defp decode_indices(data, triangle_count) do
+    expected_size = triangle_count * 12
+
+    if byte_size(data) < expected_size do
+      {:error, :insufficient_index_data}
+    else
+      <<index_data::binary-size(expected_size), _rest::binary>> = data
+      indices = parse_indices(index_data, triangle_count, [])
+      {:ok, Enum.reverse(indices)}
+    end
+  end
+
+  defp parse_indices(<<>>, 0, acc), do: acc
+
+  defp parse_indices(
+         <<i1::little-unsigned-32, i2::little-unsigned-32, i3::little-unsigned-32, rest::binary>>,
+         count,
+         acc
+       )
+       when count > 0 do
+    parse_indices(rest, count - 1, [{i1, i2, i3} | acc])
+  end
+
+  @doc """
+  Get file size information without fully parsing.
+
+  Returns expected file size based on header counts.
+  """
+  @spec expected_file_size(Header.t()) :: non_neg_integer()
+  def expected_file_size(%Header{point_count: pc, triangle_count: tc}) do
+    @header_size + pc * 12 + tc * 12
+  end
+
+  @doc """
+  Validate that a file has the correct size based on its header.
+  """
+  @spec validate_file_size(Path.t()) :: {:ok, :valid} | {:error, term()}
+  def validate_file_size(path) do
+    with {:ok, %{size: actual_size}} <- File.stat(path),
+         {:ok, header} <- parse_header(path) do
+      expected = expected_file_size(header)
+
+      if actual_size == expected do
+        {:ok, :valid}
+      else
+        {:error, {:size_mismatch, expected: expected, actual: actual_size}}
+      end
+    end
+  end
+end