unicad-kit 0.1.0__py3-none-any.whl

convert/adapters/freecad/EditShape/Prism/PrismProof.py

@@ -0,0 +1,111 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+
+from dataclasses import dataclass as MakeDataClass, field as DataField
+
+from convert.adapters.freecad.EditShape.CylinderRims import (
+    IsNearPoint,
+    KPositionTolerance,
+)
+from convert.adapters.freecad.EditShape.Prism.PrismExpected import ExpectedPrism
+from convert.adapters.freecad.EditShape.Prism.PrismRaw import KLocationChain, PrismRaw
+from convert.geometry.Opencascade import (
+    DecodeFailure,
+    EdgeData,
+    LocationPoint,
+    Reference,
+    VertexData,
+)
+from convert.geometry.Revolve.SweepVector import OffsetVector
+from interchange.brep.curves.BrepCurves import LineCurve
+
+# the same native record at another location is a different topological instance
+KPlacedKey = tuple[int, KLocationChain]
+
+
+# a bijection prevents geometric coincidence from hiding split vertices and duplicated edges
+@MakeDataClass(slots=True)
+class PrismProof:
+    RawValue: PrismRaw
+    Expected: ExpectedPrism
+    Vertices: dict[KPlacedKey, int] = DataField(default_factory=dict[KPlacedKey, int])
+    Edges: dict[KPlacedKey, tuple[int, int]] = DataField(
+        default_factory=dict[KPlacedKey, tuple[int, int]]
+    )
+
+
+# each placed native vertex must resolve exactly one expected ring corner
+def ReadVertexMut(
+    Proof: PrismProof, RefValue: Reference, Parent: KLocationChain
+) -> int:
+    ChainValue = Proof.RawValue.Place(RefValue, Parent)
+    VertexKey = (RefValue.RecordA, ChainValue)
+    if VertexKey not in Proof.Vertices:
+        Record = Proof.RawValue.Records[RefValue.RecordA].GeometryA
+        if not isinstance(Record, VertexData) or Record.Tolerance > KPositionTolerance:
+            raise DecodeFailure("invalid prism vertex")
+        World = LocationPoint(Proof.RawValue.Matrix(ChainValue), Record.Point)
+        Matches = [
+            Index
+            for Index, Point in enumerate(Proof.Expected.Points)
+            if IsNearPoint(World, Point)
+        ]
+        if len(Matches) != 1 or Matches[0] in Proof.Vertices.values():
+            raise DecodeFailure("prism vertex does not match a unique corner")
+        Proof.Vertices[VertexKey] = Matches[0]
+    return Proof.Vertices[VertexKey]
+
+
+# line parameter endpoints and real vertex references must define the same edge
+def ReadEdgeMut(
+    Proof: PrismProof, RefValue: Reference, Parent: KLocationChain
+) -> tuple[int, int]:
+    ChainValue = Proof.RawValue.Place(RefValue, Parent)
+    EdgeKey = (RefValue.RecordA, ChainValue)
+    if EdgeKey not in Proof.Edges:
+        Record = Proof.RawValue.Records[RefValue.RecordA]
+        Geometry = Record.GeometryA
+        if (
+            not isinstance(Geometry, EdgeData)
+            or Geometry.Tolerance > KPositionTolerance
+        ):
+            raise DecodeFailure("invalid prism edge")
+        if {Value.Orientation for Value in Record.Children} != {"+", "-"}:
+            raise DecodeFailure("invalid prism edge vertex senses")
+        First, Second = Record.Children
+        if First.Orientation == "-":
+            First, Second = Second, First
+        Start = ReadVertexMut(Proof, First, ChainValue)
+        EndPoint = ReadVertexMut(Proof, Second, ChainValue)
+        CheckEdgeGeom(Proof, Geometry, ChainValue, Start, EndPoint)
+        Proof.Edges[EdgeKey] = (Start, EndPoint)
+    Start, EndPoint = Proof.Edges[EdgeKey]
+    return (Start, EndPoint) if RefValue.Orientation == "+" else (EndPoint, Start)
+
+
+# analytic carrier endpoints corroborate both finite edge range and declared incidence
+def CheckEdgeGeom(
+    Proof: PrismProof,
+    Geometry: EdgeData,
+    ChainValue: KLocationChain,
+    Start: int,
+    EndPoint: int,
+) -> None:
+    Curve = Proof.RawValue.Curves[Geometry.Curve - 1]
+    if (
+        not isinstance(Curve, LineCurve)
+        or Geometry.FirstValue >= Geometry.LastValue
+        or frozenset((Start, EndPoint)) not in Proof.Expected.Edges
+    ):
+        raise DecodeFailure("unsupported prism edge carrier")
+    Matrix = Proof.RawValue.Matrix(ChainValue, Geometry.KLocation)
+    for Index, Parameter in (
+        (Start, Geometry.FirstValue),
+        (EndPoint, Geometry.LastValue),
+    ):
+        Point = LocationPoint(
+            Matrix, OffsetVector(Curve.origin, Curve.direction, Parameter)
+        )
+        if not IsNearPoint(Point, Proof.Expected.Points[Index]):
+            raise DecodeFailure("prism edge endpoints disagree with its vertices")

