srn-parser 1.0.1__tar.gz

srn_parser-1.0.1/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: srn-parser
+Version: 1.0.1
+Summary: Parse Sarine .srn gemstone files and export to Wavefront OBJ
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"

srn_parser-1.0.1/README.md

@@ -0,0 +1,97 @@
+# srn-parser
+
+Parse Sarine `.srn` gemstone scan files and export to Wavefront OBJ.
+
+SRN files are produced by [Sarine Technologies](https://sarine.com/) diamond scanning systems (DiaMension, DiaScan). They contain stone metadata (weight, color, clarity, dimensions, etc.) and a 3D mesh of the scanned gemstone. The format stores geometry only — no texture coordinates, UVs, or per-face colors. Face normals are computed from the mesh geometry during export, using flat shading which is appropriate for gemstone facets. A generic gemstone material can optionally be included via `--mtl`.
+
+## Install
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install .
+```
+
+For development:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+No dependencies — pure Python stdlib. Dev extras install `ruff`, `pytest`, and `pre-commit`.
+
+## CLI Usage
+
+### View stone metadata
+
+```bash
+srn-parser info stone.srn
+srn-parser info stone.srn --json
+```
+
+### Convert to OBJ
+
+```bash
+srn-parser convert stone.srn -o output.obj
+srn-parser convert stone.srn -o output.obj --mtl          # include material file
+srn-parser convert stone.srn -o output.obj --high-res     # use high-resolution mesh
+srn-parser convert stone.srn -o output.obj --scale 0.001  # custom scale factor
+srn-parser convert stone.srn -o output.obj --no-normals   # skip normal computation
+```
+
+SRN coordinates are in micrometers. The default `--scale` of `1e-6` converts to meters.
+
+## Python API
+
+```python
+from srn_parser import parse_srn, export_obj
+
+# Parse an SRN file
+srn = parse_srn("stone.srn")
+
+# Access metadata
+print(srn.metadata.name)        # "b15306"
+print(srn.metadata.weight)      # 1.58 (carats)
+print(srn.metadata.color)       # "Blue"
+print(srn.metadata.clarity)     # "IF"
+print(srn.metadata.shape_group) # "ROUND"
+
+# Access mesh data
+print(len(srn.mesh.vertices))   # 682
+print(len(srn.mesh.faces))      # 343
+
+# High-resolution mesh (from ConcSculptorData, when available)
+if srn.high_res_mesh:
+    print(len(srn.high_res_mesh.vertices))  # 983
+
+# Export to OBJ
+export_obj(srn.mesh, "output.obj", name=srn.metadata.name)
+
+# Export with material file and custom scale
+export_obj(srn.mesh, "output.obj", name="diamond", scale=0.001, mtl=True)
+
+# Export high-res mesh
+export_obj(srn.high_res_mesh, "output_hires.obj", name="diamond_hires")
+```
+
+## SRN Format
+
+The SRN format is a proprietary binary container (SPF) with three sections:
+
+| Section | Content |
+|---------|---------|
+| `stone.hdr` | Key-value metadata (name, weight, color, clarity, dimensions, etc.) |
+| `extdata.dat` | Binary measurement data, including a high-resolution mesh (ConcSculptorData) |
+| `smesh.dat` | DirectX .X text-format 3D mesh (vertices and faces) |
+
+## Tests
+
+```bash
+pytest -v
+```
+
+## Sample Data
+
+The `samples/` directory contains an example SRN file from Sarine DiaScan measurements.

srn_parser-1.0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "srn-parser"
+version = "1.0.1"
+description = "Parse Sarine .srn gemstone files and export to Wavefront OBJ"
+requires-python = ">=3.10"
+
+[project.optional-dependencies]
+dev = ["ruff", "pytest", "pre-commit"]
+
+[project.scripts]
+srn-parser = "srn_parser.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["srn_parser*"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B", "SIM"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

srn_parser-1.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

srn_parser-1.0.1/srn_parser/__init__.py

@@ -0,0 +1,7 @@
+"""srn-parser: Parse Sarine .srn gemstone files and export to OBJ."""
+
+from .exporters.obj import export_obj
+from .models import Mesh, SRNFile, StoneMetadata
+from .parser import parse_srn
+
+__all__ = ["parse_srn", "export_obj", "SRNFile", "StoneMetadata", "Mesh"]

srn_parser-1.0.1/srn_parser/cli.py

@@ -0,0 +1,155 @@
+"""Command-line interface for srn-parser."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from .exporters.obj import export_obj
+from .parser import parse_srn
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="srn-parser",
+        description="Parse Sarine .srn gemstone files and export to OBJ.",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # info command
+    info_parser = subparsers.add_parser("info", help="Display stone metadata.")
+    info_parser.add_argument("file", type=Path, help="Path to .srn file")
+    info_parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    # convert command
+    convert_parser = subparsers.add_parser("convert", help="Convert to OBJ format.")
+    convert_parser.add_argument("file", type=Path, help="Path to .srn file")
+    convert_parser.add_argument("-o", "--output", type=Path, help="Output .obj path")
+    convert_parser.add_argument(
+        "--scale",
+        type=float,
+        default=1e-6,
+        help="Scale factor for coordinates (default: 1e-6, micrometers to meters)",
+    )
+    convert_parser.add_argument(
+        "--no-normals",
+        action="store_true",
+        help="Skip computing face normals",
+    )
+    convert_parser.add_argument(
+        "--mtl",
+        action="store_true",
+        help="Generate companion .mtl material file",
+    )
+    convert_parser.add_argument(
+        "--high-res",
+        action="store_true",
+        help="Use high-resolution ConcSculptorData mesh instead of standard mesh",
+    )
+
+    args = parser.parse_args(argv)
+
+    if not args.file.exists():
+        print(f"Error: file not found: {args.file}", file=sys.stderr)
+        sys.exit(1)
+
+    srn = parse_srn(args.file)
+
+    if args.command == "info":
+        _cmd_info(srn, as_json=args.json)
+    elif args.command == "convert":
+        _cmd_convert(srn, args)
+
+
+def _cmd_info(srn, *, as_json: bool) -> None:
+    m = srn.metadata
+    data = {
+        "name": m.name,
+        "date": m.date.isoformat() if m.date else None,
+        "weight_ct": m.weight,
+        "measured_weight_ct": m.measured_weight,
+        "price": m.price,
+        "shape": m.shape_name,
+        "shape_group": m.shape_group,
+        "color": m.color,
+        "clarity": m.clarity,
+        "width_mm": m.width,
+        "length_mm": m.length,
+        "height_mm": m.height,
+        "polish": m.polish or None,
+        "symmetry": m.symmetry or None,
+        "fluorescence": m.fluorescence or None,
+        "certificate": m.certificate_num or None,
+        "lab": m.associated_lab or None,
+        "measure_date": m.measure_date.isoformat() if m.measure_date else None,
+        "measure_mode": m.measure_mode,
+        "mesh_vertices": len(srn.mesh.vertices),
+        "mesh_faces": len(srn.mesh.faces),
+        "high_res_vertices": len(srn.high_res_mesh.vertices) if srn.high_res_mesh else None,
+        "high_res_faces": len(srn.high_res_mesh.faces) if srn.high_res_mesh else None,
+    }
+
+    if as_json:
+        print(json.dumps(data, indent=2))
+    else:
+        print(f"Stone: {m.name}")
+        print(f"Shape: {m.shape_name} ({m.shape_group})")
+        print(f"Weight: {m.weight} ct")
+        if m.measured_weight is not None:
+            print(f"Measured weight: {m.measured_weight} ct")
+        if m.price is not None:
+            print(f"Price: ${m.price:.2f}")
+        print(f"Color: {m.color}")
+        print(f"Clarity: {m.clarity}")
+        print(f"Dimensions: {m.width:.3f} x {m.length:.3f} x {m.height:.3f} mm")
+        if m.polish:
+            print(f"Polish: {m.polish}")
+        if m.symmetry:
+            print(f"Symmetry: {m.symmetry}")
+        if m.fluorescence:
+            print(f"Fluorescence: {m.fluorescence}")
+        if m.certificate_num:
+            print(f"Certificate: {m.certificate_num}")
+        if m.associated_lab:
+            print(f"Lab: {m.associated_lab}")
+        print(f"Measure mode: {m.measure_mode}")
+        if m.date:
+            print(f"Date: {m.date.strftime('%Y-%m-%d %H:%M:%S UTC')}")
+        print(f"Mesh: {len(srn.mesh.vertices)} vertices, {len(srn.mesh.faces)} faces")
+        if srn.high_res_mesh:
+            print(
+                f"High-res mesh: {len(srn.high_res_mesh.vertices)} vertices, "
+                f"{len(srn.high_res_mesh.faces)} faces"
+            )
+
+
+def _cmd_convert(srn, args) -> None:
+    mesh = srn.mesh
+    if args.high_res:
+        if srn.high_res_mesh is None:
+            print("Error: no high-resolution mesh available in this file", file=sys.stderr)
+            sys.exit(1)
+        mesh = srn.high_res_mesh
+
+    output = args.output
+    if output is None:
+        output = Path(srn.metadata.name or "stone").with_suffix(".obj")
+
+    export_obj(
+        mesh,
+        output,
+        name=srn.metadata.name or "stone",
+        scale=args.scale,
+        normals=not args.no_normals,
+        mtl=args.mtl,
+    )
+
+    print(f"Exported {len(mesh.vertices)} vertices, {len(mesh.faces)} faces -> {output}")
+    if args.mtl:
+        print(f"Material file -> {output.with_suffix('.mtl')}")
+
+
+if __name__ == "__main__":
+    main()

srn_parser-1.0.1/srn_parser/directx.py

@@ -0,0 +1,65 @@
+"""Parser for DirectX .X text format meshes (as found in smesh.dat sections)."""
+
+from __future__ import annotations
+
+from .models import Mesh
+
+
+def parse_directx_mesh(text: str) -> Mesh:
+    """Parse a DirectX .X text-format mesh into a Mesh object.
+
+    Expects the standard format:
+        xof 0303txt 0032
+        Header { ... }
+        Mesh { vertex_count; vertices...; face_count; faces...; }
+    """
+    right_handed = "RightHanded" in text
+
+    # Extract the Mesh { ... } block content
+    mesh_start = text.index("Mesh {")
+    # Find the matching closing brace - need to handle nested braces
+    brace_depth = 0
+    mesh_body_start = text.index("{", mesh_start) + 1
+    pos = mesh_body_start
+    while pos < len(text):
+        if text[pos] == "{":
+            brace_depth += 1
+        elif text[pos] == "}":
+            if brace_depth == 0:
+                break
+            brace_depth -= 1
+        pos += 1
+    mesh_body = text[mesh_body_start:pos]
+
+    # Split on ;; which separates the four main parts:
+    # vertex_count; vertices;; face_count; faces;;
+    # But we need to be careful - split by ";\n" after stripping
+    lines = mesh_body.strip().split(";\n")
+
+    vertex_count = int(lines[0].strip())
+    face_count = int(lines[2].strip())
+
+    # Parse vertices: "x;y;z;," separated by ",\n" (last ends without comma)
+    vertex_block = lines[1].strip()
+    vertices: list[tuple[float, float, float]] = []
+    for entry in vertex_block.split(",\n"):
+        entry = entry.strip().rstrip(",")
+        parts = [p for p in entry.split(";") if p.strip()]
+        if len(parts) >= 3:
+            vertices.append((float(parts[0]), float(parts[1]), float(parts[2])))
+
+    # Parse faces: "n;i0,i1,...;," separated by ",\n" (last ends without comma)
+    face_block = lines[3].strip()
+    faces: list[tuple[int, ...]] = []
+    for entry in face_block.split(",\n"):
+        entry = entry.strip().rstrip(",")
+        parts = entry.split(";")
+        # parts[0] = vertex count for this face, parts[1] = comma-separated indices
+        if len(parts) >= 2 and parts[1].strip():
+            indices = tuple(int(i) for i in parts[1].strip().split(",") if i.strip())
+            faces.append(indices)
+
+    assert len(vertices) == vertex_count, f"Expected {vertex_count} vertices, got {len(vertices)}"
+    assert len(faces) == face_count, f"Expected {face_count} faces, got {len(faces)}"
+
+    return Mesh(vertices=vertices, faces=faces, right_handed=right_handed)

srn_parser-1.0.1/srn_parser/exporters/obj.py

@@ -0,0 +1,129 @@
+"""Wavefront OBJ exporter for SRN mesh data."""
+
+from __future__ import annotations
+
+import math
+from pathlib import Path
+
+from ..models import Mesh
+
+Vec3 = tuple[float, float, float]
+
+
+def _cross(a: Vec3, b: Vec3) -> Vec3:
+    return (
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[0],
+    )
+
+
+def _sub(a: Vec3, b: Vec3) -> Vec3:
+    return (a[0] - b[0], a[1] - b[1], a[2] - b[2])
+
+
+def _normalize(v: Vec3) -> Vec3:
+    length = math.sqrt(v[0] ** 2 + v[1] ** 2 + v[2] ** 2)
+    if length < 1e-12:
+        return (0.0, 0.0, 1.0)
+    return (v[0] / length, v[1] / length, v[2] / length)
+
+
+def compute_face_normals(
+    mesh: Mesh,
+) -> list[tuple[float, float, float]]:
+    """Compute one flat normal per face using the cross product of the first two edges."""
+    normals: list[tuple[float, float, float]] = []
+    for face in mesh.faces:
+        if len(face) < 3:
+            normals.append((0.0, 0.0, 1.0))
+            continue
+        v0 = mesh.vertices[face[0]]
+        v1 = mesh.vertices[face[1]]
+        v2 = mesh.vertices[face[2]]
+        edge1 = _sub(v1, v0)
+        edge2 = _sub(v2, v0)
+        normal = _normalize(_cross(edge1, edge2))
+        normals.append(normal)
+    return normals
+
+
+def export_obj(
+    mesh: Mesh,
+    path: str | Path,
+    *,
+    name: str = "stone",
+    scale: float = 1e-6,
+    normals: bool = True,
+    mtl: bool = False,
+) -> None:
+    """Export a Mesh to Wavefront OBJ format.
+
+    Args:
+        mesh: The mesh to export.
+        path: Output .obj file path.
+        name: Object name written to the OBJ header.
+        scale: Scale factor applied to vertex coordinates.
+               SRN coordinates are in micrometers; default 1e-6 converts to meters.
+        normals: If True, compute and write per-face normals (flat shading).
+        mtl: If True, write a companion .mtl file with a basic gemstone material.
+    """
+    path = Path(path)
+
+    face_normals = compute_face_normals(mesh) if normals else []
+
+    mtl_name = path.stem + ".mtl" if mtl else None
+
+    lines: list[str] = []
+    lines.append(f"# SRN Parser - {name}")
+    if mtl_name:
+        lines.append(f"mtllib {mtl_name}")
+    lines.append(f"o {name}")
+    lines.append("")
+
+    # Vertices
+    for v in mesh.vertices:
+        lines.append(f"v {v[0] * scale:.6f} {v[1] * scale:.6f} {v[2] * scale:.6f}")
+
+    # Normals
+    if face_normals:
+        lines.append("")
+        for n in face_normals:
+            lines.append(f"vn {n[0]:.6f} {n[1]:.6f} {n[2]:.6f}")
+
+    lines.append("")
+    if mtl_name:
+        lines.append("usemtl gemstone")
+    lines.append("s off")
+
+    # Faces (1-based indexing)
+    for i, face in enumerate(mesh.faces):
+        if face_normals:
+            ni = i + 1  # 1-based normal index
+            indices = " ".join(f"{idx + 1}//{ni}" for idx in face)
+        else:
+            indices = " ".join(str(idx + 1) for idx in face)
+        lines.append(f"f {indices}")
+
+    lines.append("")
+    path.write_text("\n".join(lines))
+
+    if mtl:
+        _write_mtl(path.with_suffix(".mtl"))
+
+
+def _write_mtl(path: Path) -> None:
+    """Write a basic gemstone material file."""
+    lines = [
+        "# SRN Parser - gemstone material",
+        "newmtl gemstone",
+        "Ka 0.100000 0.100000 0.100000",
+        "Kd 0.800000 0.800000 0.800000",
+        "Ks 1.000000 1.000000 1.000000",
+        "Ns 200.000000",
+        "Ni 2.420000",
+        "d 0.950000",
+        "illum 2",
+        "",
+    ]
+    path.write_text("\n".join(lines))

srn_parser-1.0.1/srn_parser/models.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class StoneMetadata:
+    name: str = ""
+    date: datetime | None = None
+    weight: float = 0.0
+    measured_weight: float | None = None
+    price: float | None = None
+    shape_name: str = ""
+    shape_group: str = ""
+    color: str = ""
+    clarity: str = ""
+    width: float = 0.0
+    length: float = 0.0
+    height: float = 0.0
+    polish: str = ""
+    symmetry: str = ""
+    fluorescence: str = ""
+    certificate_num: str = ""
+    associated_lab: str = ""
+    measure_date: datetime | None = None
+    measure_mode: str = ""
+
+
+@dataclass
+class Mesh:
+    vertices: list[tuple[float, float, float]]
+    faces: list[tuple[int, ...]]
+    right_handed: bool = True
+
+
+@dataclass
+class SRNFile:
+    metadata: StoneMetadata
+    mesh: Mesh
+    high_res_mesh: Mesh | None = None
+    ext_data: bytes = b""

srn_parser-1.0.1/srn_parser/parser.py

@@ -0,0 +1,170 @@
+"""Parser for Sarine .srn (SPF container) files."""
+
+from __future__ import annotations
+
+import struct
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .directx import parse_directx_mesh
+from .models import Mesh, SRNFile, StoneMetadata
+
+SPF_MAGIC = b"SPF "
+
+
+def parse_srn(path: str | Path) -> SRNFile:
+    """Parse a .srn file and return an SRNFile object."""
+    path = Path(path)
+    with open(path, "rb") as f:
+        data = f.read()
+    return _parse_container(data)
+
+
+def _parse_container(data: bytes) -> SRNFile:
+    """Parse the SPF binary container."""
+    # Validate magic
+    if not data.startswith(SPF_MAGIC):
+        raise ValueError(f"Not an SRN file: expected magic {SPF_MAGIC!r}, got {data[:4]!r}")
+
+    # Header: 20 bytes magic string + 12 bytes unknown + 4 bytes section count
+    offset = 20 + 12
+    (section_count,) = struct.unpack_from("<I", data, offset)
+    offset += 4
+
+    sections: dict[str, bytes] = {}
+    for _ in range(section_count):
+        (data_size,) = struct.unpack_from("<I", data, offset)
+        offset += 4
+        (name_len,) = struct.unpack_from("<I", data, offset)
+        offset += 4
+        name = data[offset : offset + name_len].decode("ascii")
+        offset += name_len
+        section_data = data[offset : offset + data_size]
+        offset += data_size
+        sections[name] = section_data
+
+    # Parse metadata from stone.hdr
+    metadata = StoneMetadata()
+    if "stone.hdr" in sections:
+        metadata = _parse_metadata(sections["stone.hdr"])
+
+    # Parse mesh from smesh.dat
+    mesh = Mesh(vertices=[], faces=[])
+    if "smesh.dat" in sections:
+        text = sections["smesh.dat"].decode("ISO-8859-1")
+        mesh = parse_directx_mesh(text)
+
+    # Store raw extdata and try to extract high-res mesh
+    ext_data = sections.get("extdata.dat", b"")
+    high_res_mesh = _try_parse_conc_sculptor(ext_data)
+
+    return SRNFile(
+        metadata=metadata,
+        mesh=mesh,
+        high_res_mesh=high_res_mesh,
+        ext_data=ext_data,
+    )
+
+
+def _parse_metadata(data: bytes) -> StoneMetadata:
+    """Parse the stone.hdr section (INI-style key=value pairs)."""
+    text = data.decode("ISO-8859-1")
+
+    # Strip the [data] prefix
+    if "[data]" in text:
+        text = text.split("[data]", 1)[1]
+
+    kvs: dict[str, str] = {}
+    for line in text.split("\r\n"):
+        line = line.strip()
+        if "=" in line:
+            key, _, value = line.partition("=")
+            kvs[key.strip()] = value.strip()
+
+    def _parse_timestamp(val: str) -> datetime | None:
+        if not val:
+            return None
+        try:
+            return datetime.fromtimestamp(int(val), tz=timezone.utc)
+        except (ValueError, OSError):
+            return None
+
+    def _parse_float(val: str) -> float:
+        if not val:
+            return 0.0
+        try:
+            return float(val)
+        except ValueError:
+            return 0.0
+
+    # stoneWeight can be "carat_weight,measured_weight"
+    weight = 0.0
+    measured_weight = None
+    weight_str = kvs.get("stoneWeight", "")
+    if "," in weight_str:
+        parts = weight_str.split(",")
+        weight = _parse_float(parts[0])
+        measured_weight = _parse_float(parts[1])
+    else:
+        weight = _parse_float(weight_str)
+
+    price_val = kvs.get("stonePrice", "")
+
+    return StoneMetadata(
+        name=kvs.get("stoneName", ""),
+        date=_parse_timestamp(kvs.get("stoneDate", "")),
+        weight=weight,
+        measured_weight=measured_weight,
+        price=_parse_float(price_val) if price_val else None,
+        shape_name=kvs.get("shapeName", ""),
+        shape_group=kvs.get("shapeGroup", ""),
+        color=kvs.get("stoneColor", ""),
+        clarity=kvs.get("stoneClarity", ""),
+        width=_parse_float(kvs.get("stoneWidth", "")),
+        length=_parse_float(kvs.get("stoneLength", "")),
+        height=_parse_float(kvs.get("stoneHeight", "")),
+        polish=kvs.get("stonePolish", ""),
+        symmetry=kvs.get("stoneSymmetry", ""),
+        fluorescence=kvs.get("stoneFluorescence", ""),
+        certificate_num=kvs.get("stoneCertificateNum", ""),
+        associated_lab=kvs.get("StoneAssociatedLab", ""),
+        measure_date=_parse_timestamp(kvs.get("stoneMeasureDate", "")),
+        measure_mode=kvs.get("StoneMeasureMode", ""),
+    )
+
+
+def _try_parse_conc_sculptor(ext_data: bytes) -> Mesh | None:
+    """Try to extract a high-resolution mesh from the ConcSculptorData section."""
+    marker = b"ConcSculptorData"
+    idx = ext_data.find(marker)
+    if idx < 0:
+        return None
+
+    try:
+        offset = idx + len(marker)
+        # Header: uint32 unknown (=2), uint32 vertex_count
+        (_unknown, vertex_count) = struct.unpack_from("<II", ext_data, offset)
+        offset += 8
+
+        # Read vertex_count * 3 doubles (XYZ)
+        vertices: list[tuple[float, float, float]] = []
+        for _ in range(vertex_count):
+            x, y, z = struct.unpack_from("<ddd", ext_data, offset)
+            vertices.append((x, y, z))
+            offset += 24
+
+        # Read face data: uint32 face_count, then faces
+        (face_count,) = struct.unpack_from("<I", ext_data, offset)
+        offset += 4
+
+        faces: list[tuple[int, ...]] = []
+        for _ in range(face_count):
+            (n_verts,) = struct.unpack_from("<I", ext_data, offset)
+            offset += 4
+            indices = struct.unpack_from(f"<{n_verts}I", ext_data, offset)
+            faces.append(tuple(indices))
+            offset += n_verts * 4
+
+        return Mesh(vertices=vertices, faces=faces, right_handed=True)
+    except (struct.error, IndexError, OverflowError):
+        return None

srn_parser-1.0.1/srn_parser.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: srn-parser
+Version: 1.0.1
+Summary: Parse Sarine .srn gemstone files and export to Wavefront OBJ
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"

srn_parser-1.0.1/srn_parser.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+srn_parser/__init__.py
+srn_parser/cli.py
+srn_parser/directx.py
+srn_parser/models.py
+srn_parser/parser.py
+srn_parser.egg-info/PKG-INFO
+srn_parser.egg-info/SOURCES.txt
+srn_parser.egg-info/dependency_links.txt
+srn_parser.egg-info/entry_points.txt
+srn_parser.egg-info/requires.txt
+srn_parser.egg-info/top_level.txt
+srn_parser/exporters/__init__.py
+srn_parser/exporters/obj.py
+tests/test_cli.py
+tests/test_directx.py
+tests/test_obj_exporter.py
+tests/test_parser.py

srn_parser-1.0.1/srn_parser.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

srn_parser-1.0.1/srn_parser.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+srn-parser = srn_parser.cli:main

srn_parser-1.0.1/srn_parser.egg-info/requires.txt

@@ -0,0 +1,5 @@
+
+[dev]
+ruff
+pytest
+pre-commit

srn_parser-1.0.1/srn_parser.egg-info/top_level.txt

@@ -0,0 +1 @@
+srn_parser

srn_parser-1.0.1/tests/test_cli.py

@@ -0,0 +1,73 @@
+"""Tests for the CLI interface."""
+
+import json
+
+import pytest
+
+from srn_parser.cli import main
+
+
+class TestInfoCommand:
+    def test_info_output(self, sample_b15924, capsys):
+        main(["info", str(sample_b15924)])
+        output = capsys.readouterr().out
+        assert "b15924" in output
+        assert "ROUND" in output
+        assert "1.11 ct" in output
+        assert "Blue" in output
+        assert "IF" in output
+        assert "880 vertices" in output
+
+    def test_info_json(self, sample_b15924, capsys):
+        main(["info", str(sample_b15924), "--json"])
+        output = capsys.readouterr().out
+        data = json.loads(output)
+        assert data["name"] == "b15924"
+        assert data["weight_ct"] == 1.11
+        assert data["mesh_vertices"] == 880
+        assert data["mesh_faces"] == 442
+        assert data["high_res_vertices"] == 912
+
+    def test_info_missing_file(self, tmp_path):
+        with pytest.raises(SystemExit):
+            main(["info", str(tmp_path / "nonexistent.srn")])
+
+
+class TestConvertCommand:
+    def test_convert_creates_obj(self, sample_b15924, tmp_path):
+        out = tmp_path / "out.obj"
+        main(["convert", str(sample_b15924), "-o", str(out)])
+        assert out.exists()
+        content = out.read_text()
+        assert content.startswith("# SRN Parser")
+
+    def test_convert_default_filename(self, sample_b15924, capsys):
+        main(["convert", str(sample_b15924)])
+        output = capsys.readouterr().out
+        assert "b15924.obj" in output
+
+    def test_convert_with_mtl(self, sample_b15924, tmp_path):
+        out = tmp_path / "out.obj"
+        main(["convert", str(sample_b15924), "-o", str(out), "--mtl"])
+        assert out.exists()
+        assert (tmp_path / "out.mtl").exists()
+
+    def test_convert_high_res(self, sample_b15924, tmp_path, capsys):
+        out = tmp_path / "out.obj"
+        main(["convert", str(sample_b15924), "-o", str(out), "--high-res"])
+        output = capsys.readouterr().out
+        assert "912 vertices" in output
+
+    def test_convert_no_normals(self, sample_b15924, tmp_path):
+        out = tmp_path / "out.obj"
+        main(["convert", str(sample_b15924), "-o", str(out), "--no-normals"])
+        content = out.read_text()
+        assert "vn " not in content
+
+    def test_convert_custom_scale(self, sample_b15924, tmp_path):
+        out = tmp_path / "out.obj"
+        main(["convert", str(sample_b15924), "-o", str(out), "--scale", "0.001"])
+        content = out.read_text()
+        v_line = [ln for ln in content.splitlines() if ln.startswith("v ")][0]
+        x = float(v_line.split()[1])
+        assert abs(x) > 0.01  # much larger than default 1e-6 scale

srn_parser-1.0.1/tests/test_directx.py

@@ -0,0 +1,94 @@
+"""Tests for the DirectX .X text mesh parser."""
+
+import pytest
+
+from srn_parser.directx import parse_directx_mesh
+from srn_parser.models import Mesh
+
+MINIMAL_MESH = """\
+xof 0303txt 0032
+
+Header {
+ 1;
+ 0;
+ 1;
+}
+
+Mesh {
+ 4;
+ 0.0;0.0;0.0;,
+ 1.0;0.0;0.0;,
+ 1.0;1.0;0.0;,
+ 0.0;1.0;0.0;;
+ 2;
+ 3;0,1,2;,
+ 3;0,2,3;;
+
+ RightHanded {
+  1;
+ }
+}
+"""
+
+MESH_NO_RIGHT_HANDED = """\
+xof 0303txt 0032
+
+Header {
+ 1;
+ 0;
+ 1;
+}
+
+Mesh {
+ 3;
+ 0.0;0.0;0.0;,
+ 1.0;0.0;0.0;,
+ 0.5;1.0;0.0;;
+ 1;
+ 3;0,1,2;;
+}
+"""
+
+
+class TestParseDirectXMesh:
+    def test_minimal_mesh(self):
+        mesh = parse_directx_mesh(MINIMAL_MESH)
+        assert isinstance(mesh, Mesh)
+        assert len(mesh.vertices) == 4
+        assert len(mesh.faces) == 2
+
+    def test_vertex_values(self):
+        mesh = parse_directx_mesh(MINIMAL_MESH)
+        assert mesh.vertices[0] == (0.0, 0.0, 0.0)
+        assert mesh.vertices[1] == (1.0, 0.0, 0.0)
+        assert mesh.vertices[2] == (1.0, 1.0, 0.0)
+        assert mesh.vertices[3] == (0.0, 1.0, 0.0)
+
+    def test_face_indices(self):
+        mesh = parse_directx_mesh(MINIMAL_MESH)
+        assert mesh.faces[0] == (0, 1, 2)
+        assert mesh.faces[1] == (0, 2, 3)
+
+    def test_right_handed_flag(self):
+        mesh = parse_directx_mesh(MINIMAL_MESH)
+        assert mesh.right_handed is True
+
+    def test_no_right_handed(self):
+        mesh = parse_directx_mesh(MESH_NO_RIGHT_HANDED)
+        assert mesh.right_handed is False
+        assert len(mesh.vertices) == 3
+        assert len(mesh.faces) == 1
+
+    def test_missing_mesh_block_raises(self):
+        with pytest.raises(ValueError):
+            parse_directx_mesh("xof 0303txt 0032\nHeader { 1; 0; 1; }")
+
+    def test_quad_faces(self):
+        mesh = parse_directx_mesh(MINIMAL_MESH)
+        # Second face has 3 vertices (both are triangles in this test)
+        assert all(len(f) == 3 for f in mesh.faces)
+
+    def test_negative_coords(self):
+        text = MINIMAL_MESH.replace("0.0;0.0;0.0", "-1.5;-2.5;-3.5")
+        mesh = parse_directx_mesh(text)
+        assert mesh.vertices[0] == (-1.5, -2.5, -3.5)

srn_parser-1.0.1/tests/test_obj_exporter.py

@@ -0,0 +1,177 @@
+"""Tests for the Wavefront OBJ exporter."""
+
+import math
+
+import pytest
+
+from srn_parser.exporters.obj import compute_face_normals, export_obj
+from srn_parser.models import Mesh
+
+
+@pytest.fixture
+def triangle_mesh():
+    """A single triangle in the XY plane."""
+    return Mesh(
+        vertices=[(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0)],
+        faces=[(0, 1, 2)],
+    )
+
+
+@pytest.fixture
+def quad_mesh():
+    """A quad (two-triangle square) in the XY plane."""
+    return Mesh(
+        vertices=[
+            (0.0, 0.0, 0.0),
+            (1.0, 0.0, 0.0),
+            (1.0, 1.0, 0.0),
+            (0.0, 1.0, 0.0),
+        ],
+        faces=[(0, 1, 2, 3)],
+    )
+
+
+class TestComputeFaceNormals:
+    def test_xy_plane_normal_points_z(self, triangle_mesh):
+        normals = compute_face_normals(triangle_mesh)
+        assert len(normals) == 1
+        nx, ny, nz = normals[0]
+        assert abs(nx) < 1e-9
+        assert abs(ny) < 1e-9
+        assert abs(nz - 1.0) < 1e-9
+
+    def test_xz_plane_normal(self):
+        mesh = Mesh(
+            vertices=[(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 0.0, 1.0)],
+            faces=[(0, 1, 2)],
+        )
+        normals = compute_face_normals(mesh)
+        nx, ny, nz = normals[0]
+        assert abs(nx) < 1e-9
+        assert abs(ny - (-1.0)) < 1e-9
+        assert abs(nz) < 1e-9
+
+    def test_normals_are_unit_length(self, triangle_mesh):
+        normals = compute_face_normals(triangle_mesh)
+        for n in normals:
+            length = math.sqrt(n[0] ** 2 + n[1] ** 2 + n[2] ** 2)
+            assert abs(length - 1.0) < 1e-9
+
+    def test_quad_normal(self, quad_mesh):
+        normals = compute_face_normals(quad_mesh)
+        assert len(normals) == 1
+        assert abs(normals[0][2] - 1.0) < 1e-9
+
+    def test_degenerate_face_returns_default(self):
+        mesh = Mesh(
+            vertices=[(0.0, 0.0, 0.0), (0.0, 0.0, 0.0), (0.0, 0.0, 0.0)],
+            faces=[(0, 1, 2)],
+        )
+        normals = compute_face_normals(mesh)
+        length = math.sqrt(sum(c**2 for c in normals[0]))
+        assert abs(length - 1.0) < 1e-9
+
+
+class TestExportOBJ:
+    def test_creates_file(self, triangle_mesh, tmp_path):
+        out = tmp_path / "test.obj"
+        export_obj(triangle_mesh, out, name="test")
+        assert out.exists()
+        content = out.read_text()
+        assert "o test" in content
+
+    def test_vertex_count(self, triangle_mesh, tmp_path):
+        out = tmp_path / "test.obj"
+        export_obj(triangle_mesh, out)
+        content = out.read_text()
+        v_lines = [ln for ln in content.splitlines() if ln.startswith("v ")]
+        assert len(v_lines) == 3
+
+    def test_face_count(self, triangle_mesh, tmp_path):
+        out = tmp_path / "test.obj"
+        export_obj(triangle_mesh, out)
+        content = out.read_text()
+        f_lines = [ln for ln in content.splitlines() if ln.startswith("f ")]
+        assert len(f_lines) == 1
+
+    def test_normals_present_by_default(self, triangle_mesh, tmp_path):
+        out = tmp_path / "test.obj"
+        export_obj(triangle_mesh, out)
+        content = out.read_text()
+        vn_lines = [ln for ln in content.splitlines() if ln.startswith("vn ")]
+        assert len(vn_lines) == 1
+        f_lines = [ln for ln in content.splitlines() if ln.startswith("f ")]
+        assert "//" in f_lines[0]
+
+    def test_no_normals_option(self, triangle_mesh, tmp_path):
+        out = tmp_path / "test.obj"
+        export_obj(triangle_mesh, out, normals=False)
+        content = out.read_text()
+        vn_lines = [ln for ln in content.splitlines() if ln.startswith("vn ")]
+        assert len(vn_lines) == 0
+        f_lines = [ln for ln in content.splitlines() if ln.startswith("f ")]
+        assert "//" not in f_lines[0]
+
+    def test_scale_factor(self, triangle_mesh, tmp_path):
+        out = tmp_path / "test.obj"
+        export_obj(triangle_mesh, out, scale=2.0, normals=False)
+        content = out.read_text()
+        v_lines = [ln for ln in content.splitlines() if ln.startswith("v ")]
+        parts = v_lines[1].split()
+        assert float(parts[1]) == pytest.approx(2.0)
+
+    def test_one_based_indexing(self, triangle_mesh, tmp_path):
+        out = tmp_path / "test.obj"
+        export_obj(triangle_mesh, out, normals=False)
+        content = out.read_text()
+        f_lines = [ln for ln in content.splitlines() if ln.startswith("f ")]
+        indices = f_lines[0].split()[1:]
+        assert indices == ["1", "2", "3"]
+
+    def test_mtl_file_created(self, triangle_mesh, tmp_path):
+        out = tmp_path / "test.obj"
+        export_obj(triangle_mesh, out, mtl=True)
+        mtl_path = tmp_path / "test.mtl"
+        assert mtl_path.exists()
+        content = mtl_path.read_text()
+        assert "newmtl gemstone" in content
+        assert "Ni 2.420000" in content
+
+    def test_mtl_referenced_in_obj(self, triangle_mesh, tmp_path):
+        out = tmp_path / "test.obj"
+        export_obj(triangle_mesh, out, mtl=True)
+        content = out.read_text()
+        assert "mtllib test.mtl" in content
+        assert "usemtl gemstone" in content
+
+    def test_flat_shading(self, triangle_mesh, tmp_path):
+        out = tmp_path / "test.obj"
+        export_obj(triangle_mesh, out)
+        content = out.read_text()
+        assert "s off" in content
+
+
+class TestExportFromSampleFiles:
+    def test_export_b15924(self, sample_b15924, tmp_path):
+        from srn_parser import export_obj, parse_srn
+
+        srn = parse_srn(sample_b15924)
+        out = tmp_path / "b15924.obj"
+        export_obj(srn.mesh, out, name=srn.metadata.name)
+        content = out.read_text()
+        v_lines = [ln for ln in content.splitlines() if ln.startswith("v ")]
+        f_lines = [ln for ln in content.splitlines() if ln.startswith("f ")]
+        vn_lines = [ln for ln in content.splitlines() if ln.startswith("vn ")]
+        assert len(v_lines) == 880
+        assert len(f_lines) == 442
+        assert len(vn_lines) == 442
+
+    def test_export_high_res(self, sample_b15924, tmp_path):
+        from srn_parser import export_obj, parse_srn
+
+        srn = parse_srn(sample_b15924)
+        out = tmp_path / "hires.obj"
+        export_obj(srn.high_res_mesh, out)
+        content = out.read_text()
+        v_lines = [ln for ln in content.splitlines() if ln.startswith("v ")]
+        assert len(v_lines) == 912

srn_parser-1.0.1/tests/test_parser.py

@@ -0,0 +1,112 @@
+"""Tests for the SRN binary container parser."""
+
+import pytest
+
+from srn_parser.models import Mesh, SRNFile, StoneMetadata
+from srn_parser.parser import _parse_metadata, parse_srn
+
+
+class TestParseSRN:
+    def test_parses_b15924(self, sample_b15924):
+        srn = parse_srn(sample_b15924)
+        assert isinstance(srn, SRNFile)
+        assert isinstance(srn.metadata, StoneMetadata)
+        assert isinstance(srn.mesh, Mesh)
+
+    def test_rejects_invalid_magic(self, tmp_path):
+        bad_file = tmp_path / "bad.srn"
+        bad_file.write_bytes(b"NOT AN SRN FILE")
+        with pytest.raises(ValueError, match="Not an SRN file"):
+            parse_srn(bad_file)
+
+
+class TestMetadata:
+    def test_b15924_metadata(self, sample_b15924):
+        srn = parse_srn(sample_b15924)
+        m = srn.metadata
+        assert m.name == "b15924"
+        assert m.weight == 1.11
+        assert m.shape_name == "ROUND-P11-P11"
+        assert m.shape_group == "ROUND"
+        assert m.color == "Blue"
+        assert m.clarity == "IF"
+        assert m.width == pytest.approx(1.11)
+        assert m.length == pytest.approx(6.02)
+        assert m.height == pytest.approx(3.899)
+        assert m.measure_mode == "Fastest"
+
+    def test_date_parsing(self, sample_b15924):
+        srn = parse_srn(sample_b15924)
+        assert srn.metadata.date is not None
+        assert srn.metadata.date.year == 2022
+
+    def test_empty_optional_fields(self, sample_b15924):
+        srn = parse_srn(sample_b15924)
+        assert srn.metadata.polish == ""
+        assert srn.metadata.symmetry == ""
+        assert srn.metadata.fluorescence == ""
+        assert srn.metadata.certificate_num == ""
+
+    def test_parse_metadata_handles_missing_keys(self):
+        data = b"[data]\r\nstoneName=test\r\n"
+        m = _parse_metadata(data)
+        assert m.name == "test"
+        assert m.weight == 0.0
+        assert m.price is None
+        assert m.date is None
+
+
+class TestMesh:
+    def test_b15924_mesh_counts(self, sample_b15924):
+        srn = parse_srn(sample_b15924)
+        assert len(srn.mesh.vertices) == 880
+        assert len(srn.mesh.faces) == 442
+
+    def test_vertices_are_3d_tuples(self, sample_b15924):
+        srn = parse_srn(sample_b15924)
+        for v in srn.mesh.vertices:
+            assert len(v) == 3
+            assert all(isinstance(c, float) for c in v)
+
+    def test_face_indices_in_range(self, sample_b15924):
+        srn = parse_srn(sample_b15924)
+        n_verts = len(srn.mesh.vertices)
+        for face in srn.mesh.faces:
+            assert len(face) >= 3
+            for idx in face:
+                assert 0 <= idx < n_verts
+
+    def test_right_handed(self, sample_b15924):
+        srn = parse_srn(sample_b15924)
+        assert srn.mesh.right_handed is True
+
+
+class TestHighResMesh:
+    def test_b15924_high_res_exists(self, sample_b15924):
+        srn = parse_srn(sample_b15924)
+        assert srn.high_res_mesh is not None
+        assert len(srn.high_res_mesh.vertices) == 912
+        assert len(srn.high_res_mesh.faces) == 458
+
+    def test_high_res_more_detail(self, sample_b15924):
+        srn = parse_srn(sample_b15924)
+        assert len(srn.high_res_mesh.vertices) > len(srn.mesh.vertices)
+        assert len(srn.high_res_mesh.faces) > len(srn.mesh.faces)
+
+    def test_high_res_indices_in_range(self, sample_b15924):
+        srn = parse_srn(sample_b15924)
+        n_verts = len(srn.high_res_mesh.vertices)
+        for face in srn.high_res_mesh.faces:
+            assert len(face) >= 3
+            for idx in face:
+                assert 0 <= idx < n_verts
+
+
+class TestExtData:
+    def test_ext_data_present(self, sample_b15924):
+        srn = parse_srn(sample_b15924)
+        assert len(srn.ext_data) > 0
+
+    def test_ext_data_contains_conc_sculptor(self, sample_b15924):
+        srn = parse_srn(sample_b15924)
+        assert b"ConcSculptorData" in srn.ext_data