Keep weights only: runtime lives in mlx-vlm; refresh card and validation

README.md

@@ -18,65 +18,50 @@ tags:
 
 # SAM 3D Objects — MLX BF16
 
-Frozen inference port of Meta SAM 3D Objects, including the upstream MoGe-v1
-depth estimator. Runtime and conversion require **MLX and Python's standard
-library only**. This is an unofficial derivative. SAM components retain the
-SAM License; MoGe and FlexiCubes retain Apache-2.0.
+BF16 weights of Meta SAM 3D Objects, including the upstream MoGe-v1 depth
+estimator, converted for the MLX runtime in
+[mlx-vlm](https://github.com/Blaizzy/mlx-vlm) (`mlx_vlm/models/sam3d_objects`).
+This repository holds weights and metadata only; the inference code lives in
+mlx-vlm. This is an unofficial derivative. SAM components retain the SAM
+License; MoGe retains MIT; FlexiCubes retains Apache-2.0.
 
-The bundle includes 3,709 BF16 tensors, strict loading, MLX sparse convolutions,
-windowed attention, Gaussian and colored-mesh decoding, `mx.async_eval`, and
-synchronous/asynchronous streaming APIs. Both Gaussian heads are included.
-It generates geometry and pose; it has no text or tool-calling interface.
+The 3,709 BF16 tensors across seven safetensors files cover the structure and
+pose flow model, the sparse-latent flow model, image and point-map
+conditioners, the occupancy decoder, both Gaussian decoders (32 or 4 Gaussians
+per voxel), the mesh decoder, and MoGe-v1. The model generates geometry and
+pose; it has no text or tool-calling interface.
 
-## Install the included runtime
+## Usage
 
-Download this repository, then install its small runtime package:
+Install an mlx-vlm version that includes `sam3d_objects`, download this
+repository, and run the CLI or the Python API:
 
 ```sh
+pip install mlx-vlm
 hf download mlx-community/sam-3d-objects-bf16 --local-dir sam-3d-objects-bf16
-python -m pip install ./sam-3d-objects-bf16
-sam3d-mlx --model ./sam-3d-objects-bf16 \
-  --image image.png --mask mask.png --output ./output \
-  --formats gaussian mesh
+python -m mlx_vlm.models.sam3d_objects.generate \
+  --model sam-3d-objects-bf16 --image image.png --mask mask.png \
+  --output output --formats gaussian mesh
 ```
 
-`hf` is an optional download tool; it is not a runtime dependency. The package
-can also be imported directly from the downloaded directory. The same model
-implementation lives under `mlx_vlm/models/sam3d_objects` in the port checkout.
-
 ```python
-from sam3d_objects_mlx.io import read_png, read_mask
-from sam3d_objects_mlx.pipeline import Pipeline, Request
+from mlx_vlm.models.sam3d_objects.io import read_mask, read_png
+from mlx_vlm.models.sam3d_objects.pipeline import Pipeline
 
 pipeline = Pipeline.from_pretrained("sam-3d-objects-bf16")
 image, mask = read_png("image.png")[..., :3], read_mask("mask.png")
 result = pipeline.generate(image, mask, seed=42)
-
-async def reconstruct(requests):
-    async for event in pipeline.astream(requests):
-        if event.stage == "complete":
-            consume(event.data)
 ```
 
-`requests` is an iterable or async iterable of `Request` values. Input is
-consumed one request at a time with backpressure. Events preserve IDs and
-order and include every sampling step plus decoded outputs. The event loop
-remains responsive while one worker submits MLX work. Early `aclose()` or
-cancellation stops submissions and drains the worker. Arrays may still be
-evaluating on the GPU when yielded; use `mx.eval` before host consumption.
-
-Inputs are HWC RGB/RGBA MLX arrays and HW masks. The included file reader
-supports non-interlaced 8-bit PNG, including RGBA alpha masks. Callers can use
-other decoders and pass arrays directly. Automatic MoGe depth is included;
-external HWC point maps use +X left, +Y up, +Z forward, with NaN invalid values.
-Set `estimate_depth=False` to use the trained point-map dropout instead.
-
+`pipeline.astream(requests)` streams ordered events for an iterable or async
+iterable of `Request` values, one request at a time with backpressure; the
+same weights also load through `mlx_vlm.utils.load_model`. Inputs are HWC
+RGB/RGBA MLX arrays and HW masks. Automatic MoGe depth is included; external
+HWC point maps use +X left, +Y up, +Z forward with NaN for invalid points.
 Results include local-space Gaussians, mesh vertices/faces/colors, latent
 features, occupied voxels, and a separate pose (rotation, translation, scale).
-CLI outputs standard Gaussian PLY, colored OBJ, and raw safetensors.
-`--jsonl` consumes stdin request lines and emits ordered progress records.
-Training, latent training encoders, rendering, texture baking, mesh
-simplification, and iterative layout optimization are not included.
+The mlx-vlm model README documents the full API, CLI, JSONL streaming, and
+the inference optimizations.
 
 ## Conversion and validation
 
@@ -94,20 +79,21 @@ FlexiCubes. Maximum absolute error was below 0.000002 on these fixtures;
 mesh face indices matched exactly. This is not a claim of bitwise BF16
 end-to-end parity or a reconstruction-quality evaluation.
 
-See `validation.json`, `conversion.json`, and the included source for details.
-The original sources are [SAM 3D Objects](https://github.com/facebookresearch/sam-3d-objects)
-and [MoGe](https://github.com/microsoft/MoGe).
+See `validation.json` and `conversion.json` for details. The original sources
+are [SAM 3D Objects](https://github.com/facebookresearch/sam-3d-objects) and
+[MoGe](https://github.com/microsoft/MoGe).
 
 ### Local performance
 
-Hardware: Apple M5 Max, 128 GiB unified memory. Input: 448×672 RGB plus object mask; automatic MoGe
-depth, 25 structure steps and 25 latent steps, both Gaussian heads and mesh.
-One warmup was excluded; the same seed produced identical latent outputs.
+Hardware: Apple M5 Max, 128 GiB unified memory. Input: 448×672 RGB plus object mask; automatic
+MoGe depth, 25 structure steps and 25 latent steps, both Gaussian heads
+and mesh. One warmup was excluded; the same seed produced identical latent
+outputs.
 
 | Metric | Result |
 | --- | ---: |
-| Median latency (3 runs) | 20.65 s |
-| Maximum peak memory | 10.56 GB |
+| Median latency (3 runs) | 15.68 s |
+| Maximum peak memory | 10.98 GB |
 
 Two additional async requests matched the synchronous latent output while
 the event-loop heartbeat continued. These measurements describe one input.

pyproject.toml

@@ -1,20 +0,0 @@
-[build-system]
-requires = ["setuptools>=61"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "sam3d-objects-mlx-inference"
-version = "0.1.0"
-description = "Frozen SAM 3D Objects inference using MLX and the Python standard library"
-requires-python = ">=3.10"
-dependencies = ["mlx>=0.32.2"]
-license = {text = "SAM License; Apache-2.0 for MoGe/FlexiCubes"}
-
-[project.scripts]
-sam3d-mlx = "sam3d_objects_mlx.generate:main"
-
-[tool.setuptools.packages.find]
-include = ["sam3d_objects_mlx*"]
-
-[tool.setuptools.package-data]
-sam3d_objects_mlx = ["LICENSE", "LICENSE-APACHE", "README.md"]

sam3d_objects_mlx/LICENSE

@@ -1,52 +0,0 @@
-SAM License
-Last Updated: November 19, 2025
-
-“Agreement” means the terms and conditions for use, reproduction, distribution and modification of the SAM Materials set forth herein.
-
-“SAM Materials” means, collectively, Documentation and the models, software and algorithms, including machine-learning model code, trained model weights, inference-enabling code, training-enabling code, fine-tuning enabling code, and other elements of the foregoing distributed by Meta and made available under this Agreement.
-
-“Documentation” means the specifications, manuals and documentation accompanying 
-SAM Materials distributed by Meta.
-
-“Licensee” or “you” means you, or your employer or any other person or entity (if you are entering into this Agreement on such person or entity’s behalf), of the age required under applicable laws, rules or regulations to provide legal consent and that has legal authority to bind your employer or such other person or entity if you are entering in this Agreement on their behalf.
-
-“Meta” or “we” means Meta Platforms Ireland Limited (if you are located in or, if you are an entity, your principal place of business is in the EEA or Switzerland) or Meta Platforms, Inc. (if you are located outside of the EEA or Switzerland).
-
-“Sanctions” means any economic or trade sanctions or restrictions administered or enforced by the United States (including the Office of Foreign Assets Control of the U.S. Department of the Treasury (“OFAC”), the U.S. Department of State and the U.S. Department of Commerce), the United Nations, the European Union, or the United Kingdom.
-
-“Trade Controls” means any of the following: Sanctions and applicable export and import controls.
-
-By using or distributing any portion or element of the SAM Materials, you agree to be bound by this Agreement.
-
-1. License Rights and Redistribution.
-
-a. Grant of Rights. You are granted a non-exclusive, worldwide, non-transferable and royalty-free limited license under Meta’s intellectual property or other rights owned by Meta embodied in the SAM Materials to use, reproduce, distribute, copy, create derivative works of, and make modifications to the SAM Materials.  
-
-i. Grant of Patent License. Subject to the terms and conditions of this License, you are granted a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by Meta that are necessarily infringed alone or by combination of their contribution(s) with the SAM 3 Materials. If you institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the SAM 3 Materials incorporated within the work constitutes direct or contributory patent infringement, then any patent licenses granted to you under this License for that work shall terminate as of the date such litigation is filed.
- 
-b. Redistribution and Use.  
-
-i. Distribution of SAM Materials, and any derivative works thereof, are subject to the terms of this Agreement. If you distribute or make the SAM Materials, or any derivative works thereof, available to a third party, you may only do so under the terms of this Agreement and you shall provide a copy of this Agreement with any such SAM Materials.
-
-ii.  If you submit for publication the results of research you perform on, using, or otherwise in connection with SAM Materials, you must acknowledge the use of SAM Materials in your publication.
-
-iii. Your use of the SAM Materials must comply with applicable laws and regulations, including Trade Control Laws and applicable privacy and data protection laws.
-iv. Your use of the SAM Materials will not involve or encourage others to reverse engineer, decompile or discover the underlying components of the SAM Materials.
-v. You are not the target of Trade Controls and your use of SAM Materials must comply with Trade Controls. You agree not to use, or permit others to use, SAM Materials for any activities subject to the International Traffic in Arms Regulations (ITAR) or end uses prohibited by Trade Controls, including those related to military or warfare purposes, nuclear industries or applications, espionage, or the development or use of guns or illegal weapons.
-2. User Support. Your use of the SAM Materials is done at your own discretion; Meta does not process any information nor provide any service in relation to such use.  Meta is under no obligation to provide any support services for the SAM Materials. Any support provided is “as is”, “with all faults”, and without warranty of any kind.
-
-3. Disclaimer of Warranty. UNLESS REQUIRED BY APPLICABLE LAW, THE SAM MATERIALS AND ANY OUTPUT AND RESULTS THEREFROM ARE PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OF ANY KIND, AND META DISCLAIMS ALL WARRANTIES OF ANY KIND, BOTH EXPRESS AND IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING THE SAM MATERIALS AND ASSUME ANY RISKS ASSOCIATED WITH YOUR USE OF THE SAM MATERIALS AND ANY OUTPUT AND RESULTS.
- 
-4. Limitation of Liability. IN NO EVENT WILL META OR ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, ARISING OUT OF THIS AGREEMENT, FOR ANY LOST PROFITS OR ANY DIRECT OR INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL, EXEMPLARY OR PUNITIVE DAMAGES, EVEN IF META OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF ANY OF THE FOREGOING.
- 
-5. Intellectual Property.
-
-a. Subject to Meta’s ownership of SAM Materials and derivatives made by or for Meta, with respect to any derivative works and modifications of the SAM Materials that are made by you, as between you and Meta, you are and will be the owner of such derivative works and modifications.
- 
-b. If you institute litigation or other proceedings against Meta or any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the SAM Materials, outputs or results, or any portion of any of the foregoing, constitutes infringement of intellectual property or other rights owned or licensable by you, then any licenses granted to you under this Agreement shall terminate as of the date such litigation or claim is filed or instituted. You will indemnify and hold harmless Meta from and against any claim by any third party arising out of or related to your use or distribution of the SAM Materials.
- 
-6. Term and Termination. The term of this Agreement will commence upon your acceptance of this Agreement or access to the SAM Materials and will continue in full force and effect until terminated in accordance with the terms and conditions herein. Meta may terminate this Agreement if you are in breach of any term or condition of this Agreement. Upon termination of this Agreement, you shall delete and cease use of the SAM Materials. Sections 3, 4 and 7 shall survive the termination of this Agreement. 
- 
-7. Governing Law and Jurisdiction. This Agreement will be governed and construed under the laws of the State of California without regard to choice of law principles, and the UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement. The courts of California shall have exclusive jurisdiction of any dispute arising out of this Agreement. 
-
-8. Modifications and Amendments. Meta may modify this Agreement from time to time; provided that they are similar in spirit to the current version of the Agreement, but may differ in detail to address new problems or concerns. All such changes will be effective immediately. Your continued use of the SAM Materials after any modification to this Agreement constitutes your agreement to such modification. Except as provided in this Agreement, no modification or addition to any provision of this Agreement will be binding unless it is in writing and signed by an authorized representative of both you and Meta.

sam3d_objects_mlx/LICENSE-APACHE

@@ -1,224 +0,0 @@
-    MIT License
-
-    Copyright (c) Microsoft Corporation.
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE
-
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

sam3d_objects_mlx/README.md

@@ -1,174 +0,0 @@
-# SAM 3D Objects for MLX
-
-Inference-only port of [Meta SAM 3D Objects](https://github.com/facebookresearch/sam-3d-objects).
-The runtime and checkpoint converter use **MLX and Python's standard library**.
-All parameters are frozen and every model runs in evaluation mode.
-
-The BF16 bundle is published as
-[`mlx-community/sam-3d-objects-bf16`](https://huggingface.co/mlx-community/sam-3d-objects-bf16).
-It includes the structure/pose flow model, sparse-latent flow model, image and
-point-map conditioners, occupancy decoder, both Gaussian decoders (32 or 4
-Gaussians per voxel), mesh decoder, and the MoGe-v1 depth estimator used by
-the upstream pipeline. The learned model outputs are decoded with MLX
-FlexiCubes into colored triangle meshes.
-
-Training, latent encoders used for training, differentiable renderers,
-texture baking, mesh simplification, and iterative layout optimization are
-outside this inference port. This model has no text or tool-calling protocol.
-
-## Load and generate
-
-Download the bundle with your preferred Hugging Face client. Hub transfer is
-separate from the inference runtime; the example below uses the optional `hf`
-command-line tool:
-
-```sh
-hf download mlx-community/sam-3d-objects-bf16 --local-dir models/sam-3d-objects-bf16
-```
-
-Use a checkout containing this port. Installing the entire mlx-vlm project
-also installs its other model dependencies; this model itself only needs MLX:
-
-```sh
-python -m pip install mlx
-```
-
-From the repository root:
-
-```python
-from mlx_vlm.models.sam3d_objects.io import read_mask, read_png, write_gaussians, write_obj
-from mlx_vlm.models.sam3d_objects.pipeline import Pipeline
-
-pipeline = Pipeline.from_pretrained("models/sam-3d-objects-bf16")
-image = read_png("image.png")[..., :3]
-mask = read_mask("mask.png")
-result = pipeline.generate(image, mask, seed=42)
-write_gaussians("object.ply", result["gaussian"])
-write_obj("object.obj", result["mesh"])
-```
-
-Inputs are HWC RGB/RGBA MLX arrays and an HW object mask. Images may be
-`uint8` or floating values in `[0, 1]`; masks may be boolean, 0/1, or 0/255.
-The small stdlib image reader supports non-interlaced, 8-bit PNG images.
-Other codecs can be decoded by the caller and passed as MLX arrays.
-
-Automatic point maps come from the bundled MoGe model. To use a camera or
-an existing depth pipeline, supply an HWC `pointmap` in the upstream camera
-convention: +X left, +Y up, +Z forward. Invalid points use NaN. Setting
-`estimate_depth=False` without a point map uses the trained point-map dropout;
-that path cannot establish scene-relative layout from observed depth.
-
-Outputs include `pose` (quaternion WXYZ, rotation matrix, translation, scale),
-voxel `coords`, denormalized `latents`, `gaussian`, and `mesh`. Geometry is in
-object-local coordinates; pose is returned separately. Gaussian fields are
-`positions`, `sh_dc`, `scales`, `rotations`, and `opacities`. Mesh fields are
-`vertices`, `faces`, and six-channel `vertex_colors` (RGB plus learned attributes).
-PLY uses standard Gaussian-splat fields; OBJ includes RGB vertex colors.
-
-## Streaming
-
-```python
-from mlx_vlm.models.sam3d_objects.pipeline import Request
-
-async def requests(camera):
-    async for frame, mask in camera:
-        yield Request(frame, mask, request_id="object-1", seed=42)
-
-async def reconstruct(camera):
-    async for event in pipeline.astream(requests(camera)):
-        print(event.request_id, event.stage, event.step, event.total_steps)
-        if event.stage == "complete":
-            consume(event.data)
-```
-
-`astream` accepts synchronous or asynchronous input iterables. It consumes
-one request at a time, preserves request order, and applies backpressure at
-each yield. One worker submits MLX operations so preprocessing and sparse
-topology work do not block the caller's event loop. Close the async generator
-with `aclose()` when stopping early, or use `contextlib.aclosing`.
-
-Events cover depth, conditioning, every structure/pose and sparse-latent
-flow step, occupancy, each selected decoder, and the final result. Arrays are
-scheduled with `mx.async_eval`; GPU work may still be in flight when yielded.
-Use `mx.eval(event.data)` if host-side code needs completed values. The
-blocking `generate` convenience method evaluates its final result.
-Sparse topology needs scalar synchronization to determine variable output
-sizes. Cancellation stops further submissions and drains already submitted
-work before releasing the worker stream. Each pipeline permits one active
-stream; use separate instances for independent streams.
-
-## CLI
-
-```sh
-python -m mlx_vlm.models.sam3d_objects.generate \
-  --model models/sam-3d-objects-bf16 \
-  --image image.png --mask mask.png --output outputs/object \
-  --formats gaussian mesh --ss-steps 25 --slat-steps 25
-```
-
-After installing mlx-vlm, the same command is available as `mlx_vlm.sam3d`.
-For JSONL streaming, pass `--jsonl` and provide one request per stdin line:
-
-```json
-{"id":"frame-1","image":"frame-1.png","mask":"mask-1.png","seed":42}
-{"id":"frame-2","image":"frame-2.png","mask":"mask-2.png","seed":42}
-```
-
-Progress is emitted as JSONL. Results go into numbered subdirectories under
-`--output`, each containing `result.safetensors` and the requested PLY/OBJ
-files. Input IDs are preserved as labels and never used as filesystem paths.
-For externally computed points, `--pointmap` accepts a safetensors file
-containing a `points` tensor.
-
-## Conversion
-
-Obtain the original checkpoints from `facebook/sam-3d-objects` and
-`Ruicheng/moge-vitl`, then run:
-
-```sh
-python -m mlx_vlm.models.sam3d_objects.convert \
-  --source /path/to/sam-3d-objects/checkpoints \
-  --moge-checkpoint /path/to/moge-vitl/model.pt \
-  --output models/sam-3d-objects-bf16
-```
-
-The converter reads tensor-only PyTorch ZIP archives through a restricted
-stdlib unpickler, streams their original storage bytes to safetensors, maps
-the inference weights to MLX layouts, and casts floating tensors to BF16.
-It does not import PyTorch, NumPy, or the safetensors Python library.
-Unknown pickle globals and unsupported storage layouts are rejected.
-The duplicate occupancy decoder embedded in the structure checkpoint is
-omitted in favor of its dedicated released checkpoint. Loading is strict:
-missing, extra, and incorrectly shaped model parameters are errors.
-
-The full bundle contains 3,709 tensors across seven safetensors files.
-There are no tokenizer or chat-template files because this is a geometry model.
-
-## Validation
-
-```sh
-python -m unittest mlx_vlm.tests.test_models.TestSAM3DObjects -v
-```
-
-Tests cover frozen BF16 checkpoint round trips, sparse convolution versus
-dense convolution, reference pooling semantics, window attention versus
-masked full attention, Euler/CFG scheduling, closed mesh topology, async
-backpressure/early close/reuse, and restricted checkpoint deserialization.
-
-Additional local comparisons against the original PyTorch source used FP32
-MLX CPU to isolate equation parity from accelerated Metal precision. Attention,
-both flow networks, occupancy decoding, interpolation, pretrained MoGe, and
-FlexiCubes matched within 0.000002 maximum absolute error on those fixtures;
-mesh face indices matched exactly. These are component checks, not a claim of
-bitwise BF16 end-to-end parity or a reconstruction quality benchmark.
-
-The actual BF16 Metal pipeline was also exercised on an upstream example
-image with automatic depth and both 25-step sampling stages. See the Hub
-model card's validation report for measured timings and memory.
-
-## Licenses
-
-SAM-derived code and weights retain the [SAM License](LICENSE).
-MoGe and FlexiCubes components retain Apache-2.0; see
-[LICENSE-APACHE](LICENSE-APACHE) and source copyright notices.
-This is an unofficial MLX port.

sam3d_objects_mlx/__init__.py

@@ -1,6 +0,0 @@
-"""SAM 3D Objects inference on Apple Silicon, using MLX and the stdlib."""
-
-from .config import ModelConfig
-from .sam3d_objects import Model
-
-__all__ = ["Model", "ModelConfig"]

sam3d_objects_mlx/bundle.py

@@ -1,171 +0,0 @@
-"""Package the inference code beside the converted Hub weights."""
-
-import argparse
-import json
-import shutil
-from pathlib import Path
-
-
-def package(destination):
-    root = Path(destination)
-    source = Path(__file__).parent
-    package_root = root / "sam3d_objects_mlx"
-    package_root.mkdir(parents=True, exist_ok=True)
-    for path in source.glob("*.py"):
-        shutil.copyfile(path, package_root / path.name)
-    for name in ("LICENSE", "LICENSE-APACHE", "README.md"):
-        shutil.copyfile(source / name, package_root / name)
-    (root / "LICENSE").write_text((source / "LICENSE").read_text())
-    (root / "LICENSE-APACHE").write_text((source / "LICENSE-APACHE").read_text())
-    (root / "pyproject.toml").write_text("""[build-system]
-requires = ["setuptools>=61"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "sam3d-objects-mlx-inference"
-version = "0.1.0"
-description = "Frozen SAM 3D Objects inference using MLX and the Python standard library"
-requires-python = ">=3.10"
-dependencies = ["mlx>=0.32.2"]
-license = {text = "SAM License; Apache-2.0 for MoGe/FlexiCubes"}
-
-[project.scripts]
-sam3d-mlx = "sam3d_objects_mlx.generate:main"
-
-[tool.setuptools.packages.find]
-include = ["sam3d_objects_mlx*"]
-
-[tool.setuptools.package-data]
-sam3d_objects_mlx = ["LICENSE", "LICENSE-APACHE", "README.md"]
-""")
-    card = """---
-library_name: mlx
-pipeline_tag: image-to-3d
-license: other
-license_name: sam-license
-license_link: LICENSE
-base_model:
-  - facebook/sam-3d-objects
-  - Ruicheng/moge-vitl
-tags:
-  - mlx
-  - apple-silicon
-  - bfloat16
-  - image-to-3d
-  - gaussian-splatting
-  - inference
----
-
-# SAM 3D Objects — MLX BF16
-
-Frozen inference port of Meta SAM 3D Objects, including the upstream MoGe-v1
-depth estimator. Runtime and conversion require **MLX and Python's standard
-library only**. This is an unofficial derivative. SAM components retain the
-SAM License; MoGe and FlexiCubes retain Apache-2.0.
-
-The bundle includes 3,709 BF16 tensors, strict loading, MLX sparse convolutions,
-windowed attention, Gaussian and colored-mesh decoding, `mx.async_eval`, and
-synchronous/asynchronous streaming APIs. Both Gaussian heads are included.
-It generates geometry and pose; it has no text or tool-calling interface.
-
-## Install the included runtime
-
-Download this repository, then install its small runtime package:
-
-```sh
-hf download mlx-community/sam-3d-objects-bf16 --local-dir sam-3d-objects-bf16
-python -m pip install ./sam-3d-objects-bf16
-sam3d-mlx --model ./sam-3d-objects-bf16 \\
-  --image image.png --mask mask.png --output ./output \\
-  --formats gaussian mesh
-```
-
-`hf` is an optional download tool; it is not a runtime dependency. The package
-can also be imported directly from the downloaded directory. The same model
-implementation lives under `mlx_vlm/models/sam3d_objects` in the port checkout.
-
-```python
-from sam3d_objects_mlx.io import read_png, read_mask
-from sam3d_objects_mlx.pipeline import Pipeline, Request
-
-pipeline = Pipeline.from_pretrained("sam-3d-objects-bf16")
-image, mask = read_png("image.png")[..., :3], read_mask("mask.png")
-result = pipeline.generate(image, mask, seed=42)
-
-async def reconstruct(requests):
-    async for event in pipeline.astream(requests):
-        if event.stage == "complete":
-            consume(event.data)
-```
-
-`requests` is an iterable or async iterable of `Request` values. Input is
-consumed one request at a time with backpressure. Events preserve IDs and
-order and include every sampling step plus decoded outputs. The event loop
-remains responsive while one worker submits MLX work. Early `aclose()` or
-cancellation stops submissions and drains the worker. Arrays may still be
-evaluating on the GPU when yielded; use `mx.eval` before host consumption.
-
-Inputs are HWC RGB/RGBA MLX arrays and HW masks. The included file reader
-supports non-interlaced 8-bit PNG, including RGBA alpha masks. Callers can use
-other decoders and pass arrays directly. Automatic MoGe depth is included;
-external HWC point maps use +X left, +Y up, +Z forward, with NaN invalid values.
-Set `estimate_depth=False` to use the trained point-map dropout instead.
-
-Results include local-space Gaussians, mesh vertices/faces/colors, latent
-features, occupied voxels, and a separate pose (rotation, translation, scale).
-CLI outputs standard Gaussian PLY, colored OBJ, and raw safetensors.
-`--jsonl` consumes stdin request lines and emits ordered progress records.
-Training, latent training encoders, rendering, texture baking, mesh
-simplification, and iterative layout optimization are not included.
-
-## Conversion and validation
-
-SAM weights were converted directly from the official tensor-only PyTorch
-ZIP checkpoints through a restricted stdlib reader. Tensor bytes are first
-preserved in safetensors, then mapped to MLX layouts and cast to BF16. The
-duplicate occupancy decoder is removed. MoGe uses its original safetensors
-export. No PyTorch or NumPy is imported by conversion or inference.
-
-All parameter names/shapes were checked with strict loading, every floating
-tensor is BF16, and the loaded model has zero trainable parameters. Component
-checks against the original reference in FP32 MLX CPU cover attention, both
-flow models, occupancy decoding, interpolation, pretrained MoGe, and
-FlexiCubes. Maximum absolute error was below 0.000002 on these fixtures;
-mesh face indices matched exactly. This is not a claim of bitwise BF16
-end-to-end parity or a reconstruction-quality evaluation.
-
-See `validation.json`, `conversion.json`, and the included source for details.
-The original sources are [SAM 3D Objects](https://github.com/facebookresearch/sam-3d-objects)
-and [MoGe](https://github.com/microsoft/MoGe).
-"""
-    validation = root / "validation.json"
-    if validation.exists():
-        report = json.loads(validation.read_text())
-        if "benchmark" in report:
-            b = report["benchmark"]
-            card += f"""
-### Local performance
-
-Hardware: {b["hardware"]}. Input: 448×672 RGB plus object mask; automatic MoGe
-depth, 25 structure steps and 25 latent steps, both Gaussian heads and mesh.
-One warmup was excluded; the same seed produced identical latent outputs.
-
-| Metric | Result |
-| --- | ---: |
-| Median latency ({len(b["samples"])} runs) | {b["median_seconds"]:.2f} s |
-| Maximum peak memory | {b["peak_memory_gb"]:.2f} GB |
-
-Two additional async requests matched the synchronous latent output while
-the event-loop heartbeat continued. These measurements describe one input.
-"""
-    (root / "README.md").write_text(card)
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("destination")
-    package(parser.parse_args().destination)
-
-
-if __name__ == "__main__":
-    main()

sam3d_objects_mlx/checkpoint.py

@@ -1,136 +0,0 @@
-"""Read tensor-only torch ZIP checkpoints without importing torch or NumPy.
-
-The restricted unpickler creates metadata, never source classes. Only dense,
-contiguous tensor storages and OrderedDict are accepted. The intermediate
-safetensors file preserves source bytes; MLX handles BF16 conversion later.
-"""
-
-import collections
-import io
-import json
-import math
-import pickle
-import struct
-import zipfile
-from dataclasses import dataclass
-
-DTYPES = {
-    "FloatStorage": ("F32", 4),
-    "HalfStorage": ("F16", 2),
-    "BFloat16Storage": ("BF16", 2),
-    "DoubleStorage": ("F64", 8),
-    "LongStorage": ("I64", 8),
-    "IntStorage": ("I32", 4),
-    "BoolStorage": ("BOOL", 1),
-    "ByteStorage": ("U8", 1),
-}
-
-
-@dataclass
-class Storage:
-    kind: str
-    key: str
-    size: int
-
-
-@dataclass
-class Tensor:
-    storage: Storage
-    offset: int
-    shape: tuple
-    stride: tuple
-
-
-def _tensor(storage, offset, shape, stride, *unused):
-    return Tensor(storage, offset, shape, stride)
-
-
-class TensorUnpickler(pickle.Unpickler):
-    def find_class(self, module, name):
-        if module == "collections" and name == "OrderedDict":
-            return collections.OrderedDict
-        if module == "torch" and name in DTYPES:
-            return name
-        if module == "torch._utils" and name in (
-            "_rebuild_tensor_v2",
-            "_rebuild_tensor",
-        ):
-            return _tensor
-        if module == "torch._utils" and name == "_rebuild_parameter":
-            return lambda tensor, *args: tensor
-        raise pickle.UnpicklingError(f"Unsupported checkpoint global: {module}.{name}")
-
-    def persistent_load(self, value):
-        if (
-            not isinstance(value, tuple)
-            or len(value) != 5
-            or value[0] != "storage"
-            or value[1] not in DTYPES
-        ):
-            raise pickle.UnpicklingError("Unsupported checkpoint storage")
-        return Storage(value[1], str(value[2]), value[4])
-
-
-def read_metadata(archive):
-    names = archive.namelist()
-    candidates = [n for n in names if n.endswith("/data.pkl")]
-    if len(candidates) != 1:
-        raise ValueError("Expected a tensor ZIP checkpoint with one data.pkl")
-    prefix = candidates[0].removesuffix("data.pkl")
-    if (
-        prefix + "byteorder" in names
-        and archive.read(prefix + "byteorder") != b"little"
-    ):
-        raise ValueError("Only little-endian checkpoints are supported")
-    data = TensorUnpickler(io.BytesIO(archive.read(candidates[0]))).load()
-    if "state_dict" in data:
-        data = data["state_dict"]
-    elif "model" in data and "model_config" in data:
-        data = data["model"]
-    # The released structure generator contains non-tensor training metadata.
-    data.pop("__mixhavior__", None)
-    if not isinstance(data, dict) or not all(
-        isinstance(v, Tensor) for v in data.values()
-    ):
-        raise ValueError("Checkpoint must contain only named dense tensors")
-    return prefix, data
-
-
-def to_safetensors(source, destination):
-    """Stream a tensor-only checkpoint to a byte-exact safetensors file."""
-    with zipfile.ZipFile(source) as archive:
-        prefix, tensors = read_metadata(archive)
-        header, offset = {}, 0
-        for name, t in tensors.items():
-            stride = 1
-            for size, actual in zip(reversed(t.shape), reversed(t.stride)):
-                if size > 1 and actual != stride:
-                    raise ValueError(f"Non-contiguous tensor: {name}")
-                stride *= size
-            dtype, width = DTYPES[t.storage.kind]
-            length = math.prod(t.shape) * width
-            if t.offset < 0 or t.offset + math.prod(t.shape) > t.storage.size:
-                raise ValueError(f"Tensor outside storage: {name}")
-            header[name] = {
-                "dtype": dtype,
-                "shape": list(t.shape),
-                "data_offsets": [offset, offset + length],
-            }
-            offset += length
-        encoded = json.dumps(header, separators=(",", ":")).encode()
-        encoded += b" " * (-len(encoded) % 8)
-        with open(destination, "wb") as out:
-            out.write(struct.pack("<Q", len(encoded)))
-            out.write(encoded)
-            for name, t in tensors.items():
-                width = DTYPES[t.storage.kind][1]
-                remaining = math.prod(t.shape) * width
-                with archive.open(prefix + "data/" + t.storage.key) as raw:
-                    raw.seek(t.offset * width)
-                    while remaining:
-                        chunk = raw.read(min(remaining, 8 << 20))
-                        if not chunk:
-                            raise ValueError(f"Truncated storage: {name}")
-                        out.write(chunk)
-                        remaining -= len(chunk)
-    return len(tensors)

sam3d_objects_mlx/config.py

@@ -1,75 +0,0 @@
-"""Inference configuration for Meta SAM 3D Objects."""
-
-from dataclasses import asdict, dataclass, field
-
-
-@dataclass
-class ModelConfig:
-    model_type: str = "sam3d_objects"
-    dtype: str = "bfloat16"
-    hidden_size: int = 1024
-    num_heads: int = 16
-    num_blocks: int = 24
-    cond_channels: int = 1024
-    latent_channels: int = 8
-    latent_resolution: int = 16
-    resolution: int = 64
-    io_channels: int = 128
-    decoder_channels: int = 768
-    decoder_heads: int = 12
-    decoder_blocks: int = 12
-    window_size: int = 8
-    structure_channels: list = field(default_factory=lambda: [512, 128, 32])
-    structure_res_blocks: int = 2
-    dino_hidden_size: int = 1024
-    dino_heads: int = 16
-    dino_layers: int = 24
-    dino_image_size: int = 518
-    image_size: int = 518
-    point_size: int = 256
-    point_patch_size: int = 8
-    point_channels: int = 512
-    point_heads: int = 16
-    # Enable the bundled MoGe-v1 inference model when its weights are present.
-    depth_model: bool = False
-    depth_num_tokens: int = 2551
-    ss_steps: int = 25
-    slat_steps: int = 25
-    ss_guidance: float = 7.0
-    slat_guidance: float = 1.0
-    ss_rescale_t: float = 3.0
-    slat_rescale_t: float = 1.0
-    # Match the released inference pipeline's occupancy pruning.
-    downsample_ss_dist: int = 1
-    slat_mean: list = field(
-        default_factory=lambda: [
-            0.12211431,
-            0.37204156,
-            -1.26521907,
-            -2.05276058,
-            -3.10432536,
-            -0.11294304,
-            -0.85146744,
-            0.45506954,
-        ]
-    )
-    slat_std: list = field(
-        default_factory=lambda: [
-            2.37326008,
-            2.13174402,
-            2.2413953,
-            2.30589401,
-            2.1191894,
-            1.8969511,
-            2.41684989,
-            2.08374642,
-        ]
-    )
-
-    @classmethod
-    def from_dict(cls, values):
-        names = cls.__dataclass_fields__
-        return cls(**{k: v for k, v in values.items() if k in names})
-
-    def to_dict(self):
-        return asdict(self)

sam3d_objects_mlx/convert.py

@@ -1,184 +0,0 @@
-"""Convert released inference checkpoints with MLX and the standard library."""
-
-import argparse
-import json
-import tempfile
-from pathlib import Path
-
-import mlx.core as mx
-
-from .checkpoint import to_safetensors
-from .config import ModelConfig
-
-COMPONENTS = (
-    "ss_generator",
-    "slat_generator",
-    "ss_decoder",
-    "slat_decoder_gs",
-    "slat_decoder_gs_4",
-    "slat_decoder_mesh",
-)
-
-
-def map_tensor(component, name, tensor):
-    if component.endswith("generator"):
-        if name.startswith("_base_models.generator.reverse_fn.backbone."):
-            name = (
-                component
-                + "."
-                + name.removeprefix("_base_models.generator.reverse_fn.backbone.")
-            )
-        elif name.startswith("_base_models.condition_embedder."):
-            name = (
-                component.replace("generator", "condition_embedder")
-                + "."
-                + name.removeprefix("_base_models.condition_embedder.")
-            )
-        elif name.startswith("_base_models.decoder."):
-            # Duplicate occupancy decoder bundled with the structure generator.
-            return None
-        else:
-            raise ValueError(f"Unmapped inference tensor: {name}")
-    else:
-        name = component + "." + name
-    if name.startswith("ss_decoder.") and tensor.ndim == 5:
-        tensor = tensor.transpose(0, 2, 3, 4, 1)
-    elif name.endswith("patch_embed.proj.weight"):
-        tensor = tensor.transpose(0, 2, 3, 1)
-    if mx.issubdtype(tensor.dtype, mx.floating):
-        tensor = tensor.astype(mx.bfloat16)
-    return name, tensor
-
-
-def convert(source, destination):
-    source, destination = Path(source), Path(destination)
-    if (source / "checkpoints").is_dir():
-        source = source / "checkpoints"
-    destination.mkdir(parents=True, exist_ok=True)
-    index, total_size, report = {}, 0, {}
-    for i, component in enumerate(COMPONENTS, 1):
-        checkpoint = source / f"{component}.ckpt"
-        safe = source / f"{component}.safetensors"
-        with tempfile.TemporaryDirectory(prefix="sam3d-convert-") as scratch:
-            if checkpoint.exists():
-                safe = Path(scratch) / "source.safetensors"
-                count = to_safetensors(checkpoint, safe)
-            elif safe.exists():
-                count = None
-            else:
-                raise FileNotFoundError(checkpoint)
-            weights = {}
-            for name, tensor in mx.load(str(safe)).items():
-                mapped = map_tensor(component, name, tensor)
-                if mapped is not None:
-                    key, value = mapped
-                    weights[key] = value
-            mx.async_eval(weights)
-            shard = f"model-{i:05d}-of-{len(COMPONENTS):05d}.safetensors"
-            mx.save_safetensors(
-                str(destination / shard),
-                weights,
-                metadata={"format": "mlx", "dtype": "bfloat16"},
-            )
-            index.update({k: shard for k in weights})
-            total_size += sum(v.nbytes for v in weights.values())
-            report[component] = {
-                "source_tensors": count,
-                "converted_tensors": len(weights),
-                "shard": shard,
-            }
-            print(f"{component}: {len(weights)} tensors -> {shard}", flush=True)
-            del weights
-            mx.clear_cache()
-    (destination / "config.json").write_text(
-        json.dumps(ModelConfig().to_dict(), indent=2) + "\n"
-    )
-    (destination / "model.safetensors.index.json").write_text(
-        json.dumps(
-            {"metadata": {"total_size": total_size}, "weight_map": index}, indent=2
-        )
-        + "\n"
-    )
-    (destination / "conversion.json").write_text(
-        json.dumps(
-            {
-                "source": "facebook/sam-3d-objects",
-                "dtype": "bfloat16",
-                "components": report,
-            },
-            indent=2,
-        )
-        + "\n"
-    )
-    (destination / "LICENSE").write_text(
-        (Path(__file__).parent / "LICENSE").read_text()
-    )
-    return destination
-
-
-def add_depth(source, destination):
-    """Add the released Ruicheng/moge-vitl inference checkpoint to a bundle."""
-    from .depth import DepthModel
-
-    source, destination = Path(source), Path(destination)
-    with tempfile.TemporaryDirectory(prefix="moge-convert-") as scratch:
-        if source.suffix != ".safetensors":
-            raw = Path(scratch) / "moge.safetensors"
-            to_safetensors(source, raw)
-        else:
-            raw = source
-        weights = {}
-        for name, value in mx.load(str(raw)).items():
-            if value.ndim == 4 and name.endswith("weight"):
-                if name.startswith("head.upsample_blocks.") and ".0.0.weight" in name:
-                    value = value.transpose(1, 2, 3, 0)
-                else:
-                    value = value.transpose(0, 2, 3, 1)
-            weights[name] = (
-                value.astype(mx.bfloat16)
-                if mx.issubdtype(value.dtype, mx.floating)
-                else value
-            )
-        model = DepthModel()
-        model.load_weights(list(weights.items()), strict=True)
-        weights = {"depth_model." + k: v for k, v in weights.items()}
-        mx.save_safetensors(str(destination / "moge.safetensors"), weights)
-    index_path = destination / "model.safetensors.index.json"
-    index = json.loads(index_path.read_text())
-    index["weight_map"].update({k: "moge.safetensors" for k in weights})
-    index["metadata"]["total_size"] = sum(
-        p.stat().st_size for p in destination.glob("*.safetensors")
-    )
-    index_path.write_text(json.dumps(index, indent=2) + "\n")
-    path = destination / "config.json"
-    config = json.loads(path.read_text())
-    config["depth_model"] = True
-    path.write_text(json.dumps(config, indent=2) + "\n")
-    (destination / "LICENSE-APACHE").write_text(
-        (Path(__file__).parent / "LICENSE-APACHE").read_text()
-    )
-    print(f"MoGe: {len(weights)} BF16 tensors added", flush=True)
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--source")
-    parser.add_argument("--output", required=True)
-    parser.add_argument(
-        "--moge-checkpoint",
-        help="Optional Ruicheng/moge-vitl model.pt or source safetensors",
-    )
-    args = parser.parse_args()
-    if args.source:
-        convert(args.source, args.output)
-    if args.moge_checkpoint:
-        add_depth(args.moge_checkpoint, args.output)
-    if not args.source and not args.moge_checkpoint:
-        parser.error("Provide --source and/or --moge-checkpoint")
-    from .bundle import package
-
-    package(args.output)
-
-
-if __name__ == "__main__":
-    main()

sam3d_objects_mlx/decoders.py

@@ -1,182 +0,0 @@
-# Adapted from Meta SAM 3D Objects. See LICENSE in this directory.
-"""Occupancy, Gaussian, and mesh-feature inference decoders."""
-
-import math
-
-import mlx.core as mx
-import mlx.nn as nn
-
-from .layers import (
-    Attention,
-    FeedForward,
-    LayerNorm,
-    Sequential,
-    layer_norm,
-    position_embedding,
-)
-from .sparse import SparseConv, SparseGroupNorm, window_attention
-
-
-class DenseResBlock(nn.Module):
-    def __init__(self, channels):
-        super().__init__()
-        self.norm1 = LayerNorm(channels)
-        self.norm2 = LayerNorm(channels)
-        self.conv1 = nn.Conv3d(channels, channels, 3, padding=1)
-        self.conv2 = nn.Conv3d(channels, channels, 3, padding=1)
-
-    def __call__(self, x):
-        return x + self.conv2(nn.silu(self.norm2(self.conv1(nn.silu(self.norm1(x))))))
-
-
-class DenseUpsample(nn.Module):
-    def __init__(self, inputs, outputs):
-        super().__init__()
-        self.conv = nn.Conv3d(inputs, outputs * 8, 3, padding=1)
-
-    def __call__(self, x):
-        x = self.conv(x)
-        b, d, h, w, c = x.shape
-        x = x.reshape(b, d, h, w, c // 8, 2, 2, 2)
-        return x.transpose(0, 1, 5, 2, 6, 3, 7, 4).reshape(
-            b, d * 2, h * 2, w * 2, c // 8
-        )
-
-
-class StructureDecoder(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        channels = config.structure_channels
-        self.input_layer = nn.Conv3d(config.latent_channels, channels[0], 3, padding=1)
-        self.middle_block = Sequential(
-            *(DenseResBlock(channels[0]) for _ in range(config.structure_res_blocks))
-        )
-        self.blocks = []
-        for i, c in enumerate(channels):
-            self.blocks.extend(
-                DenseResBlock(c) for _ in range(config.structure_res_blocks)
-            )
-            if i + 1 < len(channels):
-                self.blocks.append(DenseUpsample(c, channels[i + 1]))
-        self.out_layer = Sequential(
-            LayerNorm(channels[-1]), nn.SiLU(), nn.Conv3d(channels[-1], 1, 3, padding=1)
-        )
-
-    def __call__(self, x):
-        side = round(x.shape[1] ** (1 / 3))
-        x = x.reshape(x.shape[0], side, side, side, x.shape[-1])
-        x = self.middle_block(self.input_layer(x.astype(self.input_layer.weight.dtype)))
-        for block in self.blocks:
-            x = block(x)
-        return self.out_layer(x)
-
-
-class WindowBlock(nn.Module):
-    def __init__(self, channels, heads, window, shift):
-        super().__init__()
-        self.attn = Attention(channels, heads)
-        self.mlp = FeedForward(channels)
-        self._window, self._shift, self._heads = window, shift, heads
-
-    def __call__(self, x, grid):
-        h = self.attn.to_qkv(layer_norm(x, 1e-6)).reshape(
-            x.shape[0], 3, self._heads, -1
-        )
-        h = window_attention(h, grid, self._window, self._shift)
-        x = x + self.attn.to_out(h)
-        return x + self.mlp(layer_norm(x, 1e-6))
-
-
-class DecoderBase(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        c = config.decoder_channels
-        self.input_layer = nn.Linear(config.latent_channels, c)
-        self.blocks = [
-            WindowBlock(
-                c,
-                config.decoder_heads,
-                config.window_size,
-                config.window_size // 2 * (i % 2),
-            )
-            for i in range(config.decoder_blocks)
-        ]
-
-    def encode(self, x, grid):
-        x = self.input_layer(x.astype(self.input_layer.weight.dtype))
-        x = x + position_embedding(grid.coords[:, 1:], x.shape[-1]).astype(x.dtype)
-        for block in self.blocks:
-            x = block(x, grid)
-        return x
-
-
-class GaussianDecoder(DecoderBase):
-    def __init__(self, config, count=32):
-        super().__init__(config)
-        self.out_layer = nn.Linear(config.decoder_channels, 14 * count)
-        self.offset_perturbation = mx.zeros((count, 3))
-        self._count = count
-
-    def __call__(self, x, grid):
-        h = self.out_layer(layer_norm(self.encode(x, grid))).astype(mx.float32)
-        n = self._count
-        xyz, color, scaling, rotation, opacity = mx.split(
-            h, [n * 3, n * 6, n * 9, n * 13], axis=-1
-        )
-        xyz = (
-            grid.coords[:, None, 1:].astype(mx.float32) + 0.5
-        ) / grid.resolution + mx.tanh(
-            xyz.reshape(-1, n, 3) + self.offset_perturbation
-        ) * (
-            0.75 / grid.resolution
-        )
-        scale = nn.softplus(scaling.reshape(-1, 3) + math.log(math.expm1(0.004)))
-        scale = mx.sqrt(scale * scale + 0.0009**2)
-        rotation = rotation.reshape(-1, 4) * 0.1 + mx.array([1, 0, 0, 0])
-        rotation = rotation * mx.rsqrt(
-            mx.maximum(mx.sum(rotation * rotation, axis=-1, keepdims=True), 1e-24)
-        )
-        opacity = mx.sigmoid(opacity.reshape(-1, 1) + math.log(0.1 / 0.9))
-        return {
-            "positions": xyz.reshape(-1, 3) - 0.5,
-            "sh_dc": color.reshape(-1, 3),
-            "scales": scale,
-            "rotations": rotation,
-            "opacities": opacity,
-        }
-
-
-class SubdivideBlock(nn.Module):
-    def __init__(self, input_channels, channels):
-        super().__init__()
-        self.act_layers = Sequential(SparseGroupNorm(input_channels), nn.SiLU())
-        self.out_layers = Sequential(
-            SparseConv(input_channels, channels),
-            SparseGroupNorm(channels),
-            nn.SiLU(),
-            SparseConv(channels, channels),
-        )
-        self.skip_connection = SparseConv(input_channels, channels, kernel=1)
-
-    def __call__(self, x, grid):
-        h = mx.repeat(self.act_layers(x), 8, axis=0)
-        x = mx.repeat(x, 8, axis=0)
-        grid = grid.subdivide()
-        h = self.out_layers["0"](h, grid)
-        h = self.out_layers["2"](self.out_layers["1"](h))
-        h = self.out_layers["3"](h, grid)
-        return h + self.skip_connection(x, grid), grid
-
-
-class MeshDecoder(DecoderBase):
-    def __init__(self, config):
-        super().__init__(config)
-        c = config.decoder_channels
-        self.upsample = [SubdivideBlock(c, c // 4), SubdivideBlock(c // 4, c // 8)]
-        self.out_layer = nn.Linear(c // 8, 101)
-
-    def __call__(self, x, grid):
-        x = self.encode(x, grid)
-        for block in self.upsample:
-            x, grid = block(x, grid)
-        return self.out_layer(x), grid

sam3d_objects_mlx/depth.py

@@ -1,210 +0,0 @@
-# Adapted from microsoft/MoGe (Apache-2.0). See LICENSE-APACHE in this directory.
-"""Frozen MoGe v1 inference used by the released SAM 3D pipeline."""
-
-import math
-from types import SimpleNamespace
-
-import mlx.core as mx
-import mlx.nn as nn
-
-from .layers import Sequential
-from .resize import resize, resize_bicubic
-from .sparse import nonzero
-from .vision import DINOv2
-
-
-def view_plane(height, width, aspect=None):
-    aspect = width / height if aspect is None else aspect
-    x = aspect / math.sqrt(1 + aspect * aspect)
-    y = 1 / math.sqrt(1 + aspect * aspect)
-    u = mx.linspace(-x * (width - 1) / width, x * (width - 1) / width, width)
-    v = mx.linspace(-y * (height - 1) / height, y * (height - 1) / height, height)
-    xx, yy = mx.meshgrid(u, v, indexing="xy")
-    return mx.stack([xx, yy], axis=-1)
-
-
-class GroupNorm(nn.Module):
-    def __init__(self, channels, groups):
-        super().__init__()
-        self.weight = mx.ones(channels)
-        self.bias = mx.zeros(channels)
-        self._groups = groups
-
-    def __call__(self, x):
-        h = x.astype(mx.float32).reshape(
-            x.shape[0], -1, self._groups, x.shape[-1] // self._groups
-        )
-        mean = h.mean(axis=(1, 3), keepdims=True)
-        var = ((h - mean) ** 2).mean(axis=(1, 3), keepdims=True)
-        return (
-            ((h - mean) * mx.rsqrt(var + 1e-5)).reshape(x.shape) * self.weight
-            + self.bias
-        ).astype(x.dtype)
-
-
-class Conv(nn.Conv2d):
-    def __call__(self, x):
-        p = self.weight.shape[1] // 2
-        if p:
-            x = mx.pad(x, [(0, 0), (p, p), (p, p), (0, 0)], mode="edge")
-        return mx.conv2d(x, self.weight) + self.bias
-
-
-class Residual(nn.Module):
-    def __init__(self, channels, multiplier=2):
-        super().__init__()
-        hidden = channels * multiplier
-        self.layers = Sequential(
-            GroupNorm(channels, 1),
-            nn.ReLU(),
-            Conv(channels, hidden, 3),
-            GroupNorm(hidden, hidden // 32),
-            nn.ReLU(),
-            Conv(hidden, channels, 3),
-        )
-
-    def __call__(self, x):
-        return x + self.layers(x)
-
-
-class Head(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.projects = [nn.Conv2d(1024, 512, 1) for _ in range(4)]
-        self.upsample_blocks = [
-            Sequential(
-                Sequential(nn.ConvTranspose2d(i + 2, o, 2, stride=2), Conv(o, o, 3)),
-                Residual(o),
-                Residual(o),
-            )
-            for i, o in zip((512, 256, 128), (256, 128, 64))
-        ]
-        self.output_block = [
-            Sequential(Conv(66, 32, 3), nn.ReLU(), Conv(32, out, 1)) for out in (3, 1)
-        ]
-
-    def __call__(self, features, height, width):
-        x = sum(proj(f) for proj, f in zip(self.projects, features))
-        aspect = width / height
-        for block in self.upsample_blocks:
-            uv = view_plane(x.shape[1], x.shape[2], aspect)[None].astype(x.dtype)
-            x = block(mx.concatenate([x, uv], axis=-1))
-        x = resize(x, height, width)
-        x = mx.concatenate(
-            [x, view_plane(height, width, aspect)[None].astype(x.dtype)], axis=-1
-        )
-        return [block(x) for block in self.output_block]
-
-
-class Backbone(DINOv2):
-    def __init__(self):
-        super().__init__(
-            SimpleNamespace(
-                dino_hidden_size=1024,
-                dino_image_size=518,
-                dino_heads=16,
-                dino_layers=24,
-            )
-        )
-        self.register_tokens = None
-
-    def __call__(self, image):
-        h, w = image.shape[1] // 14, image.shape[2] // 14
-        x = self.patch_embed(image)
-        pos = self.pos_embed[:, 1:].astype(mx.float32).reshape(1, 37, 37, 1024)
-        if h != 37 or w != 37:
-            pos = resize_bicubic(pos, h, w, offset=0.1)
-        pos = mx.concatenate([self.pos_embed[:, :1], pos.reshape(1, -1, 1024)], axis=1)
-        x = mx.concatenate([self.cls_token, x], axis=1) + pos.astype(x.dtype)
-        outputs = []
-        for i, block in enumerate(self.blocks):
-            x = block(x)
-            if i >= 20:
-                outputs.append(self.norm(x)[:, 1:].reshape(1, h, w, 1024))
-        return outputs
-
-
-def recover_focal_shift(points, valid):
-    """One-dimensional damped least squares, with an analytic MLX Jacobian."""
-    h, w = points.shape[:2]
-    selected = nonzero(
-        resize(valid[None, ..., None].astype(mx.float32), 64, 64, nearest=True)[
-            0, ..., 0
-        ]
-        > 0
-    )
-    if selected.size < 2:
-        return mx.array(1.0), mx.array(0.0)
-    xyz = resize(points[None], 64, 64, nearest=True)[0].reshape(-1, 3)[selected]
-    uv = resize(view_plane(h, w)[None], 64, 64, nearest=True)[0].reshape(-1, 2)[
-        selected
-    ]
-
-    def residual(shift):
-        z = xyz[:, 2:3] + shift
-        p = xyz[:, :2] / z
-        dp = -p / z
-        a, b = mx.sum(p * uv), mx.sum(p * p)
-        focal = a / b
-        df = (mx.sum(dp * uv) * b - 2 * a * mx.sum(p * dp)) / (b * b)
-        return focal * p - uv, df * p + focal * dp, focal
-
-    shift, damping = mx.array(0.0), 1e-3
-    error, jac, focal = residual(shift)
-    cost = float(mx.sum(error * error).item())
-    for _ in range(100):
-        a, g = mx.sum(jac * jac), mx.sum(jac * error)
-        improved = False
-        for _ in range(20):
-            candidate = shift - g / (a * (1 + damping) + 1e-12)
-            new_error, new_jac, new_focal = residual(candidate)
-            new_cost = float(mx.sum(new_error * new_error).item())
-            if math.isfinite(new_cost) and new_cost < cost:
-                shift, error, jac, focal = candidate, new_error, new_jac, new_focal
-                if cost - new_cost < 1e-3 * max(cost, 1e-12):
-                    return focal, shift
-                cost, damping, improved = new_cost, max(damping / 10, 1e-12), True
-                break
-            damping *= 10
-        if not improved:
-            break
-    return focal, shift
-
-
-class DepthModel(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.backbone = Backbone()
-        self.head = Head()
-        self.image_mean = mx.array([0.485, 0.456, 0.406]).reshape(1, 3, 1, 1)
-        self.image_std = mx.array([0.229, 0.224, 0.225]).reshape(1, 3, 1, 1)
-
-    def forward(self, image, num_tokens=2551):
-        h, w = image.shape[:2]
-        factor = math.sqrt(num_tokens * 14 * 14 / (h * w))
-        rh, rw = int(h * factor), int(w * factor)
-        x = resize_bicubic(image[None].astype(mx.float32), rh, rw, antialias=True)
-        x = (x - self.image_mean.transpose(0, 2, 3, 1)) / self.image_std.transpose(
-            0, 2, 3, 1
-        )
-        x14 = resize(x, rh // 14 * 14, rw // 14 * 14, antialias=True)
-        features = self.backbone(x14.astype(self.backbone.cls_token.dtype))
-        points, mask = self.head(features, rh, rw)
-        points, mask = (
-            resize(points.astype(mx.float32), h, w)[0],
-            resize(mask.astype(mx.float32), h, w)[0, ..., 0],
-        )
-        z = mx.exp(points[..., 2:])
-        points = mx.concatenate([points[..., :2] * z, z], axis=-1)
-        return points, mask
-
-    def __call__(self, image, num_tokens=2551):
-        image = image[..., :3]
-        if image.dtype == mx.uint8:
-            image = image.astype(mx.float32) / 255
-        points, mask = self.forward(image, num_tokens)
-        valid = mask > 0.5
-        focal, shift = recover_focal_shift(points, valid)
-        points = points + mx.stack([mx.array(0.0), mx.array(0.0), shift])
-        # MoGe/OpenCV to SAM's PyTorch3D camera convention.
-        return mx.where(valid[..., None], points * mx.array([-1, -1, 1]), float("nan"))

sam3d_objects_mlx/flow.py

@@ -1,132 +0,0 @@
-# Adapted from Meta SAM 3D Objects. See LICENSE in this directory.
-"""Structure/pose and sparse-latent flow networks."""
-
-import mlx.core as mx
-import mlx.nn as nn
-
-from .layers import (
-    LayerNorm,
-    ModulatedBlock,
-    Sequential,
-    TimestepEmbedder,
-    layer_norm,
-    position_embedding,
-)
-from .sparse import SparseConv, pool
-
-LATENTS = {
-    "6drotation_normalized": 6,
-    "scale": 3,
-    "shape": 8,
-    "translation": 3,
-    "translation_scale": 1,
-}
-POSE_NAMES = ("6drotation_normalized", "translation", "scale", "translation_scale")
-
-
-class Latent(nn.Module):
-    def __init__(self, input_channels, channels, length):
-        super().__init__()
-        self.input_layer = nn.Linear(input_channels, channels)
-        self.out_layer = nn.Linear(channels, input_channels)
-        self.pos_emb = mx.zeros((length, channels))
-
-    def encode(self, x):
-        return self.input_layer(x) + self.pos_emb[None]
-
-    def decode(self, x):
-        return self.out_layer(layer_norm(x))
-
-
-class StructureFlow(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        c = config.hidden_size
-        self.d_embedder = TimestepEmbedder(c)
-        self.t_embedder = TimestepEmbedder(c)
-        self.latent_mapping = {
-            n: Latent(ch, c, config.latent_resolution**3 if n == "shape" else 1)
-            for n, ch in LATENTS.items()
-        }
-        self.blocks = [
-            ModulatedBlock(
-                c,
-                config.num_heads,
-                config.cond_channels,
-                names=("shape", "6drotation_normalized"),
-            )
-            for _ in range(config.num_blocks)
-        ]
-
-    def __call__(self, latents, time, condition, delta=None):
-        emb = self.t_embedder(time)
-        if delta is not None:
-            emb = emb + self.d_embedder(delta)
-        x = {
-            n: m.encode(latents[n].astype(m.input_layer.weight.dtype))
-            for n, m in self.latent_mapping.items()
-        }
-        h = {
-            "6drotation_normalized": mx.concatenate([x[n] for n in POSE_NAMES], axis=1),
-            "shape": x["shape"],
-        }
-        for block in self.blocks:
-            h = block(h, emb, condition)
-        outputs = {
-            n: self.latent_mapping[n].decode(h["6drotation_normalized"][:, i : i + 1])
-            for i, n in enumerate(POSE_NAMES)
-        }
-        outputs["shape"] = self.latent_mapping["shape"].decode(h["shape"])
-        return outputs
-
-
-class SparseResBlock(nn.Module):
-    def __init__(self, input_channels, channels, time_channels):
-        super().__init__()
-        self.norm1 = LayerNorm(input_channels, eps=1e-6)
-        self.conv1 = SparseConv(input_channels, channels)
-        self.conv2 = SparseConv(channels, channels)
-        self.emb_layers = Sequential(nn.SiLU(), nn.Linear(time_channels, 2 * channels))
-        self.skip_connection = (
-            nn.Linear(input_channels, channels)
-            if channels != input_channels
-            else nn.Identity()
-        )
-
-    def __call__(self, x, grid, time):
-        scale, shift = mx.split(self.emb_layers(time), 2, axis=-1)
-        h = self.conv1(nn.silu(self.norm1(x)), grid)
-        h = layer_norm(h, 1e-6) * (1 + scale) + shift
-        return self.conv2(nn.silu(h), grid) + self.skip_connection(x)
-
-
-class LatentFlow(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        c, io = config.hidden_size, config.io_channels
-        self.t_embedder = TimestepEmbedder(c)
-        self.input_layer = nn.Linear(config.latent_channels, io)
-        self.input_blocks = [SparseResBlock(io, io, c), SparseResBlock(io, c, c)]
-        self.blocks = [
-            ModulatedBlock(c, config.num_heads, config.cond_channels)
-            for _ in range(config.num_blocks)
-        ]
-        self.out_blocks = [SparseResBlock(2 * c, io, c), SparseResBlock(2 * io, io, c)]
-        self.out_layer = nn.Linear(io, config.latent_channels)
-
-    def __call__(self, x, grid, time, condition):
-        x = x.astype(self.input_layer.weight.dtype)
-        h = self.input_layer(x)
-        emb = self.t_embedder(time)
-        skip = self.input_blocks[0](h, grid, emb)
-        h, child, parent = pool(skip, grid)
-        h = self.input_blocks[1](h, child, emb)
-        skip_low = h
-        h = h + position_embedding(child.coords[:, 1:], h.shape[-1]).astype(h.dtype)
-        h = h[None]
-        for block in self.blocks:
-            h = block(h, emb, condition)
-        h = mx.concatenate([h[0], skip_low], axis=-1)[parent]
-        h = self.out_blocks[0](h, grid, emb)
-        h = self.out_blocks[1](mx.concatenate([h, skip], axis=-1), grid, emb)
-        return self.out_layer(layer_norm(h))

sam3d_objects_mlx/generate.py

@@ -1,122 +0,0 @@
-"""CLI for single requests or a JSONL stream of image-to-3D requests."""
-
-import argparse
-import asyncio
-import json
-import sys
-from pathlib import Path
-
-import mlx.core as mx
-from mlx.utils import tree_flatten
-
-from .io import read_mask, read_png, write_gaussians, write_obj
-from .pipeline import Pipeline, Request
-
-
-def _request(values, defaults):
-    image = read_png(values["image"])
-    mask = read_mask(values["mask"]) if values.get("mask") else None
-    pointmap = mx.load(values["pointmap"])["points"] if values.get("pointmap") else None
-    return Request(
-        image,
-        mask,
-        pointmap,
-        request_id=str(values.get("id", "0")),
-        seed=int(values.get("seed", defaults.seed)),
-        ss_steps=defaults.ss_steps,
-        slat_steps=defaults.slat_steps,
-        formats=tuple(defaults.formats),
-        estimate_depth=not defaults.no_depth,
-    )
-
-
-def _save(result, root):
-    root.mkdir(parents=True, exist_ok=True)
-    tensors = {k: v for k, v in tree_flatten(result) if isinstance(v, mx.array)}
-    mx.save_safetensors(str(root / "result.safetensors"), tensors)
-    for kind in ("gaussian", "gaussian_4"):
-        if kind in result:
-            write_gaussians(root / f"{kind}.ply", result[kind])
-    if "mesh" in result:
-        write_obj(root / "mesh.obj", result["mesh"])
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--model", required=True, help="Local converted BF16 bundle")
-    parser.add_argument("--image", help="PNG RGB or RGBA image")
-    parser.add_argument("--mask", help="PNG object mask")
-    parser.add_argument(
-        "--pointmap", help="Safetensors file with an HWC 'points' array"
-    )
-    parser.add_argument(
-        "--jsonl",
-        action="store_true",
-        help="Read JSON requests from stdin and stream JSON progress to stdout",
-    )
-    parser.add_argument("--output", required=True, help="Output directory")
-    parser.add_argument("--seed", type=int, default=42)
-    parser.add_argument("--ss-steps", type=int)
-    parser.add_argument("--slat-steps", type=int)
-    parser.add_argument(
-        "--formats",
-        nargs="+",
-        choices=("gaussian", "gaussian_4", "mesh"),
-        default=["gaussian", "mesh"],
-    )
-    parser.add_argument(
-        "--no-depth",
-        action="store_true",
-        help="Use trained point-map dropout when no map is supplied",
-    )
-    args = parser.parse_args()
-    if not args.jsonl and not args.image:
-        parser.error("Provide --image or --jsonl")
-    pipeline = Pipeline.from_pretrained(args.model)
-    if not args.jsonl:
-        request = _request(
-            {"image": args.image, "mask": args.mask, "pointmap": args.pointmap}, args
-        )
-        for event in pipeline.stream(request):
-            print(
-                json.dumps(
-                    {
-                        "id": event.request_id,
-                        "stage": event.stage,
-                        "step": event.step,
-                        "total_steps": event.total_steps,
-                    }
-                ),
-                flush=True,
-            )
-            if event.stage == "complete":
-                _save(event.data, Path(args.output))
-        return
-
-    async def run():
-        async def requests():
-            while line := await asyncio.to_thread(sys.stdin.readline):
-                if line.strip():
-                    yield _request(json.loads(line), args)
-
-        request_index = 0
-        async for event in pipeline.astream(requests()):
-            record = {
-                "id": event.request_id,
-                "stage": event.stage,
-                "step": event.step,
-                "total_steps": event.total_steps,
-            }
-            if event.stage == "complete":
-                # Input IDs are labels, never filesystem paths.
-                output = Path(args.output) / f"{request_index:06d}"
-                await asyncio.to_thread(_save, event.data, output)
-                record["output"] = str(output)
-                request_index += 1
-            print(json.dumps(record), flush=True)
-
-    asyncio.run(run())
-
-
-if __name__ == "__main__":
-    main()

sam3d_objects_mlx/io.py

@@ -1,154 +0,0 @@
-"""PNG input and binary PLY/OBJ output using only the standard library."""
-
-import struct
-import zlib
-from pathlib import Path
-
-import mlx.core as mx
-
-
-def read_png(path):
-    """Read non-interlaced 8-bit grayscale, RGB, RGBA, or indexed PNG."""
-    raw = Path(path).read_bytes()
-    if raw[:8] != b"\x89PNG\r\n\x1a\n":
-        raise ValueError("Expected a PNG image; other codecs need an external decoder")
-    offset, compressed, palette, transparency = 8, bytearray(), None, None
-    header = None
-    while offset + 12 <= len(raw):
-        length = struct.unpack_from(">I", raw, offset)[0]
-        kind = raw[offset + 4 : offset + 8]
-        data = raw[offset + 8 : offset + 8 + length]
-        if len(data) != length or offset + 12 + length > len(raw):
-            raise ValueError("Truncated PNG chunk")
-        crc = struct.unpack_from(">I", raw, offset + 8 + length)[0]
-        if zlib.crc32(kind + data) & 0xFFFFFFFF != crc:
-            raise ValueError("PNG checksum mismatch")
-        if kind == b"IHDR":
-            header = struct.unpack(">IIBBBBB", data)
-        elif kind == b"IDAT":
-            compressed.extend(data)
-        elif kind == b"PLTE":
-            palette = data
-        elif kind == b"tRNS":
-            transparency = data
-        elif kind == b"IEND":
-            break
-        offset += length + 12
-    if header is None:
-        raise ValueError("PNG has no header")
-    width, height, bits, color, compression, filtering, interlace = header
-    channels = {0: 1, 2: 3, 3: 1, 4: 2, 6: 4}.get(color)
-    if bits != 8 or channels is None or compression or filtering or interlace:
-        raise ValueError("Only non-interlaced 8-bit PNG images are supported")
-    stride = width * channels
-    data = zlib.decompress(compressed)
-    if len(data) != height * (stride + 1):
-        raise ValueError("PNG pixel data has an invalid size")
-    output = bytearray(height * stride)
-    for y in range(height):
-        mode = data[y * (stride + 1)]
-        if mode > 4:
-            raise ValueError("Invalid PNG filter")
-        for x in range(stride):
-            value = data[y * (stride + 1) + x + 1]
-            a = output[y * stride + x - channels] if x >= channels else 0
-            b = output[(y - 1) * stride + x] if y else 0
-            c = output[(y - 1) * stride + x - channels] if y and x >= channels else 0
-            if mode == 1:
-                value += a
-            elif mode == 2:
-                value += b
-            elif mode == 3:
-                value += (a + b) // 2
-            elif mode == 4:
-                p = a + b - c
-                pa, pb, pc = abs(p - a), abs(p - b), abs(p - c)
-                value += a if pa <= pb and pa <= pc else b if pb <= pc else c
-            output[y * stride + x] = value & 255
-    pixels = mx.array(memoryview(output)).reshape(height, width, channels)
-    if color == 3:
-        if palette is None or len(palette) % 3:
-            raise ValueError("Invalid PNG palette")
-        colors = mx.array(memoryview(palette)).reshape(-1, 3)
-        indices = pixels[..., 0].astype(mx.int32)
-        if int(indices.max().item()) >= colors.shape[0]:
-            raise ValueError("PNG palette index out of bounds")
-        pixels = colors[indices]
-        if transparency is not None:
-            alpha = mx.array(
-                list(transparency) + [255] * (colors.shape[0] - len(transparency)),
-                mx.uint8,
-            )
-            pixels = mx.concatenate([pixels, alpha[indices, None]], axis=-1)
-    return pixels
-
-
-def read_mask(path):
-    """Read grayscale masks or the alpha channel of RGBA object cutouts."""
-    pixels = read_png(path)
-    channel = -1 if pixels.shape[-1] in (2, 4) else 0
-    return pixels[..., channel] > 0
-
-
-def write_gaussians(path, gaussian):
-    """Write the standard Gaussian-splat PLY fields (log-scales/logit opacity)."""
-    xyz, scale, opacity = (
-        gaussian["positions"],
-        gaussian["scales"],
-        gaussian["opacities"],
-    )
-    opacity = mx.clip(opacity, 1e-7, 1 - 1e-7)
-    values = mx.concatenate(
-        [
-            xyz,
-            mx.zeros_like(xyz),
-            gaussian["sh_dc"],
-            mx.log(opacity / (1 - opacity)),
-            mx.log(scale),
-            gaussian["rotations"],
-        ],
-        axis=-1,
-    ).astype(mx.float32)
-    fields = [
-        "x",
-        "y",
-        "z",
-        "nx",
-        "ny",
-        "nz",
-        "f_dc_0",
-        "f_dc_1",
-        "f_dc_2",
-        "opacity",
-        "scale_0",
-        "scale_1",
-        "scale_2",
-        "rot_0",
-        "rot_1",
-        "rot_2",
-        "rot_3",
-    ]
-    header = (
-        "ply\nformat binary_little_endian 1.0\n"
-        + f"element vertex {values.shape[0]}\n"
-        + "".join(f"property float {f}\n" for f in fields)
-        + "end_header\n"
-    )
-    with open(path, "wb") as out:
-        out.write(header.encode())
-        for start in range(0, values.shape[0], 16384):
-            for row in values[start : start + 16384].tolist():
-                out.write(struct.pack("<17f", *row))
-
-
-def write_obj(path, mesh):
-    with open(path, "w") as out:
-        vertices = mx.concatenate(
-            [mesh["vertices"], mesh["vertex_colors"][:, :3]], axis=-1
-        )
-        for start in range(0, vertices.shape[0], 16384):
-            for row in vertices[start : start + 16384].tolist():
-                out.write("v " + " ".join(f"{v:.8g}" for v in row) + "\n")
-        for start in range(0, mesh["faces"].shape[0], 16384):
-            for row in mesh["faces"][start : start + 16384].tolist():
-                out.write("f " + " ".join(str(v + 1) for v in row) + "\n")

sam3d_objects_mlx/layers.py

@@ -1,194 +0,0 @@
-# Adapted from Meta SAM 3D Objects. See LICENSE in this directory.
-"""Dense inference layers; all tensors and computation use MLX."""
-
-import math
-
-import mlx.core as mx
-import mlx.nn as nn
-
-
-class Sequential(nn.Module):
-    """Keep the upstream numbered state-dict names."""
-
-    def __init__(self, *layers):
-        super().__init__()
-        for i, layer in enumerate(layers):
-            self[str(i)] = layer
-
-    def __call__(self, x):
-        for layer in self.values():
-            x = layer(x)
-        return x
-
-    def __getitem__(self, key):
-        return super().__getitem__(str(key) if isinstance(key, int) else key)
-
-    def __setitem__(self, key, value):
-        super().__setitem__(str(key) if isinstance(key, int) else key, value)
-
-
-def layer_norm(x, eps=1e-5):
-    return mx.fast.layer_norm(x, None, None, eps)
-
-
-class LayerNorm(nn.LayerNorm):
-    def __call__(self, x):
-        y = super().__call__(x.astype(mx.float32))
-        return y.astype(x.dtype)
-
-
-def position_embedding(coords, channels):
-    dim = channels // 6
-    freq = mx.exp(-math.log(10000) * mx.arange(dim, dtype=mx.float32) / dim)
-    phase = coords.astype(mx.float32)[..., None] * freq
-    out = mx.concatenate([mx.sin(phase), mx.cos(phase)], axis=-1)
-    out = out.reshape(coords.shape[0], -1)
-    return mx.pad(out, [(0, 0), (0, channels - out.shape[-1])])
-
-
-class TimestepEmbedder(nn.Module):
-    def __init__(self, channels):
-        super().__init__()
-        self.mlp = Sequential(
-            nn.Linear(256, channels), nn.SiLU(), nn.Linear(channels, channels)
-        )
-
-    def __call__(self, t):
-        phase = t.reshape(-1, 1).astype(mx.float32) * mx.exp(
-            -math.log(10000) * mx.arange(128, dtype=mx.float32) / 128
-        )
-        x = mx.concatenate([mx.cos(phase), mx.sin(phase)], axis=-1)
-        return self.mlp(x.astype(self.mlp["0"].weight.dtype))
-
-
-class FeedForward(nn.Module):
-    def __init__(self, channels, ratio=4):
-        super().__init__()
-        self.mlp = Sequential(
-            nn.Linear(channels, int(channels * ratio)),
-            nn.GELU(approx="tanh"),
-            nn.Linear(int(channels * ratio), channels),
-        )
-
-    def __call__(self, x):
-        return self.mlp(x)
-
-
-class HeadNorm(nn.Module):
-    def __init__(self, heads, dim):
-        super().__init__()
-        self.gamma = mx.ones((heads, dim))
-
-    def __call__(self, x):
-        xf = x.astype(mx.float32)
-        y = xf * mx.rsqrt(mx.maximum(mx.sum(xf * xf, axis=-1, keepdims=True), 1e-24))
-        return (y * self.gamma * math.sqrt(x.shape[-1])).astype(x.dtype)
-
-
-def attend(q, k, v, mask=None):
-    y = mx.fast.scaled_dot_product_attention(
-        q.transpose(0, 2, 1, 3),
-        k.transpose(0, 2, 1, 3),
-        v.transpose(0, 2, 1, 3),
-        scale=q.shape[-1] ** -0.5,
-        mask=mask,
-    )
-    return y.transpose(0, 2, 1, 3).reshape(q.shape[0], q.shape[1], -1)
-
-
-class Attention(nn.Module):
-    def __init__(self, channels, heads, context_channels=None, qk_norm=False):
-        super().__init__()
-        self.heads = heads
-        if context_channels is None:
-            self.to_qkv = nn.Linear(channels, channels * 3)
-        else:
-            self.to_q = nn.Linear(channels, channels)
-            self.to_kv = nn.Linear(context_channels, channels * 2)
-        if qk_norm:
-            self.q_rms_norm = HeadNorm(heads, channels // heads)
-            self.k_rms_norm = HeadNorm(heads, channels // heads)
-        self.to_out = nn.Linear(channels, channels)
-
-    def __call__(self, x, context=None, mask=None):
-        b, n, c = x.shape
-        if context is None:
-            qkv = self.to_qkv(x).reshape(b, n, 3, self.heads, -1)
-            q, k, v = (qkv[:, :, i] for i in range(3))
-        else:
-            q = self.to_q(x).reshape(b, n, self.heads, -1)
-            kv = self.to_kv(context).reshape(b, -1, 2, self.heads, c // self.heads)
-            k, v = kv[:, :, 0], kv[:, :, 1]
-        if "q_rms_norm" in self:
-            q, k = self.q_rms_norm(q), self.k_rms_norm(k)
-        return self.to_out(attend(q, k, v, mask))
-
-
-class MOTAttention(nn.Module):
-    def __init__(self, channels, heads, names):
-        super().__init__()
-        self.heads = heads
-        self.to_qkv = {n: nn.Linear(channels, 3 * channels) for n in names}
-        self.to_out = {n: nn.Linear(channels, channels) for n in names}
-        self.q_rms_norm = {n: HeadNorm(heads, channels // heads) for n in names}
-        self.k_rms_norm = {n: HeadNorm(heads, channels // heads) for n in names}
-
-    def __call__(self, x):
-        q, k, v = {}, {}, {}
-        for name, value in x.items():
-            qkv = self.to_qkv[name](value).reshape(*value.shape[:2], 3, self.heads, -1)
-            q[name] = self.q_rms_norm[name](qkv[:, :, 0])
-            k[name] = self.k_rms_norm[name](qkv[:, :, 1])
-            v[name] = qkv[:, :, 2]
-        out = {
-            "shape": self.to_out["shape"](attend(q["shape"], k["shape"], v["shape"]))
-        }
-        others = [n for n in x if n != "shape"]
-        keys = mx.concatenate([k[n] for n in others] + [k["shape"]], axis=1)
-        vals = mx.concatenate([v[n] for n in others] + [v["shape"]], axis=1)
-        for n in others:
-            out[n] = self.to_out[n](attend(q[n], keys, vals))
-        return out
-
-
-class ModulatedBlock(nn.Module):
-    def __init__(self, channels, heads, context_channels, names=None):
-        super().__init__()
-        self.adaLN_modulation = Sequential(nn.SiLU(), nn.Linear(channels, 6 * channels))
-        if names is None:
-            self.norm2 = LayerNorm(channels, eps=1e-6)
-            self.self_attn = Attention(channels, heads, qk_norm=True)
-            self.cross_attn = Attention(channels, heads, context_channels)
-            self.mlp = FeedForward(channels)
-        else:
-            self.norm2 = {n: LayerNorm(channels, eps=1e-6) for n in names}
-            self.self_attn = MOTAttention(channels, heads, names)
-            self.cross_attn = {
-                n: Attention(channels, heads, context_channels) for n in names
-            }
-            self.mlp = {n: FeedForward(channels) for n in names}
-
-    def __call__(self, x, time, context):
-        shift, scale, gate, shift_mlp, scale_mlp, gate_mlp = [
-            v[:, None] for v in mx.split(self.adaLN_modulation(time), 6, axis=-1)
-        ]
-        if isinstance(x, dict):
-            h = self.self_attn(
-                {n: layer_norm(v, 1e-6) * (1 + scale) + shift for n, v in x.items()}
-            )
-            x = {n: v + h[n] * gate for n, v in x.items()}
-            x = {
-                n: v + self.cross_attn[n](self.norm2[n](v), context)
-                for n, v in x.items()
-            }
-            return {
-                n: v
-                + self.mlp[n](layer_norm(v, 1e-6) * (1 + scale_mlp) + shift_mlp)
-                * gate_mlp
-                for n, v in x.items()
-            }
-        x = x + self.self_attn(layer_norm(x, 1e-6) * (1 + scale) + shift) * gate
-        x = x + self.cross_attn(self.norm2(x), context)
-        return (
-            x + self.mlp(layer_norm(x, 1e-6) * (1 + scale_mlp) + shift_mlp) * gate_mlp
-        )

sam3d_objects_mlx/mesh.py

@@ -1,223 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
-# FlexiCubes portions adapted under Apache-2.0; see mesh_tables.py.
-"""Inference-only FlexiCubes extraction on a sparse MLX grid."""
-
-import mlx.core as mx
-
-from .mesh_tables import check_table, dmc_table, num_vd_table
-from .sparse import nonzero
-
-CORNERS = (
-    (0, 0, 0),
-    (1, 0, 0),
-    (0, 1, 0),
-    (1, 1, 0),
-    (0, 0, 1),
-    (1, 0, 1),
-    (0, 1, 1),
-    (1, 1, 1),
-)
-EDGES = (0, 1, 1, 5, 4, 5, 0, 4, 2, 3, 3, 7, 6, 7, 2, 6, 2, 0, 3, 1, 7, 5, 6, 4)
-
-
-def _keys(x, resolution):
-    return (x[..., 0] * resolution + x[..., 1]) * resolution + x[..., 2]
-
-
-def _decode(keys, resolution):
-    return mx.stack(
-        [
-            keys // (resolution * resolution),
-            keys // resolution % resolution,
-            keys % resolution,
-        ],
-        axis=-1,
-    )
-
-
-def unique(keys):
-    """Sorted unique keys and inverse indices, without NumPy."""
-    order = mx.argsort(keys)
-    sorted_keys = keys[order]
-    start = mx.concatenate([mx.array([True]), sorted_keys[1:] != sorted_keys[:-1]])
-    first = nonzero(start)
-    groups = mx.cumsum(start.astype(mx.int32)) - 1
-    inverse = mx.zeros(keys.size, mx.int32).at[order].add(groups)
-    return sorted_keys[first], inverse
-
-
-def _lookup(keys, query):
-    idx = mx.minimum(mx.searchsorted(keys, query.reshape(-1)), keys.size - 1).reshape(
-        query.shape
-    )
-    return mx.where(keys[idx] == query, idx, keys.size)
-
-
-def _empty():
-    return {
-        "vertices": mx.zeros((0, 3)),
-        "faces": mx.zeros((0, 3), mx.int32),
-        "vertex_colors": mx.zeros((0, 6)),
-    }
-
-
-def extract_mesh(features, grid):
-    """Decode all learned SDF, deformation, alpha/beta/gamma and color values.
-
-    Candidate cubes include neighbors of predicted vertices. This matches
-    the dense reference's default +1 SDF outside the sparse prediction.
-    """
-    if not features.shape[0]:
-        return _empty()
-    r = grid.resolution
-    coords = grid.coords[:, 1:]
-    f = features.astype(mx.float32)
-    corner = mx.array(CORNERS, dtype=mx.int32)
-    vkeys, inverse = unique(_keys(coords[:, None] + corner[None], r + 1).reshape(-1))
-    values = mx.concatenate(
-        [
-            f[:, :8, None] - 1 / r,
-            f[:, 8:32].reshape(-1, 8, 3),
-            f[:, 53:].reshape(-1, 8, 6),
-        ],
-        axis=-1,
-    ).reshape(-1, 10)
-    sums = mx.zeros((vkeys.size, 10)).at[inverse].add(values)
-    counts = mx.zeros((vkeys.size, 1)).at[inverse].add(mx.ones((inverse.size, 1)))
-    attrs = sums / counts
-    vcoords = _decode(vkeys, r + 1)
-    candidates = (vcoords[:, None] - corner[None]).reshape(-1, 3)
-    valid = nonzero(mx.all((candidates >= 0) & (candidates < r), axis=-1))
-    ckeys, _ = unique(_keys(candidates[valid], r))
-    ccoords = _decode(ckeys, r)
-    corners_keys = _keys(ccoords[:, None] + corner[None], r + 1)
-    lookup = _lookup(vkeys, corners_keys)
-    sdf = mx.concatenate([attrs[:, 0], mx.ones(1)])
-    occupancy = sdf[lookup] < 0
-    sums_occ = occupancy.sum(axis=-1)
-    surface = nonzero((sums_occ > 0) & (sums_occ < 8))
-    if not surface.size:
-        return _empty()
-    ccoords, ckeys = ccoords[surface], ckeys[surface]
-    corners_keys = corners_keys[surface]
-    cases = mx.sum(
-        occupancy[surface] * mx.array([1, 2, 4, 8, 16, 32, 64, 128]), axis=-1
-    )
-    # Resolve the ambiguous C16/C19 cases against adjacent surface cubes.
-    checks = mx.array(check_table, mx.int32)[cases]
-    adjacent = ccoords + checks[:, 1:4]
-    adjacent_index = _lookup(ckeys, _keys(adjacent, r))
-    problem_flags = mx.concatenate([checks[:, 0], mx.zeros(1, mx.int32)])
-    invert = (
-        (checks[:, 0] == 1)
-        & mx.all((adjacent >= 0) & (adjacent < r), axis=-1)
-        & (problem_flags[adjacent_index] == 1)
-    )
-    cases = mx.where(invert, checks[:, -1], cases)
-
-    # Retain the dense reference's vertex IDs, including default vertices.
-    all_vkeys, cube_idx = unique(corners_keys.reshape(-1))
-    cube_idx = cube_idx.reshape(-1, 8)
-    attr_indices = _lookup(vkeys, all_vkeys)
-    default_attr = mx.array([[1.0] + [0.0] * 9])
-    attrs = mx.concatenate([attrs, default_attr])[attr_indices]
-    vertices = (
-        _decode(all_vkeys, r + 1).astype(mx.float32) / r
-        - 0.5
-        + mx.tanh(attrs[:, 1:4]) * ((1 - 1e-8) / (r * 2))
-    )
-    sdf, colors = attrs[:, 0], mx.sigmoid(attrs[:, 4:])
-    source_keys = _keys(coords, r)
-    source_order = mx.argsort(source_keys)
-    weight_indices = _lookup(source_keys[source_order], ckeys)
-    weights = mx.concatenate([f[source_order, 32:53], mx.zeros((1, 21))])[
-        weight_indices
-    ]
-    beta, alpha = 1 + 0.99 * mx.tanh(weights[:, :12]), 1 + 0.99 * mx.tanh(
-        weights[:, 12:20]
-    )
-    gamma = 0.99 * mx.sigmoid(weights[:, 20]) + 0.005
-    edges = mx.array(EDGES, mx.int32)
-    all_edges = cube_idx[:, edges].reshape(-1, 2)
-    edge_keys = all_edges[:, 0].astype(mx.int64) * all_vkeys.size + all_edges[:, 1]
-    unique_edge_keys, edge_inverse = unique(edge_keys)
-    unique_edges = mx.stack(
-        [unique_edge_keys // all_vkeys.size, unique_edge_keys % all_vkeys.size], axis=-1
-    ).astype(mx.int32)
-    crossing = mx.sum(sdf[unique_edges] < 0, axis=-1) == 1
-    cross_ids = nonzero(crossing)
-    surface_edges = unique_edges[cross_ids]
-    mapping = mx.full((unique_edges.shape[0],), -1, mx.int32)
-    mapping[cross_ids] = mx.arange(cross_ids.size)
-    idx_map = mapping[edge_inverse].reshape(-1, 12)
-    edge_counts = (
-        mx.zeros((unique_edges.shape[0],), mx.int32)
-        .at[edge_inverse]
-        .add(mx.ones(edge_inverse.size, mx.int32))[edge_inverse]
-    )
-
-    # Each topology emits one to four dual vertices; seven edges per group.
-    table = mx.array(dmc_table, mx.int32)
-    numbers = mx.array(num_vd_table, mx.int32)[cases]
-    edge_group, group_vertex, group_cube, gamma_parts = [], [], [], []
-    total = 0
-    for number in range(1, 5):
-        cubes = nonzero(numbers == number)
-        if not cubes.size:
-            continue
-        group = table[cases[cubes], :number].reshape(-1, 7)
-        valid = nonzero(group >= 0)
-        edge_group.append(group.reshape(-1)[valid])
-        group_vertex.append(mx.repeat(mx.arange(group.shape[0]) + total, 7)[valid])
-        group_cube.append(mx.repeat(cubes, number * 7)[valid])
-        gamma_parts.append(mx.repeat(gamma[cubes], number))
-        total += group.shape[0]
-    edge_group, group_vertex, group_cube = (
-        mx.concatenate(x) for x in (edge_group, group_vertex, group_cube)
-    )
-    vd_gamma = mx.concatenate(gamma_parts)
-    selected = idx_map[group_cube, edge_group]
-    pair = surface_edges[selected]
-    alpha_pair = alpha[:, edges].reshape(-1, 12, 2)[group_cube, edge_group]
-    signed = sdf[pair] * alpha_pair
-    interp = mx.stack([signed[:, 1], -signed[:, 0]], axis=-1)
-    interp = interp / interp.sum(axis=-1, keepdims=True)
-    crossing_vertices = mx.sum(vertices[pair] * interp[..., None], axis=1)
-    crossing_colors = mx.sum(colors[pair] * interp[..., None], axis=1)
-    weight = beta[group_cube, edge_group, None]
-    denominator = mx.zeros((total, 1)).at[group_vertex].add(weight)
-    vd = (
-        mx.zeros((total, 3)).at[group_vertex].add(crossing_vertices * weight)
-        / denominator
-    )
-    vd_colors = (
-        mx.zeros((total, colors.shape[-1]))
-        .at[group_vertex]
-        .add(crossing_colors * weight)
-        / denominator
-    )
-    vd_idx = mx.zeros((cases.size * 12,), mx.int32)
-    vd_idx[group_cube * 12 + edge_group] = group_vertex
-
-    group_mask = nonzero((edge_counts == 4) & crossing[edge_inverse])
-    group = idx_map.reshape(-1)[group_mask]
-    # Explicit tie breaker gives the stable edge order used by the reference.
-    order = mx.argsort(group.astype(mx.int64) * group.size + mx.arange(group.size))
-    quads = vd_idx[group_mask][order].reshape(-1, 4)
-    edge_ids = group[order].reshape(-1, 4)[:, 0]
-    flip = sdf[surface_edges[edge_ids, 0]] > 0
-    quads = mx.concatenate(
-        [
-            quads[nonzero(flip)][:, mx.array([0, 1, 3, 2])],
-            quads[nonzero(~flip)][:, mx.array([2, 3, 1, 0])],
-        ]
-    )
-    g = vd_gamma[quads]
-    split = g[:, 0] * g[:, 2] > g[:, 1] * g[:, 3]
-    faces = mx.where(
-        split[:, None],
-        quads[:, mx.array([0, 1, 2, 0, 2, 3])],
-        quads[:, mx.array([0, 1, 3, 3, 1, 2])],
-    ).reshape(-1, 3)
-    return {"vertices": vd, "faces": faces.astype(mx.int32), "vertex_colors": vd_colors}

sam3d_objects_mlx/mesh_tables.py

@@ -1,2327 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
-# All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-dmc_table = [
-    [
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 8, 9, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 7, 8, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 4, 7, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [4, 7, 8, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 4, 7, 9, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 9, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [4, 5, 9, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 4, 5, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 4, 5, 8, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [5, 7, 8, 9, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 5, 7, 9, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 5, 7, 8, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 5, 7, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 8, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 8, 9, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 7, 8, -1, -1, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 4, 7, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [4, 7, 8, -1, -1, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 4, 7, 9, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 9, -1, -1, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 8, 11, -1, -1, -1],
-        [4, 5, 9, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 4, 5, -1, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 4, 5, 8, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [5, 7, 8, 9, -1, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 5, 7, 9, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 5, 7, 8, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 5, 7, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 9, 10, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 8, 9, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 7, 8, -1, -1, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 4, 7, -1, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 9, 10, -1, -1, -1],
-        [4, 7, 8, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 4, 7, 9, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 9, -1, -1, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [4, 5, 9, -1, -1, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 4, 5, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 4, 5, 8, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [5, 7, 8, 9, -1, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 5, 7, 9, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 5, 7, 8, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 5, 7, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 10, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 8, 10, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 9, 10, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [8, 9, 10, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 7, 8, -1, -1, -1, -1],
-        [1, 3, 10, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 4, 7, 10, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 9, 10, 11, -1, -1],
-        [4, 7, 8, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 7, 9, 10, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 9, -1, -1, -1, -1],
-        [1, 3, 10, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 8, 10, 11, -1, -1],
-        [4, 5, 9, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 4, 5, 10, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 8, 10, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [5, 7, 8, 9, -1, -1, -1],
-        [1, 3, 10, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 5, 7, 9, 10, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 5, 7, 8, 10, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [5, 7, 10, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 8, 9, -1, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 6, 8, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 4, 6, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [4, 6, 8, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 4, 6, 9, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 9, -1, -1, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [4, 5, 9, -1, -1, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 4, 5, -1, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 4, 5, 8, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [5, 6, 8, 9, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 5, 6, 9, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 5, 6, 8, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 5, 6, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 6, 7, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 6, 7, 8, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [2, 3, 6, 7, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 6, 7, 8, 9, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 4, 6, 8, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 4, 6, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [2, 3, 4, 6, 8, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 4, 6, 9, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 9, -1, -1, -1, -1],
-        [2, 3, 6, 7, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 6, 7, 8, -1, -1],
-        [4, 5, 9, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 4, 5, -1, -1, -1],
-        [2, 3, 6, 7, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 4, 5, 6, 7, 8],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 5, 6, 8, 9, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 5, 6, 9, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 2, 3, 5, 6, 8],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 5, 6, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 10, -1, -1, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 9, 10, -1, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 8, 9, 10, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 6, 8, 11, -1, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 4, 6, 11, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 9, 10, -1, -1, -1],
-        [4, 6, 8, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 4, 6, 9, 10, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 9, -1, -1, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [4, 5, 9, -1, -1, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 4, 5, 10, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 4, 5, 8, 10, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [5, 6, 8, 9, 11, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 5, 6, 9, 11, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 5, 6, 8, 10, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 5, 6, 10, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 6, 7, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 6, 7, 8, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 6, 7, 9, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [6, 7, 8, 9, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 4, 6, 8, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 4, 6, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 4, 6, 8, 9, 10],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 6, 9, 10, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 9, -1, -1, -1, -1],
-        [1, 3, 6, 7, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 6, 7, 8, 10, -1],
-        [4, 5, 9, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 4, 5, 6, 7, 10],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 6, 7, 8, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 5, 6, 8, 9, 10],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 5, 6, 9, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 8, 9, -1, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 7, 8, -1, -1, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 4, 7, -1, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [4, 7, 8, -1, -1, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 4, 7, 9, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 6, 9, 10, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [4, 6, 9, 10, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 4, 6, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 4, 6, 8, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [6, 7, 8, 9, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 6, 7, 9, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 6, 7, 8, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 6, 7, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 11, -1, -1, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 8, 11, -1, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 8, 9, 11, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 7, 8, -1, -1, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 4, 7, 11, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [4, 7, 8, -1, -1, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 4, 7, 9, 11, -1],
-        [5, 6, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 6, 9, 10, -1, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 8, 11, -1, -1, -1],
-        [4, 6, 9, 10, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 4, 6, 10, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 4, 6, 8, 10, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [6, 7, 8, 9, 10, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 6, 7, 9, 10, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 6, 7, 8, 10, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 6, 7, 10, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 5, 6, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [1, 2, 5, 6, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 5, 6, 9, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 5, 6, 8, 9, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 7, 8, -1, -1, -1, -1],
-        [1, 2, 5, 6, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 4, 7, -1, -1, -1],
-        [1, 2, 5, 6, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 5, 6, 9, -1, -1],
-        [4, 7, 8, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 4, 5, 6, 7, 9],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 4, 6, 9, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [1, 2, 4, 6, 9, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 4, 6, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 4, 6, 8, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 6, 7, 8, 9, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 2, 3, 6, 7, 9],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 6, 7, 8, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 6, 7, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 5, 6, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 5, 6, 8, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 5, 6, 9, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [5, 6, 8, 9, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 7, 8, -1, -1, -1, -1],
-        [1, 3, 5, 6, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 4, 5, 6, 7, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 5, 6, 9, 11, -1],
-        [4, 7, 8, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 6, 7, 9, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 4, 6, 9, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 4, 6, 8, 9, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 4, 6, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 6, 8, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 6, 7, 8, 9, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 6, 7, 8, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [6, 7, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [5, 7, 10, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [5, 7, 10, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [5, 7, 10, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 8, 9, -1, -1, -1],
-        [5, 7, 10, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 8, 10, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 4, 5, 10, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [4, 5, 8, 10, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 4, 5, 9, 10, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 7, 9, 10, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [4, 7, 9, 10, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 4, 7, 10, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 4, 7, 8, 10, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [8, 9, 10, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 9, 10, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 8, 10, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 10, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 5, 7, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 5, 7, 8, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [2, 3, 5, 7, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 5, 7, 8, 9, 10],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 4, 5, 8, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 4, 5, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [2, 3, 4, 5, 8, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 4, 5, 9, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 4, 7, 9, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 4, 7, 8, 9, 10],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 2, 3, 4, 7, 10],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 7, 8, -1, -1, -1, -1],
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 8, 9, 10, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 9, 10, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 2, 3, 8, 10, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 10, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 5, 7, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [1, 2, 5, 7, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 5, 7, 9, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 5, 7, 8, 9, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 4, 5, 8, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 2, 3, 4, 5, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 4, 5, 8, 9, 11],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 9, -1, -1, -1, -1],
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 4, 7, 9, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [1, 2, 4, 7, 9, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 4, 7, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 4, 7, 8, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 2, 8, 9, 11, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 2, 3, 9, 11, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 2, 8, 11, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [2, 3, 11, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 5, 7, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 5, 7, 8, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 5, 7, 9, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [5, 7, 8, 9, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 4, 5, 8, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 4, 5, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 4, 5, 8, 9, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 5, 9, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 4, 7, 9, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 4, 7, 8, 9, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 4, 7, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [4, 7, 8, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [1, 3, 8, 9, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 1, 9, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [0, 3, 8, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-    [
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-        [-1, -1, -1, -1, -1, -1, -1],
-    ],
-]
-num_vd_table = [
-    0,
-    1,
-    1,
-    1,
-    1,
-    1,
-    2,
-    1,
-    1,
-    2,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    2,
-    1,
-    2,
-    1,
-    3,
-    1,
-    2,
-    2,
-    2,
-    1,
-    2,
-    1,
-    2,
-    1,
-    1,
-    2,
-    1,
-    1,
-    2,
-    2,
-    2,
-    1,
-    2,
-    3,
-    1,
-    1,
-    2,
-    2,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    2,
-    1,
-    2,
-    1,
-    2,
-    2,
-    1,
-    1,
-    2,
-    1,
-    1,
-    1,
-    1,
-    2,
-    2,
-    2,
-    1,
-    1,
-    2,
-    1,
-    2,
-    3,
-    2,
-    2,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    2,
-    1,
-    1,
-    1,
-    2,
-    1,
-    2,
-    2,
-    2,
-    1,
-    1,
-    1,
-    1,
-    1,
-    2,
-    3,
-    2,
-    2,
-    2,
-    2,
-    2,
-    1,
-    3,
-    4,
-    2,
-    2,
-    2,
-    2,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    2,
-    2,
-    1,
-    1,
-    1,
-    1,
-    2,
-    1,
-    1,
-    2,
-    2,
-    2,
-    2,
-    2,
-    3,
-    2,
-    1,
-    2,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    2,
-    2,
-    3,
-    2,
-    3,
-    2,
-    4,
-    2,
-    2,
-    2,
-    2,
-    1,
-    2,
-    1,
-    2,
-    1,
-    1,
-    2,
-    1,
-    1,
-    2,
-    2,
-    2,
-    1,
-    1,
-    2,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    2,
-    1,
-    2,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    2,
-    1,
-    1,
-    1,
-    2,
-    2,
-    2,
-    1,
-    1,
-    2,
-    1,
-    1,
-    2,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    2,
-    1,
-    1,
-    1,
-    2,
-    1,
-    1,
-    1,
-    1,
-    2,
-    1,
-    1,
-    1,
-    1,
-    1,
-    2,
-    1,
-    1,
-    1,
-    1,
-    1,
-    2,
-    1,
-    2,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    0,
-]
-check_table = [
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 1, 0, 0, 194],
-    [1, -1, 0, 0, 193],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 0, 1, 0, 164],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 0, -1, 0, 161],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 0, 0, 1, 152],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 0, 0, 1, 145],
-    [1, 0, 0, 1, 144],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 0, 0, -1, 137],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 0, 1, 0, 133],
-    [1, 0, 1, 0, 132],
-    [1, 1, 0, 0, 131],
-    [1, 1, 0, 0, 130],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 0, 0, 1, 100],
-    [0, 0, 0, 0, 0],
-    [1, 0, 0, 1, 98],
-    [0, 0, 0, 0, 0],
-    [1, 0, 0, 1, 96],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 0, 1, 0, 88],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 0, -1, 0, 82],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 0, 1, 0, 74],
-    [0, 0, 0, 0, 0],
-    [1, 0, 1, 0, 72],
-    [0, 0, 0, 0, 0],
-    [1, 0, 0, -1, 70],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, -1, 0, 0, 67],
-    [0, 0, 0, 0, 0],
-    [1, -1, 0, 0, 65],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 1, 0, 0, 56],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, -1, 0, 0, 52],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 1, 0, 0, 44],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 1, 0, 0, 40],
-    [0, 0, 0, 0, 0],
-    [1, 0, 0, -1, 38],
-    [1, 0, -1, 0, 37],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 0, -1, 0, 33],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, -1, 0, 0, 28],
-    [0, 0, 0, 0, 0],
-    [1, 0, -1, 0, 26],
-    [1, 0, 0, -1, 25],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, -1, 0, 0, 20],
-    [0, 0, 0, 0, 0],
-    [1, 0, -1, 0, 18],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 0, 0, -1, 9],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [1, 0, 0, -1, 6],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0],
-]
-tet_table = [
-    [-1, -1, -1, -1, -1, -1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [1, 1, 1, 1, 1, 1],
-    [4, 4, 4, 4, 4, 4],
-    [0, 0, 0, 0, 0, 0],
-    [4, 0, 0, 4, 4, -1],
-    [1, 1, 1, 1, 1, 1],
-    [4, 4, 4, 4, 4, 4],
-    [0, 4, 0, 4, 4, -1],
-    [0, 0, 0, 0, 0, 0],
-    [1, 1, 1, 1, 1, 1],
-    [5, 5, 5, 5, 5, 5],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [1, 1, 1, 1, 1, 1],
-    [2, 2, 2, 2, 2, 2],
-    [0, 0, 0, 0, 0, 0],
-    [2, 0, 2, -1, 0, 2],
-    [1, 1, 1, 1, 1, 1],
-    [2, -1, 2, 4, 4, 2],
-    [0, 0, 0, 0, 0, 0],
-    [2, 0, 2, 4, 4, 2],
-    [1, 1, 1, 1, 1, 1],
-    [2, 4, 2, 4, 4, 2],
-    [0, 4, 0, 4, 4, 0],
-    [2, 0, 2, 0, 0, 2],
-    [1, 1, 1, 1, 1, 1],
-    [2, 5, 2, 5, 5, 2],
-    [0, 0, 0, 0, 0, 0],
-    [2, 0, 2, 0, 0, 2],
-    [1, 1, 1, 1, 1, 1],
-    [1, 1, 1, 1, 1, 1],
-    [0, 1, 1, -1, 0, 1],
-    [0, 0, 0, 0, 0, 0],
-    [2, 2, 2, 2, 2, 2],
-    [4, 1, 1, 4, 4, 1],
-    [0, 1, 1, 0, 0, 1],
-    [4, 0, 0, 4, 4, 0],
-    [2, 2, 2, 2, 2, 2],
-    [-1, 1, 1, 4, 4, 1],
-    [0, 1, 1, 4, 4, 1],
-    [0, 0, 0, 0, 0, 0],
-    [2, 2, 2, 2, 2, 2],
-    [5, 1, 1, 5, 5, 1],
-    [0, 1, 1, 0, 0, 1],
-    [0, 0, 0, 0, 0, 0],
-    [2, 2, 2, 2, 2, 2],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [8, 8, 8, 8, 8, 8],
-    [1, 1, 1, 4, 4, 1],
-    [0, 0, 0, 0, 0, 0],
-    [4, 0, 0, 4, 4, 0],
-    [4, 4, 4, 4, 4, 4],
-    [1, 1, 1, 4, 4, 1],
-    [0, 4, 0, 4, 4, 0],
-    [0, 0, 0, 0, 0, 0],
-    [4, 4, 4, 4, 4, 4],
-    [1, 1, 1, 5, 5, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [5, 5, 5, 5, 5, 5],
-    [6, 6, 6, 6, 6, 6],
-    [6, -1, 0, 6, 0, 6],
-    [6, 0, 0, 6, 0, 6],
-    [6, 1, 1, 6, 1, 6],
-    [4, 4, 4, 4, 4, 4],
-    [0, 0, 0, 0, 0, 0],
-    [4, 0, 0, 4, 4, 4],
-    [1, 1, 1, 1, 1, 1],
-    [6, 4, -1, 6, 4, 6],
-    [6, 4, 0, 6, 4, 6],
-    [6, 0, 0, 6, 0, 6],
-    [6, 1, 1, 6, 1, 6],
-    [5, 5, 5, 5, 5, 5],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [1, 1, 1, 1, 1, 1],
-    [2, 2, 2, 2, 2, 2],
-    [0, 0, 0, 0, 0, 0],
-    [2, 0, 2, 2, 0, 2],
-    [1, 1, 1, 1, 1, 1],
-    [2, 2, 2, 2, 2, 2],
-    [0, 0, 0, 0, 0, 0],
-    [2, 0, 2, 2, 2, 2],
-    [1, 1, 1, 1, 1, 1],
-    [2, 4, 2, 2, 4, 2],
-    [0, 4, 0, 4, 4, 0],
-    [2, 0, 2, 2, 0, 2],
-    [1, 1, 1, 1, 1, 1],
-    [2, 2, 2, 2, 2, 2],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [1, 1, 1, 1, 1, 1],
-    [6, 1, 1, 6, -1, 6],
-    [6, 1, 1, 6, 0, 6],
-    [6, 0, 0, 6, 0, 6],
-    [6, 2, 2, 6, 2, 6],
-    [4, 1, 1, 4, 4, 1],
-    [0, 1, 1, 0, 0, 1],
-    [4, 0, 0, 4, 4, 4],
-    [2, 2, 2, 2, 2, 2],
-    [6, 1, 1, 6, 4, 6],
-    [6, 1, 1, 6, 4, 6],
-    [6, 0, 0, 6, 0, 6],
-    [6, 2, 2, 6, 2, 6],
-    [5, 1, 1, 5, 5, 1],
-    [0, 1, 1, 0, 0, 1],
-    [0, 0, 0, 0, 0, 0],
-    [2, 2, 2, 2, 2, 2],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [6, 6, 6, 6, 6, 6],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [4, 4, 4, 4, 4, 4],
-    [1, 1, 1, 1, 4, 1],
-    [0, 4, 0, 4, 4, 0],
-    [0, 0, 0, 0, 0, 0],
-    [4, 4, 4, 4, 4, 4],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 5, 0, 5, 0, 5],
-    [5, 5, 5, 5, 5, 5],
-    [5, 5, 5, 5, 5, 5],
-    [0, 5, 0, 5, 0, 5],
-    [-1, 5, 0, 5, 0, 5],
-    [1, 5, 1, 5, 1, 5],
-    [4, 5, -1, 5, 4, 5],
-    [0, 5, 0, 5, 0, 5],
-    [4, 5, 0, 5, 4, 5],
-    [1, 5, 1, 5, 1, 5],
-    [4, 4, 4, 4, 4, 4],
-    [0, 4, 0, 4, 4, 4],
-    [0, 0, 0, 0, 0, 0],
-    [1, 1, 1, 1, 1, 1],
-    [6, 6, 6, 6, 6, 6],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [1, 1, 1, 1, 1, 1],
-    [2, 5, 2, 5, -1, 5],
-    [0, 5, 0, 5, 0, 5],
-    [2, 5, 2, 5, 0, 5],
-    [1, 5, 1, 5, 1, 5],
-    [2, 5, 2, 5, 4, 5],
-    [0, 5, 0, 5, 0, 5],
-    [2, 5, 2, 5, 4, 5],
-    [1, 5, 1, 5, 1, 5],
-    [2, 4, 2, 4, 4, 2],
-    [0, 4, 0, 4, 4, 4],
-    [2, 0, 2, 0, 0, 2],
-    [1, 1, 1, 1, 1, 1],
-    [2, 6, 2, 6, 6, 2],
-    [0, 0, 0, 0, 0, 0],
-    [2, 0, 2, 0, 0, 2],
-    [1, 1, 1, 1, 1, 1],
-    [1, 1, 1, 1, 1, 1],
-    [0, 1, 1, 1, 0, 1],
-    [0, 0, 0, 0, 0, 0],
-    [2, 2, 2, 2, 2, 2],
-    [4, 1, 1, 1, 4, 1],
-    [0, 1, 1, 1, 0, 1],
-    [4, 0, 0, 4, 4, 0],
-    [2, 2, 2, 2, 2, 2],
-    [1, 1, 1, 1, 1, 1],
-    [0, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [2, 2, 2, 2, 2, 2],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [2, 2, 2, 2, 2, 2],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [5, 5, 5, 5, 5, 5],
-    [1, 1, 1, 1, 4, 1],
-    [0, 0, 0, 0, 0, 0],
-    [4, 0, 0, 4, 4, 0],
-    [4, 4, 4, 4, 4, 4],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [4, 4, 4, 4, 4, 4],
-    [1, 1, 1, 1, 1, 1],
-    [6, 0, 0, 6, 0, 6],
-    [0, 0, 0, 0, 0, 0],
-    [6, 6, 6, 6, 6, 6],
-    [5, 5, 5, 5, 5, 5],
-    [5, 5, 0, 5, 0, 5],
-    [5, 5, 0, 5, 0, 5],
-    [5, 5, 1, 5, 1, 5],
-    [4, 4, 4, 4, 4, 4],
-    [0, 0, 0, 0, 0, 0],
-    [4, 4, 0, 4, 4, 4],
-    [1, 1, 1, 1, 1, 1],
-    [4, 4, 4, 4, 4, 4],
-    [4, 4, 0, 4, 4, 4],
-    [0, 0, 0, 0, 0, 0],
-    [1, 1, 1, 1, 1, 1],
-    [8, 8, 8, 8, 8, 8],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [1, 1, 1, 1, 1, 1],
-    [2, 2, 2, 2, 2, 2],
-    [0, 0, 0, 0, 0, 0],
-    [2, 2, 2, 2, 0, 2],
-    [1, 1, 1, 1, 1, 1],
-    [2, 2, 2, 2, 2, 2],
-    [0, 0, 0, 0, 0, 0],
-    [2, 2, 2, 2, 2, 2],
-    [1, 1, 1, 1, 1, 1],
-    [2, 2, 2, 2, 2, 2],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [4, 1, 1, 4, 4, 1],
-    [2, 2, 2, 2, 2, 2],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [1, 1, 1, 1, 1, 1],
-    [1, 1, 1, 1, 1, 1],
-    [1, 1, 1, 1, 0, 1],
-    [0, 0, 0, 0, 0, 0],
-    [2, 2, 2, 2, 2, 2],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [2, 4, 2, 4, 4, 2],
-    [1, 1, 1, 1, 1, 1],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [2, 2, 2, 2, 2, 2],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [2, 2, 2, 2, 2, 2],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [5, 5, 5, 5, 5, 5],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [4, 4, 4, 4, 4, 4],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [4, 4, 4, 4, 4, 4],
-    [1, 1, 1, 1, 1, 1],
-    [0, 0, 0, 0, 0, 0],
-    [0, 0, 0, 0, 0, 0],
-    [12, 12, 12, 12, 12, 12],
-]

sam3d_objects_mlx/pipeline.py

@@ -1,311 +0,0 @@
-"""Bounded streaming inference over image/mask/point-map requests."""
-
-import asyncio
-import threading
-from concurrent.futures import ThreadPoolExecutor
-from dataclasses import dataclass
-from typing import Optional
-
-import mlx.core as mx
-
-from .flow import LATENTS
-from .mesh import extract_mesh, unique
-from .processing import decode_pose, prepare_inputs
-from .sam3d_objects import Model
-from .sparse import Grid, nonzero
-
-
-@dataclass(frozen=True)
-class Request:
-    image: mx.array
-    mask: Optional[mx.array] = None
-    pointmap: Optional[mx.array] = None
-    request_id: str = ""
-    seed: int = 42
-    ss_steps: Optional[int] = None
-    slat_steps: Optional[int] = None
-    formats: tuple = ("gaussian", "mesh")
-    estimate_depth: bool = True
-
-
-@dataclass(frozen=True)
-class Event:
-    request_id: str
-    stage: str
-    step: int
-    total_steps: int
-    data: dict
-
-
-def schedule(steps, rescale):
-    if not isinstance(steps, int) or isinstance(steps, bool) or steps < 1:
-        raise ValueError("Inference step counts must be positive integers")
-    return [
-        (i / steps) / (1 + (rescale - 1) * (1 - i / steps)) for i in range(steps + 1)
-    ]
-
-
-def sample(flow, state, steps, rescale, strength, condition, *, grid=None, cancel=None):
-    """Euler flow with upstream's additive CFG on timestamps [0, 500]."""
-    times = schedule(steps, rescale)
-    for i, (t0, t1) in enumerate(zip(times, times[1:]), 1):
-        if cancel is not None and cancel.is_set():
-            return
-        time = mx.array([t0 * 1000], mx.float32)
-        if isinstance(state, dict):
-            velocity = flow(state, time, condition, mx.zeros(1))
-            if strength > 0 and t0 <= 0.5:
-                uncond = flow(state, time, mx.zeros_like(condition), mx.zeros(1))
-                velocity = {
-                    n: (1 + strength) * v.astype(mx.float32)
-                    - strength * uncond[n].astype(mx.float32)
-                    for n, v in velocity.items()
-                }
-            state = {
-                n: x + (t1 - t0) * velocity[n].astype(mx.float32)
-                for n, x in state.items()
-            }
-        else:
-            velocity = flow(state, grid, time, condition)
-            if strength > 0 and t0 <= 0.5:
-                uncond = flow(state, grid, time, mx.zeros_like(condition))
-                velocity = (1 + strength) * velocity.astype(
-                    mx.float32
-                ) - strength * uncond.astype(mx.float32)
-            state = state + (t1 - t0) * velocity.astype(mx.float32)
-        mx.async_eval(state)
-        yield i, state
-
-
-def occupancy_grid(logits, prune=1):
-    r = logits.shape[1]
-    active = nonzero(logits[0, ..., 0] > 0)
-    if not active.size:
-        raise RuntimeError("The structure decoder produced no occupied voxels")
-    coords = mx.stack(
-        [mx.zeros_like(active), active // (r * r), active // r % r, active % r], axis=-1
-    ).astype(mx.int32)
-    grid = Grid(coords, r)
-    if prune:
-        if prune != 1:
-            raise ValueError("Only the released one-voxel pruning radius is supported")
-        surface = nonzero(mx.any(grid.neighbors() == coords.shape[0], axis=-1))
-        coords = coords[surface]
-    factor = 1
-    if coords.shape[0] > 42000:
-        xyz = coords[:, 1:].astype(mx.float32)
-        low, high = xyz.min(axis=0), xyz.max(axis=0)
-        size = high - low + 1
-        target_size = size / 2
-        target_low = low + (size - target_size) / 2
-        target_high = target_low + target_size - 1
-        xyz = mx.round(
-            (xyz - low) / mx.maximum(high - low, 1) * (target_size - 1) + target_low
-        )
-        xyz = mx.clip(
-            xyz, target_low.astype(mx.int32), target_high.astype(mx.int32)
-        ).astype(mx.int32)
-        codes, _ = unique((xyz[:, 0] * r + xyz[:, 1]) * r + xyz[:, 2])
-        coords = mx.stack(
-            [mx.zeros_like(codes), codes // (r * r), codes // r % r, codes % r], axis=-1
-        )
-        if coords.shape[0] > 42000:
-            raise RuntimeError(
-                "Occupancy remains too large after upstream downsampling"
-            )
-        factor = 2
-    return Grid(coords, r), factor
-
-
-class Pipeline:
-    """One model, one active stream; input backpressure is one request.
-
-    GPU work is submitted with async_eval. Dynamic sparse topology requires
-    scalar synchronization. Async iteration runs submissions on one worker,
-    leaving the caller's event loop responsive; it never buffers whole videos.
-    """
-
-    def __init__(self, model):
-        self.model = model
-        self._lock = threading.Lock()
-
-    @classmethod
-    def from_pretrained(cls, path):
-        return cls(Model.from_pretrained(path))
-
-    def _run(self, request, cancel):
-        config, model = self.model.config, self.model
-        formats = tuple(request.formats)
-        if not formats or set(formats) - {"gaussian", "gaussian_4", "mesh"}:
-            raise ValueError("formats must contain gaussian, gaussian_4, or mesh")
-        ss_steps = config.ss_steps if request.ss_steps is None else request.ss_steps
-        slat_steps = (
-            config.slat_steps if request.slat_steps is None else request.slat_steps
-        )
-        schedule(ss_steps, config.ss_rescale_t)
-        schedule(slat_steps, config.slat_rescale_t)
-        pointmap = request.pointmap
-        if pointmap is None and request.estimate_depth and config.depth_model:
-            pointmap = model.depth_model(request.image, config.depth_num_tokens)
-            mx.async_eval(pointmap)
-            yield Event(request.request_id, "depth", 1, 1, {"pointmap": pointmap})
-        inputs, metadata = prepare_inputs(
-            request.image, request.mask, pointmap, size=config.image_size
-        )
-        condition = model.ss_condition_embedder(inputs)
-        mx.async_eval(condition)
-        yield Event(
-            request.request_id,
-            "conditioning",
-            1,
-            1,
-            {"pointmap_conditioned": metadata["pointmap_conditioned"]},
-        )
-        keys = mx.random.split(mx.random.key(request.seed), len(LATENTS) + 1)
-        state = {
-            name: mx.random.normal(
-                (1, config.latent_resolution**3 if name == "shape" else 1, channels),
-                key=keys[i],
-            )
-            for i, (name, channels) in enumerate(LATENTS.items())
-        }
-        for step, state in sample(
-            model.ss_generator,
-            state,
-            ss_steps,
-            config.ss_rescale_t,
-            config.ss_guidance,
-            condition,
-            cancel=cancel,
-        ):
-            yield Event(
-                request.request_id, "structure", step, ss_steps, {"latents": state}
-            )
-        if cancel.is_set():
-            return
-        logits = model.ss_decoder(state["shape"])
-        mx.async_eval(logits)
-        grid, factor = occupancy_grid(logits, config.downsample_ss_dist)
-        pose = decode_pose(state, metadata, factor)
-        yield Event(
-            request.request_id, "occupancy", 1, 1, {"coords": grid.coords, "pose": pose}
-        )
-        condition = model.slat_condition_embedder(inputs)
-        mx.async_eval(condition)
-        latent = mx.random.normal(
-            (grid.coords.shape[0], config.latent_channels), key=keys[-1]
-        )
-        for step, latent in sample(
-            model.slat_generator,
-            latent,
-            slat_steps,
-            config.slat_rescale_t,
-            config.slat_guidance,
-            condition,
-            grid=grid,
-            cancel=cancel,
-        ):
-            yield Event(
-                request.request_id,
-                "latent",
-                step,
-                slat_steps,
-                {"features": latent, "coords": grid.coords},
-            )
-        if cancel.is_set():
-            return
-        latent = latent * mx.array(config.slat_std) + mx.array(config.slat_mean)
-        result = {
-            "coords": grid.coords,
-            "latents": latent,
-            "pose": pose,
-            "pointmap_conditioned": metadata["pointmap_conditioned"],
-        }
-        for index, kind in enumerate(formats, 1):
-            if cancel.is_set():
-                return
-            if kind == "mesh":
-                features, mesh_grid = model.slat_decoder_mesh(latent, grid)
-                mx.async_eval(features)
-                output = extract_mesh(features, mesh_grid)
-            else:
-                decoder = (
-                    model.slat_decoder_gs
-                    if kind == "gaussian"
-                    else model.slat_decoder_gs_4
-                )
-                output = decoder(latent, grid)
-            mx.async_eval(output)
-            result[kind] = output
-            yield Event(request.request_id, kind, index, len(formats), output)
-        mx.async_eval(result)
-        yield Event(request.request_id, "complete", 1, 1, result)
-
-    def stream(self, request):
-        if not self._lock.acquire(blocking=False):
-            raise RuntimeError("A stream is already using this pipeline")
-        cancel = threading.Event()
-        try:
-            yield from self._run(request, cancel)
-        finally:
-            cancel.set()
-            self._lock.release()
-
-    def generate(self, image, mask=None, pointmap=None, **kwargs):
-        for event in self.stream(Request(image, mask, pointmap, **kwargs)):
-            if event.stage == "complete":
-                mx.eval(event.data)
-                return event.data
-
-    async def astream(self, requests):
-        """Consume an iterable or async iterable, yielding ordered Event objects.
-
-        Cancellation stops further submissions and closes the active request.
-        Already submitted GPU commands finish before worker stream cleanup.
-        """
-        if not self._lock.acquire(blocking=False):
-            raise RuntimeError("A stream is already using this pipeline")
-        executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix="sam3d-mlx")
-        loop = asyncio.get_running_loop()
-        cancel = threading.Event()
-        iterator = None
-
-        def advance():
-            return next(iterator, None)
-
-        async def inputs():
-            if hasattr(requests, "__aiter__"):
-                async for item in requests:
-                    yield item
-            else:
-                for item in requests:
-                    yield item
-
-        def cleanup():
-            if iterator is not None:
-                iterator.close()
-            mx.synchronize()
-            clear = getattr(mx, "clear_streams", None)
-            if clear is not None:
-                clear()
-
-        try:
-            async for request in inputs():
-                iterator = self._run(request, cancel)
-                while True:
-                    event = await loop.run_in_executor(executor, advance)
-                    if event is None:
-                        break
-                    yield event
-                iterator = None
-        finally:
-            cancel.set()
-            # Cleanup is queued behind any in-flight advance on the same worker.
-            pending_cleanup = loop.run_in_executor(executor, cleanup)
-
-            def release(_):
-                executor.shutdown(wait=False)
-                self._lock.release()
-
-            pending_cleanup.add_done_callback(release)
-            await asyncio.shield(pending_cleanup)

sam3d_objects_mlx/processing.py

@@ -1,213 +0,0 @@
-# Adapted from Meta SAM 3D Objects. See LICENSE in this directory.
-"""MLX image/mask/point-map preprocessing and layout decoding."""
-
-import mlx.core as mx
-
-from .resize import resize
-from .sparse import nonzero
-
-
-def _square(x, fill=0):
-    h, w = x.shape[:2]
-    side = max(h, w)
-    top, left = (side - h) // 2, (side - w) // 2
-    return mx.pad(
-        x,
-        [(top, side - h - top), (left, side - w - left), (0, 0)],
-        constant_values=fill,
-    )
-
-
-def _crop(x, box):
-    left, top, right, bottom = box
-    h, w = x.shape[:2]
-    pads = [
-        (max(0, -top), max(0, bottom - h)),
-        (max(0, -left), max(0, right - w)),
-        (0, 0),
-    ]
-    x = mx.pad(x, pads)
-    y, z = max(top, 0), max(left, 0)
-    return x[y : y + bottom - top, z : z + right - left]
-
-
-def _median(x):
-    x = x.reshape(-1)
-    valid = ~mx.isnan(x)
-    count = int(valid.sum().item())
-    if not count:
-        return mx.array(float("nan"))
-    return mx.sort(mx.where(valid, x, float("inf")))[(count - 1) // 2]
-
-
-def prepare_inputs(image, mask, pointmap=None, *, size=518):
-    """Accept HWC RGB/RGBA and HW masks; floating RGB must be in [0, 1].
-
-    Point maps use the upstream PyTorch3D camera convention (+X left,
-    +Y up, +Z forward). Omitted maps use the trained point-map dropout.
-    """
-    if image.ndim != 3 or image.shape[-1] not in (3, 4):
-        raise ValueError("Expected an HWC RGB or RGBA image")
-    if mask is None:
-        if image.shape[-1] != 4:
-            raise ValueError("Provide an object mask or an RGBA image")
-        mask = image[..., 3]
-    image = image[..., :3]
-    if image.dtype == mx.uint8:
-        image = image.astype(mx.float32) / 255
-    else:
-        image = image.astype(mx.float32)
-        if not bool(mx.all(mx.isfinite(image) & (image >= 0) & (image <= 1)).item()):
-            raise ValueError("Floating-point image values must be finite and in [0, 1]")
-    if mask.ndim == 3 and mask.shape[-1] == 1:
-        mask = mask[..., 0]
-    if mask.shape != image.shape[:2]:
-        raise ValueError("The mask must have the same height and width as the image")
-    threshold = 127 if mask.dtype == mx.uint8 and int(mask.max().item()) > 1 else 0.5
-    mask = (mask > threshold).astype(mx.float32)[..., None]
-    ys, xs = nonzero(mx.any(mask[..., 0] > 0, axis=1)), nonzero(
-        mx.any(mask[..., 0] > 0, axis=0)
-    )
-    if ys.size < 2 or xs.size < 2:
-        raise ValueError("The object mask must span at least two rows and columns")
-    x0, x1, y0, y1 = (int(v.item()) for v in (xs[0], xs[-1], ys[0], ys[-1]))
-    side = int(max(x1 - x0, y1 - y0, 2) * 1.2)
-    cx, cy = (x0 + x1) / 2, (y0 + y1) / 2
-    box = (
-        int(cx - side // 2),
-        int(cy - side // 2),
-        int(cx + side // 2),
-        int(cy + side // 2),
-    )
-    result = {}
-    for name, value in (("image", image), ("mask", mask)):
-        for output, raw in (
-            (name, _crop(value, box)),
-            ("rgb_image" if name == "image" else "rgb_image_mask", value),
-        ):
-            result[output] = resize(
-                _square(raw)[None],
-                size,
-                size,
-                nearest=name == "mask",
-                antialias=name == "image",
-            )
-    shift, scale = mx.zeros(3), mx.ones(3)
-    if pointmap is not None:
-        if pointmap.ndim != 3 or pointmap.shape[-1] != 3:
-            raise ValueError("Expected an HWC point map with XYZ channels")
-        pointmap = resize(
-            pointmap[None].astype(mx.float32),
-            image.shape[0],
-            image.shape[1],
-            nearest=True,
-        )[0]
-        selected = pointmap.reshape(-1, 3)[nonzero(mask[..., 0] > 0)]
-        if not bool(mx.any(mx.isfinite(selected)).item()):
-            raise ValueError("The object mask contains no finite point-map values")
-        shift = mx.stack([_median(selected[:, c]) for c in range(3)])
-        scale_value = _median(mx.max(mx.abs(pointmap - shift), axis=-1))
-        if (
-            not bool(mx.all(mx.isfinite(shift)).item())
-            or not bool(mx.isfinite(scale_value).item())
-            or float(scale_value.item()) <= 0
-        ):
-            raise ValueError("The point map has invalid or zero spatial scale")
-        scale = mx.broadcast_to(scale_value, (3,))
-        normalized = (pointmap - shift) / scale
-        result["pointmap"] = resize(
-            _square(_crop(normalized, box), float("nan"))[None],
-            size,
-            size,
-            nearest=True,
-        )
-        result["rgb_pointmap"] = resize(
-            _square(normalized)[None], size, size, nearest=True
-        )
-    else:
-        result["pointmap"] = result["rgb_pointmap"] = None
-    return result, {
-        "pointmap_scale": scale,
-        "pointmap_shift": shift,
-        "pointmap_conditioned": pointmap is not None,
-    }
-
-
-def _normalize(x):
-    return x / mx.maximum(mx.sqrt(mx.sum(x * x, axis=-1, keepdims=True)), 1e-12)
-
-
-def _cross(a, b):
-    return mx.stack(
-        [
-            a[..., 1] * b[..., 2] - a[..., 2] * b[..., 1],
-            a[..., 2] * b[..., 0] - a[..., 0] * b[..., 2],
-            a[..., 0] * b[..., 1] - a[..., 1] * b[..., 0],
-        ],
-        axis=-1,
-    )
-
-
-def decode_pose(latents, metadata, downsample_factor=1):
-    mean = mx.array(
-        [
-            -0.06366084883674913,
-            0.008438224692279752,
-            0.00017084786438302483,
-            0.0007126610473540038,
-            -0.0030916726538816417,
-            0.5166093753457688,
-        ]
-    )
-    std = mx.array(
-        [
-            0.6656971967514863,
-            0.6787012271867754,
-            0.30345010594844524,
-            0.4394504420678794,
-            0.39817973931717104,
-            0.6176286868761914,
-        ]
-    )
-    rot = latents["6drotation_normalized"].astype(mx.float32).reshape(6) * std + mean
-    a = _normalize(rot[:3])
-    b = _normalize(rot[3:] - mx.sum(a * rot[3:]) * a)
-    matrix = mx.stack([a, b, _cross(a, b)], axis=-1)
-    m = matrix
-    qabs = mx.sqrt(
-        mx.maximum(
-            mx.array([1.0, 1.0, 1.0, 1.0])
-            + mx.stack(
-                [
-                    m[0, 0] + m[1, 1] + m[2, 2],
-                    m[0, 0] - m[1, 1] - m[2, 2],
-                    -m[0, 0] + m[1, 1] - m[2, 2],
-                    -m[0, 0] - m[1, 1] + m[2, 2],
-                ]
-            ),
-            0,
-        )
-    )
-    qw, qx, qy, qz = qabs * qabs
-    candidates = mx.stack(
-        [
-            mx.stack([qw, m[2, 1] - m[1, 2], m[0, 2] - m[2, 0], m[1, 0] - m[0, 1]]),
-            mx.stack([m[2, 1] - m[1, 2], qx, m[1, 0] + m[0, 1], m[0, 2] + m[2, 0]]),
-            mx.stack([m[0, 2] - m[2, 0], m[1, 0] + m[0, 1], qy, m[2, 1] + m[1, 2]]),
-            mx.stack([m[1, 0] - m[0, 1], m[2, 0] + m[0, 2], m[2, 1] + m[1, 2], qz]),
-        ]
-    )
-    quaternion = (candidates / (2 * mx.maximum(qabs[:, None], 0.1)))[mx.argmax(qabs)]
-    quaternion = mx.where(quaternion[0] < 0, -quaternion, quaternion)
-    scale = mx.exp(latents["scale"].reshape(3)) * metadata["pointmap_scale"]
-    scale = mx.broadcast_to(mx.mean(scale) * downsample_factor, (3,))
-    translation = (
-        latents["translation"].reshape(3) * metadata["pointmap_scale"]
-        + metadata["pointmap_shift"]
-    )
-    return {
-        "rotation": quaternion,
-        "rotation_matrix": matrix,
-        "translation": translation,
-        "scale": scale,
-    }

sam3d_objects_mlx/resize.py

@@ -1,70 +0,0 @@
-"""Channel-last resizing without image or array dependencies."""
-
-import mlx.core as mx
-
-
-def resize_bicubic(x, height, width, *, antialias=False, offset=0.0):
-    """PyTorch bicubic coefficients, including the DINO scale-factor offset."""
-    for axis, size in ((2, width), (1, height)):
-        old = x.shape[axis]
-        if old == size and not offset:
-            continue
-        scale = old / (size + offset)
-        center = (mx.arange(size, dtype=mx.float32) + 0.5) * scale - 0.5
-        support = 2 * max(scale, 1) if antialias else 2
-        taps = int(support) + 1
-        indices = mx.floor(center).astype(mx.int32)[:, None] + mx.arange(
-            -taps, taps + 1
-        )
-        distance = mx.abs(indices - center[:, None]) / (
-            max(scale, 1) if antialias else 1
-        )
-        a = -0.5 if antialias else -0.75
-        weights = mx.where(
-            distance < 1,
-            ((a + 2) * distance - (a + 3)) * distance**2 + 1,
-            mx.where(
-                distance < 2,
-                ((a * distance - 5 * a) * distance + 8 * a) * distance - 4 * a,
-                0,
-            ),
-        )
-        if antialias:
-            weights = mx.where((indices >= 0) & (indices < old), weights, 0)
-            weights = weights / weights.sum(axis=-1, keepdims=True)
-        gathered = mx.take(x, mx.clip(indices, 0, old - 1), axis=axis)
-        shape = [1] * gathered.ndim
-        shape[axis : axis + 2] = weights.shape
-        x = mx.sum(gathered * weights.reshape(shape).astype(x.dtype), axis=axis + 1)
-    return x
-
-
-def resize(x, height, width, *, nearest=False, antialias=False):
-    """Match PyTorch interpolate with align_corners=False (NHWC)."""
-    for axis, size in ((1, height), (2, width)):
-        old = x.shape[axis]
-        if old == size:
-            continue
-        if nearest:
-            idx = mx.minimum(mx.arange(size) * old // size, old - 1)
-            x = mx.take(x, idx, axis=axis)
-            continue
-        scale = old / size
-        center = (mx.arange(size, dtype=mx.float32) + 0.5) * scale - 0.5
-        if antialias and scale > 1:
-            support = int(scale) + 1
-            offsets = mx.arange(-support, support + 1)
-            indices = mx.floor(center).astype(mx.int32)[:, None] + offsets
-            weights = mx.maximum(1 - mx.abs(indices - center[:, None]) / scale, 0)
-            weights = mx.where((indices >= 0) & (indices < old), weights, 0)
-            weights = weights / weights.sum(axis=-1, keepdims=True)
-        else:
-            low = mx.floor(center).astype(mx.int32)
-            indices = mx.stack([low, low + 1], axis=-1)
-            f = center - low
-            weights = mx.stack([1 - f, f], axis=-1)
-        gathered = mx.take(x, mx.clip(indices, 0, old - 1), axis=axis)
-        shape = [1] * gathered.ndim
-        shape[axis : axis + 2] = weights.shape
-        x = mx.sum(gathered * weights.reshape(shape).astype(x.dtype), axis=axis + 1)
-    return x

sam3d_objects_mlx/sam3d_objects.py

@@ -1,72 +0,0 @@
-# Adapted from Meta SAM 3D Objects. See LICENSE in this directory.
-"""Frozen inference models for SAM 3D Objects."""
-
-import json
-from pathlib import Path
-
-import mlx.core as mx
-import mlx.nn as nn
-
-from .config import ModelConfig
-from .decoders import GaussianDecoder, MeshDecoder, StructureDecoder
-from .flow import LatentFlow, StructureFlow
-from .vision import ConditionEncoder
-
-
-class Model(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.config = config
-        self.ss_generator = StructureFlow(config)
-        self.slat_generator = LatentFlow(config)
-        self.ss_condition_embedder = ConditionEncoder(config, pointmap=True)
-        self.slat_condition_embedder = ConditionEncoder(config)
-        self.ss_decoder = StructureDecoder(config)
-        self.slat_decoder_gs = GaussianDecoder(config)
-        self.slat_decoder_gs_4 = GaussianDecoder(config, count=4)
-        self.slat_decoder_mesh = MeshDecoder(config)
-        if config.depth_model:
-            from .depth import DepthModel
-
-            self.depth_model = DepthModel()
-        self.eval()
-        self.freeze()
-
-    def train(self, mode=True):
-        if mode:
-            raise ValueError("SAM 3D Objects is an inference-only model")
-        return super().train(False)
-
-    @classmethod
-    def from_pretrained(cls, path):
-        """Load a local converted bundle using MLX alone, with strict weights."""
-        root = Path(path)
-        config = ModelConfig.from_dict(json.loads((root / "config.json").read_text()))
-        model = cls(config)
-        index = root / "model.safetensors.index.json"
-        if index.exists():
-            files = sorted(set(json.loads(index.read_text())["weight_map"].values()))
-        else:
-            files = ["model.safetensors"]
-        weights = {}
-        for name in files:
-            if Path(name).name != name:
-                raise ValueError("Checkpoint shards must be in the model directory")
-            shard = mx.load(str(root / name))
-            if weights.keys() & shard.keys():
-                raise ValueError("Duplicate tensor names across checkpoint shards")
-            weights.update(shard)
-        model.load_weights(list(weights.items()), strict=True)
-        model.freeze()
-        model.eval()
-        mx.async_eval(model.parameters())
-        return model
-
-    @staticmethod
-    def sanitize(weights):
-        return weights
-
-    def __call__(self, *args, **kwargs):
-        from .pipeline import Pipeline
-
-        return Pipeline(self).generate(*args, **kwargs)

sam3d_objects_mlx/sparse.py

@@ -1,172 +0,0 @@
-# Adapted from mlx_vlm.models.moge3.sparse and Meta SAM 3D Objects.
-"""Sparse inference operators using MLX gathers, reductions, and attention."""
-
-from dataclasses import dataclass, field
-from itertools import product
-
-import mlx.core as mx
-import mlx.nn as nn
-
-from .layers import attend
-
-
-def nonzero(mask):
-    mask = mask.reshape(-1)
-    count = int(mx.sum(mask).item())
-    return mx.sort(mx.where(mask, mx.arange(mask.size), mask.size))[:count]
-
-
-def coord_keys(coords, resolution):
-    return (
-        (coords[:, 0] * resolution + coords[:, 1]) * resolution + coords[:, 2]
-    ) * resolution + coords[:, 3]
-
-
-@dataclass
-class Grid:
-    coords: mx.array
-    resolution: int
-    cache: dict = field(default_factory=dict)
-
-    def neighbors(self):
-        if "neighbors" not in self.cache:
-            offsets = mx.array(list(product((-1, 0, 1), repeat=3)), dtype=mx.int32)
-            positions = self.coords[:, None, 1:] + offsets[None]
-            valid = mx.all((positions >= 0) & (positions < self.resolution), axis=-1)
-            r = self.resolution
-            nkeys = (
-                (self.coords[:, :1] * r + positions[:, :, 0]) * r + positions[:, :, 1]
-            ) * r + positions[:, :, 2]
-            keys = coord_keys(self.coords, r)
-            order = mx.argsort(keys)
-            sorted_keys = keys[order]
-            index = mx.minimum(
-                mx.searchsorted(sorted_keys, nkeys.reshape(-1)), keys.size - 1
-            ).reshape(nkeys.shape)
-            found = valid & (sorted_keys[index] == nkeys)
-            self.cache["neighbors"] = mx.where(found, order[index], keys.size)
-        return self.cache["neighbors"]
-
-    def downsample(self):
-        if "downsample" not in self.cache:
-            coords = self.coords // mx.array([1, 2, 2, 2])
-            r = (self.resolution + 1) // 2
-            keys = coord_keys(coords, r)
-            order = mx.argsort(keys)
-            sorted_keys = keys[order]
-            start = mx.concatenate(
-                [mx.array([True]), sorted_keys[1:] != sorted_keys[:-1]]
-            )
-            first = nonzero(start)
-            groups = mx.cumsum(start.astype(mx.int32)) - 1
-            parent = mx.zeros(keys.size, mx.int32).at[order].add(groups)
-            child = Grid(coords[order[first]], r)
-            self.cache["downsample"] = (child, parent)
-        return self.cache["downsample"]
-
-    def subdivide(self):
-        if "subdivide" not in self.cache:
-            offsets = mx.array(
-                [(0, *p) for p in product((0, 1), repeat=3)], dtype=mx.int32
-            )
-            coords = self.coords[:, None] * mx.array([1, 2, 2, 2]) + offsets[None]
-            self.cache["subdivide"] = Grid(coords.reshape(-1, 4), self.resolution * 2)
-        return self.cache["subdivide"]
-
-    def windows(self, size, shift):
-        key = ("windows", size, shift)
-        if key not in self.cache:
-            coords = mx.concatenate(
-                [self.coords[:, :1], (self.coords[:, 1:] + shift) // size], axis=-1
-            )
-            keys = coord_keys(coords, (self.resolution + shift + size - 1) // size)
-            order = mx.argsort(keys)
-            sorted_keys = keys[order]
-            starts = nonzero(
-                mx.concatenate([mx.array([True]), sorted_keys[1:] != sorted_keys[:-1]])
-            ).tolist()
-            ends = starts[1:] + [keys.size]
-            buckets = {}
-            for start, end in zip(starts, ends):
-                width = 1 << (end - start - 1).bit_length()
-                buckets.setdefault(width, []).append((start, end - start))
-            packed = []
-            for width, ranges in sorted(buckets.items()):
-                first = mx.array([s for s, _ in ranges])[:, None]
-                lengths = mx.array([n for _, n in ranges])[:, None]
-                offset = mx.arange(width)[None]
-                valid = offset < lengths
-                indices = mx.where(
-                    valid, order[mx.minimum(first + offset, keys.size - 1)], keys.size
-                )
-                packed.append((indices, valid))
-            self.cache[key] = packed
-        return self.cache[key]
-
-
-class SparseConv(nn.Module):
-    def __init__(self, input_channels, output_channels, kernel=3):
-        super().__init__()
-        self.conv = nn.Conv3d(
-            input_channels, output_channels, kernel, padding=kernel // 2
-        )
-
-    def __call__(self, x, grid):
-        w, bias = self.conv.weight, self.conv.bias
-        if w.shape[1] == 1:
-            return mx.addmm(bias, x, w[:, 0, 0, 0].T)
-        indices = grid.neighbors()
-        padded = mx.concatenate([x, mx.zeros((1, x.shape[-1]), x.dtype)])
-        # Limit temporary im2col storage to 16 MiB per matrix product.
-        rows = max(1, (16 << 20) // (27 * x.shape[-1] * x.dtype.size))
-        weight = w.reshape(w.shape[0], -1).T
-        outputs = []
-        for start in range(0, x.shape[0], rows):
-            values = padded[indices[start : start + rows]].reshape(-1, weight.shape[0])
-            outputs.append(mx.addmm(bias, values, weight))
-        return mx.concatenate(outputs, axis=0)
-
-
-def pool(x, grid):
-    child, parent = grid.downsample()
-    sums = (
-        mx.zeros((child.coords.shape[0], x.shape[-1]), mx.float32)
-        .at[parent]
-        .add(x.astype(mx.float32))
-    )
-    # Upstream torch.scatter_reduce(mean) includes the initial zero value.
-    counts = (
-        mx.ones((child.coords.shape[0], 1), mx.float32)
-        .at[parent]
-        .add(mx.ones((x.shape[0], 1)))
-    )
-    return (sums / counts).astype(x.dtype), child, parent
-
-
-class SparseGroupNorm(nn.Module):
-    def __init__(self, channels, groups=32):
-        super().__init__()
-        self.weight = mx.ones(channels)
-        self.bias = mx.zeros(channels)
-        self.groups = min(groups, channels)
-
-    def __call__(self, x):
-        # Each streamed request has one object; normalize across all its voxels.
-        h = x.astype(mx.float32).reshape(x.shape[0], self.groups, -1)
-        mean = h.mean(axis=(0, 2), keepdims=True)
-        var = ((h - mean) ** 2).mean(axis=(0, 2), keepdims=True)
-        h = ((h - mean) * mx.rsqrt(var + 1e-5)).reshape(x.shape)
-        return (h * self.weight + self.bias).astype(x.dtype)
-
-
-def window_attention(qkv, grid, size, shift):
-    n, _, heads, dim = qkv.shape
-    padded = mx.concatenate([qkv, mx.zeros((1, 3, heads, dim), qkv.dtype)])
-    result = mx.zeros((n + 1, heads * dim), qkv.dtype)
-    for indices, valid in grid.windows(size, shift):
-        values = padded[indices]
-        out = attend(*(values[:, :, i] for i in range(3)), mask=valid[:, None, None, :])
-        result = result.at[indices.reshape(-1)].add(
-            mx.where(valid[..., None], out, 0).reshape(-1, heads * dim)
-        )
-    return result[:n]

sam3d_objects_mlx/vision.py

@@ -1,215 +0,0 @@
-# Adapted from mlx_vlm.models.dinov2 and Meta SAM 3D Objects.
-# See LICENSE in this directory for the SAM components.
-"""DINOv2 register-token image encoders and point-map conditioning."""
-
-import mlx.core as mx
-import mlx.nn as nn
-
-from .layers import LayerNorm, Sequential, attend, layer_norm
-from .resize import resize
-
-
-class PatchEmbed(nn.Module):
-    def __init__(self, channels):
-        super().__init__()
-        self.proj = nn.Conv2d(3, channels, 14, stride=14)
-
-    def __call__(self, x):
-        x = self.proj(x)
-        return x.reshape(x.shape[0], -1, x.shape[-1])
-
-
-class VisionAttention(nn.Module):
-    def __init__(self, channels, heads):
-        super().__init__()
-        self.heads = heads
-        self.qkv = nn.Linear(channels, 3 * channels)
-        self.proj = nn.Linear(channels, channels)
-
-    def __call__(self, x):
-        qkv = self.qkv(x).reshape(*x.shape[:2], 3, self.heads, -1)
-        return self.proj(attend(*(qkv[:, :, i] for i in range(3))))
-
-
-class VisionMLP(nn.Module):
-    def __init__(self, channels, ratio=4):
-        super().__init__()
-        self.fc1 = nn.Linear(channels, channels * ratio)
-        self.fc2 = nn.Linear(channels * ratio, channels)
-
-    def __call__(self, x):
-        return self.fc2(nn.gelu(self.fc1(x)))
-
-
-class LayerScale(nn.Module):
-    def __init__(self, channels):
-        super().__init__()
-        self.gamma = mx.ones(channels)
-
-    def __call__(self, x):
-        return x * self.gamma
-
-
-class VisionBlock(nn.Module):
-    def __init__(self, channels, heads, *, layer_scale=True, ratio=4):
-        super().__init__()
-        self.norm1 = LayerNorm(channels, eps=1e-6)
-        self.attn = VisionAttention(channels, heads)
-        self.norm2 = LayerNorm(channels, eps=1e-6)
-        self.mlp = VisionMLP(channels, ratio)
-        self.ls1 = LayerScale(channels) if layer_scale else nn.Identity()
-        self.ls2 = LayerScale(channels) if layer_scale else nn.Identity()
-
-    def __call__(self, x):
-        x = x + self.ls1(self.attn(self.norm1(x)))
-        return x + self.ls2(self.mlp(self.norm2(x)))
-
-
-class DINOv2(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        c = config.dino_hidden_size
-        n = (config.dino_image_size // 14) ** 2
-        self.patch_embed = PatchEmbed(c)
-        self.cls_token = mx.zeros((1, 1, c))
-        self.mask_token = mx.zeros((1, c))
-        self.pos_embed = mx.zeros((1, n + 1, c))
-        self.register_tokens = mx.zeros((1, 4, c))
-        self.blocks = [
-            VisionBlock(c, config.dino_heads) for _ in range(config.dino_layers)
-        ]
-        self.norm = LayerNorm(c, eps=1e-6)
-
-    def __call__(self, image, prenorm=False):
-        x = self.patch_embed(image)
-        if x.shape[1] + 1 != self.pos_embed.shape[1]:
-            raise ValueError("DINO input must match the checkpoint image size")
-        x = (
-            mx.concatenate(
-                [mx.broadcast_to(self.cls_token, (x.shape[0], 1, x.shape[-1])), x],
-                axis=1,
-            )
-            + self.pos_embed
-        )
-        x = mx.concatenate(
-            [
-                x[:, :1],
-                mx.broadcast_to(self.register_tokens, (x.shape[0], 4, x.shape[-1])),
-                x[:, 1:],
-            ],
-            axis=1,
-        )
-        for block in self.blocks:
-            x = block(x)
-        if prenorm:
-            return layer_norm(x)
-        x = self.norm(x)
-        return mx.concatenate([x[:, :1], x[:, 5:]], axis=1)
-
-
-class Dino(nn.Module):
-    def __init__(self, config, prenorm=False):
-        super().__init__()
-        self.backbone = DINOv2(config)
-        self._size = config.image_size
-        self._prenorm = prenorm
-
-    def __call__(self, image):
-        x = resize(image, self._size, self._size)
-        if x.shape[-1] == 1:
-            x = mx.repeat(x, 3, axis=-1)
-        x = (x - mx.array([0.485, 0.456, 0.406])) / mx.array([0.229, 0.224, 0.225])
-        return self.backbone(x.astype(self.backbone.cls_token.dtype), self._prenorm)
-
-
-class PointPatchEmbed(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        c, p, s = config.point_channels, config.point_patch_size, config.point_size
-        self._patch, self._size = p, s
-        self.point_proj = nn.Linear(3, c)
-        self.invalid_xyz_token = mx.zeros(c)
-        self.pos_embed = mx.zeros((1, c, s // p, s // p))
-        self.pos_embed_window = mx.zeros((1, 1 + p * p, c))
-        self.cls_token = mx.zeros((1, 1, c))
-        self.blocks = [VisionBlock(c, config.point_heads, layer_scale=False, ratio=2)]
-
-    def __call__(self, points):
-        points = resize(points, self._size, self._size, nearest=True)
-        valid = mx.all(mx.isfinite(points), axis=-1, keepdims=True)
-        x = self.point_proj(
-            mx.where(valid, points, 0).astype(self.point_proj.weight.dtype)
-        )
-        x = mx.where(valid, x, self.invalid_xyz_token)
-        b, h, w, c = x.shape
-        p = self._patch
-        x = (
-            x.reshape(b, h // p, p, w // p, p, c)
-            .transpose(0, 1, 3, 2, 4, 5)
-            .reshape(-1, p * p, c)
-        )
-        x = (
-            mx.concatenate(
-                [mx.broadcast_to(self.cls_token, (x.shape[0], 1, c)), x], axis=1
-            )
-            + self.pos_embed_window
-        )
-        for block in self.blocks:
-            x = block(x)
-        return x[:, 0].reshape(b, -1, c) + self.pos_embed.transpose(0, 2, 3, 1).reshape(
-            1, -1, c
-        )
-
-
-class ProjectionFFN(nn.Module):
-    def __init__(self, input_dim, output_dim):
-        super().__init__()
-        hidden = ((int(8 * output_dim / 3) + 255) // 256) * 256
-        self.w1 = nn.Linear(input_dim, hidden, bias=False)
-        self.w2 = nn.Linear(hidden, output_dim, bias=False)
-        self.w3 = nn.Linear(input_dim, hidden, bias=False)
-
-    def __call__(self, x):
-        return self.w2(nn.silu(self.w1(x)) * self.w3(x))
-
-
-class ConditionEncoder(nn.Module):
-    def __init__(self, config, *, pointmap=False):
-        super().__init__()
-        self.module_list = [
-            Dino(config, prenorm=not pointmap),
-            Dino(config, prenorm=not pointmap),
-        ]
-        dims = [config.dino_hidden_size] * 2
-        if pointmap:
-            self.module_list.append(PointPatchEmbed(config))
-            dims.append(config.point_channels)
-        self.idx_emb = mx.zeros((3, config.cond_channels))
-        self.projection_nets = [
-            Sequential(LayerNorm(d), ProjectionFFN(d, config.cond_channels))
-            for d in dims
-        ]
-
-    def __call__(self, inputs):
-        groups = [
-            ("image", "rgb_image"),
-            ("mask", "rgb_image_mask"),
-            ("pointmap", "rgb_pointmap"),
-        ]
-        tokens = []
-        for i, module in enumerate(self.module_list):
-            for pos, name in enumerate(groups[i]):
-                if i == 2 and inputs.get(name) is None:
-                    # Match the trained condition dropout: zero complete tokens,
-                    # including their learned positional embedding.
-                    count = (module._size // module._patch) ** 2
-                    tokens.append(
-                        mx.zeros(
-                            (inputs["image"].shape[0], count, self.idx_emb.shape[-1]),
-                            self.idx_emb.dtype,
-                        )
-                    )
-                    continue
-                x = self.projection_nets[i](module(inputs[name]))
-                tokens.append(x + self.idx_emb[pos : pos + 1, None])
-        return mx.concatenate(tokens, axis=1)

validation.json

@@ -13,7 +13,7 @@
   "external_runtime_imports": [],
   "regression_tests": {
     "class": "TestSAM3DObjects",
-    "passed": 9
+    "passed": 13
   },
   "reference_comparison": {
     "precision": "float32",
@@ -60,30 +60,30 @@
     ],
     "samples": [
       {
-        "seconds": 20.503766250010813,
-        "peak_memory_gb": 10.560477761
+        "seconds": 14.864514124987181,
+        "peak_memory_gb": 10.87792566
       },
       {
-        "seconds": 20.648073707998265,
-        "peak_memory_gb": 10.561346009
+        "seconds": 15.67705433399533,
+        "peak_memory_gb": 10.878777628
       },
       {
-        "seconds": 20.7599100000225,
-        "peak_memory_gb": 10.561346037
+        "seconds": 15.963315250002779,
+        "peak_memory_gb": 10.976393304
       }
     ],
-    "median_seconds": 20.648073707998265,
-    "peak_memory_gb": 10.561346037,
-    "gaussians": 844864,
-    "mesh_vertices": 611900,
-    "mesh_faces": 1215398,
+    "median_seconds": 15.67705433399533,
+    "peak_memory_gb": 10.976393304,
+    "gaussians": 845184,
+    "mesh_vertices": 629536,
+    "mesh_faces": 1250780,
     "pointmap_conditioned": true,
     "async_validation": {
       "request_ids": [
         "0",
         "1"
       ],
-      "event_loop_heartbeats": 3624
+      "event_loop_heartbeats": 2810
     }
   }
 }