convert/adapters/freecad/EditShape/Prism/PrismRaw.py

@@ -0,0 +1,207 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+
+from dataclasses import dataclass as MakeDataClass
+from re import findall as FindAll
+
+from convert.adapters.freecad.EditShape.CylinderRims import KAngleTolerance
+from convert.adapters.freecad.EditShape.Prism.PrismTrim import (
+    ReadPrismBinds,
+    ReadPrismCurves,
+)
+from convert.adapters.freecad.EditShape.TrimBind import TrimBinding
+from convert.adapters.freecad.EditShape.TrimGeometry import TrimCurve
+from convert.geometry.Opencascade import (
+    AssertReachable,
+    DecodeFailure,
+    EdgeData,
+    ExpectHeader,
+    FaceData,
+    FoldMatrix,
+    LocationProduct,
+    LocationScale,
+    ReadChainMut,
+    ReadCount,
+    ReadModelCurves,
+    ReadModelSurfs,
+    ReadReference,
+    Reference,
+    ShapeRecord,
+    ShapeRecords,
+    Tokens,
+    ZeroTable,
+)
+from interchange.brep.curves.BrepCurves import BrepCurve
+from interchange.brep.surfaces.BrepSurfaces import BrepSurface
+
+# symbolic native datums distinguish real sharing from coincident independent topology
+KLocationChain = tuple[tuple[int, int], ...]
+
+# only the bounded solid shell face wire edge vertex hierarchy can describe a prism
+KPrismKinds = {b"So": b"Sh", b"Sh": b"Fa", b"Fa": b"Wi", b"Wi": b"Ed", b"Ed": b"Ve"}
+
+
+# native placements and carriers are retained separately from shared topology records
+@MakeDataClass(frozen=True, slots=True)
+class PrismRaw:
+    Chains: list[KLocationChain]
+    Datums: dict[int, tuple[float, ...]]
+    Pcurves: tuple[TrimCurve, ...]
+    Bindings: dict[int, tuple[TrimBinding, ...]]
+    Curves: tuple[BrepCurve, ...]
+    Surfaces: tuple[BrepSurface, ...]
+    Records: dict[int, ShapeRecord]
+    RootRef: Reference
+
+    # reverse ordered datums preserve shared topology through native placement composition
+    def Place(self, RefValue: Reference, Parent: KLocationChain = ()) -> KLocationChain:
+        return LocationProduct(Parent, self.Chains[RefValue.KLocation])
+
+    # datums are stored innermost first and geometry uses the world transform
+    def Matrix(self, ChainValue: KLocationChain, Index: int = 0) -> tuple[float, ...]:
+        return FoldMatrix(
+            LocationProduct(ChainValue, self.Chains[Index])[::-1], self.Datums
+        )
+
+
+# vertex representations discarded by the general parser are outside this planar grammar
+def CheckVertData(ShapeData: bytes, Records: dict[int, ShapeRecord]) -> None:
+    Count = sum(Value.KindValue == b"Ve" for Value in Records.values())
+    Pattern = rb"(?<!\S)Ve\s+(?:\S+\s+){4}0\s+0(?=\s)"
+    if len(FindAll(Pattern, ShapeData)) != Count:
+        raise DecodeFailure("unsupported prism vertex representations")
+
+
+# coherent range flags prevent accepting a saved edge with an unqualified parameter state
+def CheckEdgeFlags(ShapeData: bytes, Records: dict[int, ShapeRecord]) -> None:
+    Count = sum(Value.KindValue == b"Ed" for Value in Records.values())
+    Pattern = rb"(?<!\S)Ed\s+\S+\s+1\s+1\s+0(?=\s)"
+    if len(FindAll(Pattern, ShapeData)) != Count:
+        raise DecodeFailure("unsupported prism edge parameter flags")
+
+
+# the root shell and each boundary record must have its qualified child type
+def CheckPrismTree(
+    Records: dict[int, ShapeRecord], RootRef: Reference, Sides: int
+) -> None:
+    if Records[RootRef.RecordA].KindValue != b"So" or RootRef.Orientation != "+":
+        raise DecodeFailure("prism requires a single forward solid")
+    for Record in Records.values():
+        KindValue = Record.KindValue
+        Count = len(Record.Children)
+        if (
+            (KindValue in {b"So", b"Fa"} and Count != 1)
+            or (KindValue == b"Sh" and Count != Sides + 2)
+            or (KindValue == b"Wi" and not 3 <= Count <= max(Sides, 4))
+            or (KindValue == b"Ed" and Count != 2)
+            or (KindValue == b"Ve" and Count != 0)
+            or (KindValue in {b"Wi", b"Sh"} and Record.FlagBits[4] != "1")
+            or (KindValue != b"Ve" and KindValue not in KPrismKinds)
+            or any(
+                Child.Orientation not in {"+", "-"}
+                or Records[Child.RecordA].KindValue != KPrismKinds[KindValue]
+                for Child in Record.Children
+            )
+        ):
+            raise DecodeFailure("unsupported prism topology")
+    AssertReachable(
+        RootRef.RecordA,
+        {
+            Index: tuple(Child.RecordA for Child in Value.Children)
+            for Index, Value in Records.items()
+        },
+        {Index: Value.KindValue for Index, Value in Records.items()},
+    )
+
+
+# retaining rigid datum chains lets one cap record represent two separate cap instances
+def ReadPrismPlaces(
+    Cursor: Tokens,
+) -> tuple[list[KLocationChain], dict[int, tuple[float, ...]]]:
+    Count = ReadCount(Cursor, b"Locations", 16)
+    Chains: list[KLocationChain] = []
+    Datums: dict[int, tuple[float, ...]] = {}
+    for Index in range(1, Count + 1):
+        Location = ReadChainMut(Cursor, Index, Chains, Datums)
+        if (
+            not Location
+            or Location in Chains
+            or abs(LocationScale(FoldMatrix(Location[::-1], Datums)) - 1.0)
+            > KAngleTolerance
+        ):
+            raise DecodeFailure("unsupported prism location")
+        Chains.append(Location)
+    return [(), *Chains], Datums
+
+
+# both carrier encodings need the same finite closed incidence grammar
+def ReadPrismTree(
+    Cursor: Tokens,
+    ShapeData: bytes,
+    Sides: int,
+    CurveCount: int,
+    TrimCount: int,
+    SurfaceCount: int,
+    PlaceCount: int,
+) -> tuple[dict[int, ShapeRecord], Reference]:
+    ZeroTable(Cursor, b"Triangulations")
+    Count = ReadCount(Cursor, b"TShapes", 7 * Sides + 6)
+    Records = ShapeRecords(
+        Cursor, Count, CurveCount, TrimCount, SurfaceCount, PlaceCount
+    )
+    RootRef = ReadReference(Cursor, Count, PlaceCount)
+    if RootRef is None or Cursor.PeekToken() is not None:
+        raise DecodeFailure("unsupported prism root")
+    CheckPrismTree(Records, RootRef, Sides)
+    CheckVertData(ShapeData, Records)
+    CheckEdgeFlags(ShapeData, Records)
+    return Records, RootRef
+
+
+# shared root placement cancels out when comparing a seed edge and trim
+def CheckRootTrims(Records: dict[int, ShapeRecord], RootRef: Reference) -> None:
+    if RootRef.KLocation != 1 or any(
+        any(Child.KLocation for Child in Record.Children)
+        or (
+            isinstance(Geometry := Record.GeometryA, (EdgeData, FaceData))
+            and Geometry.KLocation
+        )
+        for Record in Records.values()
+    ):
+        raise DecodeFailure("explicit prism trims require a shared root location")
+
+
+# native saves use implicit planar trims while kit seeds store exact planar line trims
+def ReadPrismRaw(ShapeData: bytes, Sides: int, AllowRootTrim: bool = False) -> PrismRaw:
+    Cursor = Tokens(ShapeData)
+    ExpectHeader(Cursor)
+    Chains, Datums = ReadPrismPlaces(Cursor)
+    ModelStart = Cursor.LastEnd
+    Pcurves = ReadPrismCurves(Cursor, 6 * Sides)
+    if Pcurves and Datums and (not AllowRootTrim or len(Chains) != 2):
+        raise DecodeFailure("located explicit prism pcurves are unsupported")
+    Cursor = Tokens(ShapeData[ModelStart:])
+    _, Curves = ReadModelCurves(Cursor, "freecad:edit-prism")
+    ZeroTable(Cursor, b"Polygon3D")
+    ZeroTable(Cursor, b"PolygonOnTriangulations")
+    Surfaces = ReadModelSurfs(Cursor, "freecad:edit-prism")
+    Records, RootRef = ReadPrismTree(
+        Cursor,
+        ShapeData,
+        Sides,
+        len(Curves),
+        len(Pcurves),
+        len(Surfaces),
+        len(Chains) - 1,
+    )
+    if Pcurves and Datums:
+        CheckRootTrims(Records, RootRef)
+    Bindings = (
+        ReadPrismBinds(ShapeData, Records, len(Pcurves), len(Surfaces))
+        if Pcurves
+        else {}
+    )
+    return PrismRaw(
+        Chains, Datums, Pcurves, Bindings, Curves, Surfaces, Records, RootRef
+    )

convert/adapters/freecad/EditShape/Prism/PrismTrim.py

@@ -0,0 +1,122 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+
+from re import split as SplitValue
+
+from convert.adapters.freecad.EditShape.CylinderRims import KAngleTolerance
+from convert.adapters.freecad.EditShape.TrimBind import TrimBinding
+from convert.adapters.freecad.EditShape.TrimGeometry import (
+    IsTrimAligned,
+    IsUnitPair,
+    TrimCurve,
+)
+from convert.geometry.Opencascade import (
+    DecodeFailure,
+    EdgeData,
+    FaceData,
+    KIdentityLocation,
+    ReadCount,
+    ShapeRecord,
+    Tokens,
+)
+from interchange.brep.curves.BrepCurves import LineCurve
+from interchange.brep.surfaces.BrepSurfaces import PlaneSurface
+
+
+# linear planar trims are the only stored edge representations used by kit prisms
+def ReadPrismCurves(Cursor: Tokens, Maximum: int) -> tuple[TrimCurve, ...]:
+    Count = ReadCount(Cursor, b"Curve2ds", Maximum)
+    Curves: list[TrimCurve] = []
+    for _ in range(Count):
+        _ = Cursor.ReadInteger(1, 1)
+        Origin = (Cursor.ReadNumber(), Cursor.ReadNumber())
+        AxisValue = (Cursor.ReadNumber(), Cursor.ReadNumber())
+        if not IsUnitPair(AxisValue):
+            raise DecodeFailure("invalid prism pcurve direction")
+        Curves.append(TrimCurve(Origin, AxisValue))
+    return tuple(Curves)
+
+
+# a seed edge carries one three dimensional range and one trim for each adjacent face
+def ReadEdgeBinds(
+    Block: bytes, TrimCount: int, FaceCount: int, PlaceCount: int
+) -> tuple[TrimBinding, ...]:
+    Cursor = Tokens(Block)
+    _ = Cursor.ReadNumber()
+    Cursor.ExpectToken(b"1")
+    Cursor.ExpectToken(b"1")
+    Cursor.ExpectToken(b"0")
+    Cursor.ExpectToken(b"1")
+    _ = Cursor.ReadInteger(1)
+    _ = Cursor.ReadInteger(0, PlaceCount)
+    _ = Cursor.ReadNumber()
+    _ = Cursor.ReadNumber()
+    Bindings: list[TrimBinding] = []
+    for _ in range(2):
+        Cursor.ExpectToken(b"2")
+        CurveId = Cursor.ReadInteger(1, TrimCount)
+        SurfaceId = Cursor.ReadInteger(1, FaceCount)
+        Placement = Cursor.ReadInteger(0, PlaceCount)
+        Bindings.append(
+            TrimBinding(
+                (CurveId,),
+                SurfaceId,
+                Placement,
+                Cursor.ReadNumber(),
+                Cursor.ReadNumber(),
+            )
+        )
+    Cursor.ExpectToken(b"0")
+    return tuple(Bindings)
+
+
+# exact carrier tables and per edge bindings are checked before topology is accepted
+def ReadPrismBinds(
+    ShapeData: bytes,
+    Records: dict[int, ShapeRecord],
+    TrimCount: int,
+    FaceCount: int,
+    PlaceCount: int = 0,
+) -> dict[int, tuple[TrimBinding, ...]]:
+    EdgeIds = [Index for Index, Value in Records.items() if Value.KindValue == b"Ed"]
+    Blocks = SplitValue(rb"(?<!\S)Ed(?=\s)", ShapeData)[1:]
+    if len(EdgeIds) != len(Blocks):
+        raise DecodeFailure("cannot locate prism edge trims")
+    Result = {
+        Index: ReadEdgeBinds(Block, TrimCount, FaceCount, PlaceCount)
+        for Index, Block in zip(EdgeIds, Blocks, strict=True)
+    }
+    UsedIds = [Value.CurveIds[0] for Bindings in Result.values() for Value in Bindings]
+    if sorted(UsedIds) != list(range(1, TrimCount + 1)):
+        raise DecodeFailure("unreachable or shared prism trim")
+    return Result
+
+
+# each stored linear trim must trace its actual edge on the referenced face plane
+def CheckTrimBind(
+    Bindings: tuple[TrimBinding, ...],
+    Pcurves: tuple[TrimCurve, ...],
+    EdgeValue: EdgeData,
+    FaceValue: FaceData,
+    LineValue: LineCurve,
+    Surface: PlaneSurface,
+) -> None:
+    Matches = [Value for Value in Bindings if Value.SurfaceId == FaceValue.Surface]
+    if len(Matches) != 1:
+        raise DecodeFailure("missing or ambiguous prism trim face binding")
+    Binding = Matches[0]
+    if (
+        abs(Binding.Lower - EdgeValue.FirstValue) > KAngleTolerance
+        or abs(Binding.Upper - EdgeValue.LastValue) > KAngleTolerance
+        or not IsTrimAligned(
+            Pcurves[Binding.CurveIds[0] - 1],
+            Surface,
+            LineValue,
+            KIdentityLocation,
+            KIdentityLocation,
+            Binding.Lower,
+            Binding.Upper,
+        )
+    ):
+        raise DecodeFailure("prism pcurve disagrees with its analytic edge")

convert/adapters/freecad/EditShape/PrismShape.py

@@ -0,0 +1,84 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+
+from math import isfinite as IsFinite
+
+from convert.adapters.freecad.EditShape.CylinderRims import KPositionTolerance
+from convert.adapters.freecad.EditShape.Prism.PrismAxisLink import (
+    CheckPrismLink,
+    KPrismLink,
+)
+from convert.adapters.freecad.EditShape.Prism.PrismExpected import (
+    ExpectedPrism,
+    ExpectedShape,
+)
+from convert.adapters.freecad.EditShape.Prism.PrismFaces import CheckFaceMut
+from convert.adapters.freecad.EditShape.Prism.PrismProof import PrismProof
+from convert.adapters.freecad.EditShape.Prism.PrismRaw import PrismRaw, ReadPrismRaw
+from convert.geometry.Opencascade import EdgeData, FaceData
+from interchange.geometry.models.Transform import Transform
+from interchange.geometry.models.VectorPlane import PlaneVector
+
+# an analytic prism with sixty four sides fits within a bounded native shape entry
+KMaxPrismBytes = 262_144
+
+
+# saved geometry independently proves the signed native extrusion and every shared edge
+def IsEditPrism(
+    ShapeData: bytes,
+    Frame: Transform,
+    Profile: tuple[PlaneVector, ...],
+    DistanceMm: float,
+    LinkValue: KPrismLink | None = None,
+) -> bool:
+    if (
+        not ShapeData
+        or len(ShapeData) > KMaxPrismBytes
+        or not 3 <= len(Profile) <= 64
+        or not IsFinite(DistanceMm)
+        or abs(DistanceMm) <= 2.0 * KPositionTolerance
+    ):
+        return False
+    try:
+        Expected = ExpectedShape(Frame, Profile, DistanceMm)
+        RawValue = ReadPrismRaw(ShapeData, len(Profile))
+        if LinkValue is not None:
+            CheckPrismLink(RawValue, LinkValue)
+        return IsPrismMatch(RawValue, Expected)
+    except (KeyError, OverflowError, ValueError):
+        return False
+
+
+# all carrier families must prove the same placed faces and shared edge identities
+def IsPrismMatch(RawValue: PrismRaw, Expected: ExpectedPrism) -> bool:
+    Proof = PrismProof(RawValue, Expected)
+    RootPlace = RawValue.Place(RawValue.RootRef)
+    (ShellRef,) = RawValue.Records[RawValue.RootRef.RecordA].Children
+    ShellPlace = RawValue.Place(ShellRef, RootPlace)
+    FaceRefs = RawValue.Records[ShellRef.RecordA].Children
+    Faces = {CheckFaceMut(Proof, ShellRef, Value, ShellPlace) for Value in FaceRefs}
+    return (
+        Faces == Expected.Faces.keys()
+        and len(Proof.Vertices) == len(Expected.Points)
+        and len(Proof.Edges) == len(Expected.Edges)
+        and HasUsedCarriers(Proof)
+    )
+
+
+# geometry entries outside the proven shell cannot be substituted or ignored
+def HasUsedCarriers(Proof: PrismProof) -> bool:
+    RawValue = Proof.RawValue
+    Curves = {
+        Value.Curve
+        for Record in RawValue.Records.values()
+        if isinstance(Value := Record.GeometryA, EdgeData)
+    }
+    Surfaces = {
+        Value.Surface
+        for Record in RawValue.Records.values()
+        if isinstance(Value := Record.GeometryA, FaceData)
+    }
+    return len(Curves) == len(RawValue.Curves) and len(Surfaces) == len(
+        RawValue.Surfaces
+    )

convert/adapters/freecad/EditShape/Revolution/RevCarriers.py

@@ -0,0 +1,108 @@
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: Copyright (c) 2026 Parashell, Odin Glynn-Martin, Stephen Harcourt
+
+
+from math import cos as Cosine, pi as PiValue, sin as SineValue
+
+from convert.adapters.freecad.EditShape.CylinderRims import KAngleTolerance
+from convert.geometry.Opencascade import (
+    DecodeFailure,
+    IsFrame,
+    ReadCount,
+    Tokens,
+    VectorValue,
+)
+from convert.geometry.Revolve.SweepVector import CrossVector, DotVector, OffsetVector
+from interchange.brep.curves.BrepCurves import CircleCurve, LineCurve
+from interchange.brep.surfaces.BrepSurfaces import (
+    ConeSurface,
+    CylinderSurface,
+    PlaneSurface,
+)
+from interchange.geometry.models.VectorSpace import SpaceVector
+
+# only elementary sweep carriers are qualified by the native shape witness
+KRevCurve = LineCurve | CircleCurve
+
+# the surface family fixes which exact native parameterization is allowed
+KRevSurface = PlaneSurface | CylinderSurface | ConeSurface
+
+
+# stored basis parity determines the orientation of the native surface derivatives
+def ReadRevSurface(Cursor: Tokens, Index: int) -> KRevSurface:
+    Family = Cursor.ReadInteger(1, 3)
+    Origin, AxisValue, RefValue, SideValue = (VectorValue(Cursor) for _ in range(4))
+    if not IsFrame(AxisValue, RefValue, SideValue):
+        raise DecodeFailure("invalid Revolution surface frame")
+    NameValue = f"revolution:surface:{Index}"
+    Attrs = {"reference_y": (SideValue.x, SideValue.y, SideValue.z)}
+    if Family == 1:
+        return PlaneSurface(NameValue, Origin, AxisValue, RefValue, attributes=Attrs)
+    Radius = Cursor.ReadNumber()
+    if Radius <= 0.0:
+        raise DecodeFailure("invalid Revolution surface radius")
+    if Family == 2:
+        return CylinderSurface(
+            NameValue, Origin, AxisValue, RefValue, Radius, attributes=Attrs
+        )
+    HalfAngle = Cursor.ReadNumber()
+    if not KAngleTolerance < abs(HalfAngle) < PiValue / 2.0 - KAngleTolerance:
+        raise DecodeFailure("invalid Revolution cone angle")
+    return ConeSurface(
+        NameValue, Origin, AxisValue, RefValue, Radius, HalfAngle, attributes=Attrs
+    )
+
+
+# checking circle handedness keeps its evaluated direction bound to the original frame
+def CheckCurveAxes(Cursor: Tokens, Maximum: int) -> None:
+    Count = ReadCount(Cursor, b"Curves", Maximum)
+    for _ in range(Count):
+        Family = Cursor.ReadInteger(1, 2)
+        _ = VectorValue(Cursor)
+        AxisValue = VectorValue(Cursor)
+        if Family == 2:
+            First, Second = VectorValue(Cursor), VectorValue(Cursor)
+            _ = Cursor.ReadNumber()
+            if DotVector(CrossVector(AxisValue, First), Second) < 1.0 - KAngleTolerance:
+                raise DecodeFailure("invalid Revolution circle handedness")
+
+
+# line and circle trims can be verified through their exact analytic parameterizations
+def CurvePoint(Curve: KRevCurve, Param: float) -> SpaceVector:
+    if isinstance(Curve, LineCurve):
+        return OffsetVector(Curve.origin, Curve.direction, Param)
+    SideValue = CrossVector(Curve.axis, Curve.reference_direction)
+    return OffsetVector(
+        OffsetVector(
+            Curve.center, Curve.reference_direction, Curve.radius * Cosine(Param)
+        ),
+        SideValue,
+        Curve.radius * SineValue(Param),
+    )
+
+
+# finite cone meridians use slant distance while cylinders use axial distance
+def SurfacePoint(
+    Surface: KRevSurface, SideValue: SpaceVector, UValue: float, VValue: float
+) -> SpaceVector:
+    if isinstance(Surface, PlaneSurface):
+        return OffsetVector(
+            OffsetVector(Surface.origin, Surface.reference_direction, UValue),
+            SideValue,
+            VValue,
+        )
+    Radius, Axial = Surface.radius, VValue
+    if isinstance(Surface, ConeSurface):
+        Radius += VValue * SineValue(Surface.half_angle)
+        Axial *= Cosine(Surface.half_angle)
+    if Radius <= 0.0:
+        raise DecodeFailure("Revolution pcurve crosses the axis")
+    return OffsetVector(
+        OffsetVector(
+            OffsetVector(Surface.origin, Surface.axis, Axial),
+            Surface.reference_direction,
+            Radius * Cosine(UValue),
+        ),
+        SideValue,
+        Radius * SineValue(UValue),
+    )