Add files using upload-large-folder tool

third_party/GraspGen/sam3/.gitignore

@@ -0,0 +1,153 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*-Copy*.ipynb
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# PyCharm
+.idea/
+
+# VS Code
+.vscode/
+*.code-workspace
+
+# Model weights and checkpoints
+*.pth
+*.pt
+*.bin
+*.ckpt
+*.safetensors
+weights/
+checkpoints/
+sam3_logs/
+
+# Data files
+*.h5
+*.hdf5
+*.pkl
+*.pickle
+*.npy
+*.npz
+
+# Logs
+logs/
+runs/
+tensorboard/
+
+# OS specific
+.DS_Store
+Thumbs.db
+
+# BPE vocabulary files
+*.bpe
+*.vocab

third_party/GraspGen/sam3/CODE_OF_CONDUCT.md

@@ -0,0 +1,80 @@
+# Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to make participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when
+an individual is representing the project or its community in public spaces.
+Examples of representing a project or community include using an official
+project e-mail address, posting via an official social media account, or acting
+as an appointed representative at an online or offline event. Representation of
+a project may be further defined and clarified by project maintainers.
+
+This Code of Conduct also applies outside the project spaces when there is a
+reasonable belief that an individual's behavior may have a negative impact on
+the project or its community.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at <opensource-conduct@meta.com>. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

third_party/GraspGen/sam3/CONTRIBUTING.md

@@ -0,0 +1,30 @@
+# Contributing to sam3
+We want to make contributing to this project as easy and transparent as
+possible.
+
+## Pull Requests
+We actively welcome your pull requests.
+
+1. Fork the repo and create your branch from `main`.
+2. If you've added code that should be tested, add tests.
+3. If you've changed APIs, update the documentation.
+4. Make sure your code lints.
+5. If you haven't already, complete the Contributor License Agreement ("CLA").
+
+## Contributor License Agreement ("CLA")
+In order to accept your pull request, we need you to submit a CLA. You only need
+to do this once to work on any of Facebook's open source projects.
+
+Complete your CLA here: <https://code.facebook.com/cla>
+
+## Issues
+We use GitHub issues to track public bugs. Please ensure your description is
+clear and has sufficient instructions to be able to reproduce the issue.
+
+Facebook has a [bounty program](https://www.facebook.com/whitehat/) for the safe
+disclosure of security bugs. In those cases, please go through the process
+outlined on that page and do not file a public issue.
+
+## License
+By contributing to sam3, you agree that your contributions will be licensed
+under the LICENSE file in the root directory of this source tree.

third_party/GraspGen/sam3/LICENSE

@@ -0,0 +1,61 @@
+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.
+
+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.

third_party/GraspGen/sam3/MANIFEST.in

@@ -0,0 +1,6 @@
+include LICENSE
+include README.md
+recursive-include examples *.py
+recursive-include examples *.ipynb
+recursive-include examples *.md
+recursive-include tests *.py

third_party/GraspGen/sam3/README.md

@@ -0,0 +1,395 @@
+# SAM 3: Segment Anything with Concepts
+
+Meta Superintelligence Labs
+
+[Nicolas Carion](https://www.nicolascarion.com/)\*,
+[Laura Gustafson](https://scholar.google.com/citations?user=c8IpF9gAAAAJ&hl=en)\*,
+[Yuan-Ting Hu](https://scholar.google.com/citations?user=E8DVVYQAAAAJ&hl=en)\*,
+[Shoubhik Debnath](https://scholar.google.com/citations?user=fb6FOfsAAAAJ&hl=en)\*,
+[Ronghang Hu](https://ronghanghu.com/)\*,
+[Didac Suris](https://www.didacsuris.com/)\*,
+[Chaitanya Ryali](https://scholar.google.com/citations?user=4LWx24UAAAAJ&hl=en)\*,
+[Kalyan Vasudev Alwala](https://scholar.google.co.in/citations?user=m34oaWEAAAAJ&hl=en)\*,
+[Haitham Khedr](https://hkhedr.com/)\*, Andrew Huang,
+[Jie Lei](https://jayleicn.github.io/),
+[Tengyu Ma](https://scholar.google.com/citations?user=VeTSl0wAAAAJ&hl=en),
+[Baishan Guo](https://scholar.google.com/citations?user=BC5wDu8AAAAJ&hl=en),
+Arpit Kalla, [Markus Marks](https://damaggu.github.io/),
+[Joseph Greer](https://scholar.google.com/citations?user=guL96CkAAAAJ&hl=en),
+Meng Wang, [Peize Sun](https://peizesun.github.io/),
+[Roman Rädle](https://scholar.google.com/citations?user=Tpt57v0AAAAJ&hl=en),
+[Triantafyllos Afouras](https://www.robots.ox.ac.uk/~afourast/),
+[Effrosyni Mavroudi](https://scholar.google.com/citations?user=vYRzGGEAAAAJ&hl=en),
+[Katherine Xu](https://k8xu.github.io/)°,
+[Tsung-Han Wu](https://patrickthwu.com/)°,
+[Yu Zhou](https://yu-bryan-zhou.github.io/)°,
+[Liliane Momeni](https://scholar.google.com/citations?user=Lb-KgVYAAAAJ&hl=en)°,
+[Rishi Hazra](https://rishihazra.github.io/)°,
+[Shuangrui Ding](https://mark12ding.github.io/)°,
+[Sagar Vaze](https://sgvaze.github.io/)°,
+[Francois Porcher](https://scholar.google.com/citations?user=LgHZ8hUAAAAJ&hl=en)°,
+[Feng Li](https://fengli-ust.github.io/)°,
+[Siyuan Li](https://siyuanliii.github.io/)°,
+[Aishwarya Kamath](https://ashkamath.github.io/)°,
+[Ho Kei Cheng](https://hkchengrex.com/)°,
+[Piotr Dollar](https://pdollar.github.io/)†,
+[Nikhila Ravi](https://nikhilaravi.com/)†,
+[Kate Saenko](https://ai.bu.edu/ksaenko.html)†,
+[Pengchuan Zhang](https://pzzhang.github.io/pzzhang/)†,
+[Christoph Feichtenhofer](https://feichtenhofer.github.io/)†
+
+\* core contributor, ° intern, † project lead, order is random within groups
+
+[[`Paper`](https://ai.meta.com/research/publications/sam-3-segment-anything-with-concepts/)]
+[[`Project`](https://ai.meta.com/sam3)]
+[[`Demo`](https://segment-anything.com/)]
+[[`Blog`](https://ai.meta.com/blog/segment-anything-model-3/)]
+[[`BibTeX`](#citing-sam-3)]
+
+![SAM 3 architecture](assets/model_diagram.png?raw=true) SAM 3 is a unified foundation model for promptable segmentation in images and videos. It can detect, segment, and track objects using text or visual prompts such as points, boxes, and masks. Compared to its predecessor [SAM 2](https://github.com/facebookresearch/sam2), SAM 3 introduces the ability to exhaustively segment all instances of an open-vocabulary concept specified by a short text phrase or exemplars. Unlike prior work, SAM 3 can handle a vastly larger set of open-vocabulary prompts. It achieves 75-80% of human performance on our new [SA-CO benchmark](https://github.com/facebookresearch/sam3?tab=readme-ov-file#sa-co-dataset) which contains 270K unique concepts, over 50 times more than existing benchmarks.
+
+This breakthrough is driven by an innovative data engine that has automatically annotated over 4 million unique concepts, creating the largest high-quality open-vocabulary segmentation dataset to date. In addition, SAM 3 introduces a new model architecture featuring a presence token that improves discrimination between closely related text prompts (e.g., “a player in white” vs. “a player in red”), as well as a decoupled detector–tracker design that minimizes task interference and scales efficiently with data.
+
+<p align="center">
+  <img src="assets/dog.gif" width=380 />
+  <img src="assets/player.gif" width=380 />
+</p>
+
+## Installation
+
+### Prerequisites
+
+- Python 3.12 or higher
+- PyTorch 2.7 or higher
+- CUDA-compatible GPU with CUDA 12.6 or higher
+
+1. **Create a new Conda environment:**
+
+```bash
+conda create -n sam3 python=3.12
+conda deactivate
+conda activate sam3
+```
+
+2. **Install PyTorch with CUDA support:**
+
+```bash
+pip install torch==2.7.0 torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126
+```
+
+3. **Clone the repository and install the package:**
+
+```bash
+git clone https://github.com/facebookresearch/sam3.git
+cd sam3
+pip install -e .
+```
+
+4. **Install additional dependencies for example notebooks or development:**
+
+```bash
+# For running example notebooks
+pip install -e ".[notebooks]"
+
+# For development
+pip install -e ".[train,dev]"
+```
+
+## Getting Started
+
+⚠️ Before using SAM 3, please request access to the checkpoints on the SAM 3
+Hugging Face [repo](https://huggingface.co/facebook/sam3). Once accepted, you
+need to be authenticated to download the checkpoints. You can do this by running
+the following [steps](https://huggingface.co/docs/huggingface_hub/en/quick-start#authentication)
+(e.g. `hf auth login` after generating an access token.)
+
+### Basic Usage
+
+```python
+import torch
+#################################### For Image ####################################
+from PIL import Image
+from sam3.model_builder import build_sam3_image_model
+from sam3.model.sam3_image_processor import Sam3Processor
+# Load the model
+model = build_sam3_image_model()
+processor = Sam3Processor(model)
+# Load an image
+image = Image.open("<YOUR_IMAGE_PATH.jpg>")
+inference_state = processor.set_image(image)
+# Prompt the model with text
+output = processor.set_text_prompt(state=inference_state, prompt="<YOUR_TEXT_PROMPT>")
+
+# Get the masks, bounding boxes, and scores
+masks, boxes, scores = output["masks"], output["boxes"], output["scores"]
+
+#################################### For Video ####################################
+
+from sam3.model_builder import build_sam3_video_predictor
+
+video_predictor = build_sam3_video_predictor()
+video_path = "<YOUR_VIDEO_PATH>" # a JPEG folder or an MP4 video file
+# Start a session
+response = video_predictor.handle_request(
+    request=dict(
+        type="start_session",
+        resource_path=video_path,
+    )
+)
+response = video_predictor.handle_request(
+    request=dict(
+        type="add_prompt",
+        session_id=response["session_id"],
+        frame_index=0, # Arbitrary frame index
+        text="<YOUR_TEXT_PROMPT>",
+    )
+)
+output = response["outputs"]
+```
+
+## Examples
+
+The `examples` directory contains notebooks demonstrating how to use SAM3 with
+various types of prompts:
+
+- [`sam3_image_predictor_example.ipynb`](examples/sam3_image_predictor_example.ipynb)
+  : Demonstrates how to prompt SAM 3 with text and visual box prompts on images.
+- [`sam3_video_predictor_example.ipynb`](examples/sam3_video_predictor_example.ipynb)
+  : Demonstrates how to prompt SAM 3 with text prompts on videos, and doing
+  further interactive refinements with points.
+- [`sam3_image_batched_inference.ipynb`](examples/sam3_image_batched_inference.ipynb)
+  : Demonstrates how to run batched inference with SAM 3 on images.
+- [`sam3_agent.ipynb`](examples/sam3_agent.ipynb): Demonsterates the use of SAM
+  3 Agent to segment complex text prompt on images.
+- [`saco_gold_silver_vis_example.ipynb`](examples/saco_gold_silver_vis_example.ipynb)
+  : Shows a few examples from SA-Co image evaluation set.
+- [`saco_veval_vis_example.ipynb`](examples/saco_veval_vis_example.ipynb) :
+  Shows a few examples from SA-Co video evaluation set.
+
+There are additional notebooks in the examples directory that demonstrate how to
+use SAM 3 for interactive instance segmentation in images and videos (SAM 1/2
+tasks), or as a tool for an MLLM, and how to run evaluations on the SA-Co
+dataset.
+
+To run the Jupyter notebook examples:
+
+```bash
+# Make sure you have the notebooks dependencies installed
+pip install -e ".[notebooks]"
+
+# Start Jupyter notebook
+jupyter notebook examples/sam3_image_predictor_example.ipynb
+```
+
+## Model
+
+SAM 3 consists of a detector and a tracker that share a vision encoder. It has 848M parameters. The
+detector is a DETR-based model conditioned on text, geometry, and image
+exemplars. The tracker inherits the SAM 2 transformer encoder-decoder
+architecture, supporting video segmentation and interactive refinement.
+
+## Image Results
+
+<div align="center">
+<table style="min-width: 80%; border: 2px solid #ddd; border-collapse: collapse">
+  <thead>
+    <tr>
+      <th rowspan="3" style="border-right: 2px solid #ddd; padding: 12px 20px">Model</th>
+      <th colspan="3" style="text-align: center; border-right: 2px solid #ddd; padding: 12px 20px">Instance Segmentation</th>
+      <th colspan="5" style="text-align: center; padding: 12px 20px">Box Detection</th>
+    </tr>
+    <tr>
+      <th colspan="2" style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">LVIS</th>
+      <th style="text-align: center; border-right: 2px solid #ddd; padding: 12px 20px">SA-Co/Gold</th>
+      <th colspan="2" style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">LVIS</th>
+      <th colspan="2" style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">COCO</th>
+      <th style="text-align: center; padding: 12px 20px">SA-Co/Gold</th>
+    </tr>
+    <tr>
+      <th style="text-align: center; padding: 12px 20px">cgF1</th>
+      <th style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">AP</th>
+      <th style="text-align: center; border-right: 2px solid #ddd; padding: 12px 20px">cgF1</th>
+      <th style="text-align: center; padding: 12px 20px">cgF1</th>
+      <th style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">AP</th>
+      <th style="text-align: center; padding: 12px 20px">AP</th>
+      <th style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">AP<sub>o</sub>
+</th>
+      <th style="text-align: center; padding: 12px 20px">cgF1</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td style="border-right: 2px solid #ddd; padding: 10px 20px">Human</td>
+      <td style="text-align: center; padding: 10px 20px">-</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">-</td>
+      <td style="text-align: center; border-right: 2px solid #ddd; padding: 10px 20px">72.8</td>
+      <td style="text-align: center; padding: 10px 20px">-</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">-</td>
+      <td style="text-align: center; padding: 10px 20px">-</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">-</td>
+      <td style="text-align: center; padding: 10px 20px">74.0</td>
+    </tr>
+    <tr>
+      <td style="border-right: 2px solid #ddd; padding: 10px 20px">OWLv2*</td>
+      <td style="text-align: center; padding: 10px 20px; color: #999">29.3</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px; color: #999">43.4</td>
+      <td style="text-align: center; border-right: 2px solid #ddd; padding: 10px 20px">24.6</td>
+      <td style="text-align: center; padding: 10px 20px; color: #999">30.2</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px; color: #999">45.5</td>
+      <td style="text-align: center; padding: 10px 20px">46.1</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">23.9</td>
+      <td style="text-align: center; padding: 10px 20px">24.5</td>
+    </tr>
+    <tr>
+      <td style="border-right: 2px solid #ddd; padding: 10px 20px">DINO-X</td>
+      <td style="text-align: center; padding: 10px 20px">-</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">38.5</td>
+      <td style="text-align: center; border-right: 2px solid #ddd; padding: 10px 20px">21.3</td>
+      <td style="text-align: center; padding: 10px 20px">-</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">52.4</td>
+      <td style="text-align: center; padding: 10px 20px">56.0</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">-</td>
+      <td style="text-align: center; padding: 10px 20px">22.5</td>
+    </tr>
+    <tr>
+      <td style="border-right: 2px solid #ddd; padding: 10px 20px">Gemini 2.5</td>
+      <td style="text-align: center; padding: 10px 20px">13.4</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">-</td>
+      <td style="text-align: center; border-right: 2px solid #ddd; padding: 10px 20px">13.0</td>
+      <td style="text-align: center; padding: 10px 20px">16.1</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">-</td>
+      <td style="text-align: center; padding: 10px 20px">-</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">-</td>
+      <td style="text-align: center; padding: 10px 20px">14.4</td>
+    </tr>
+    <tr style="border-top: 2px solid #b19c9cff">
+      <td style="border-right: 2px solid #ddd; padding: 10px 20px">SAM 3</td>
+      <td style="text-align: center; padding: 10px 20px">37.2</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">48.5</td>
+      <td style="text-align: center; border-right: 2px solid #ddd; padding: 10px 20px">54.1</td>
+      <td style="text-align: center; padding: 10px 20px">40.6</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">53.6</td>
+      <td style="text-align: center; padding: 10px 20px">56.4</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">55.7</td>
+      <td style="text-align: center; padding: 10px 20px">55.7</td>
+    </tr>
+  </tbody>
+</table>
+
+<p style="text-align: center; margin-top: 10px; font-size: 0.9em; color: #ddd;">* Partially trained on LVIS, AP<sub>o</sub> refers to COCO-O accuracy</p>
+
+</div>
+
+## Video Results
+
+<div align="center">
+<table style="min-width: 80%; border: 2px solid #ddd; border-collapse: collapse">
+  <thead>
+    <tr>
+      <th rowspan="2" style="border-right: 2px solid #ddd; padding: 12px 20px">Model</th>
+      <th colspan="2" style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">SA-V test</th>
+      <th colspan="2" style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">YT-Temporal-1B test</th>
+      <th colspan="2" style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">SmartGlasses test</th>
+      <th style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">LVVIS test</th>
+      <th style="text-align: center; padding: 12px 20px">BURST test</th>
+    </tr>
+    <tr>
+      <th style="text-align: center; padding: 12px 20px">cgF1</th>
+      <th style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">pHOTA</th>
+      <th style="text-align: center; padding: 12px 20px">cgF1</th>
+      <th style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">pHOTA</th>
+      <th style="text-align: center; padding: 12px 20px">cgF1</th>
+      <th style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">pHOTA</th>
+      <th style="text-align: center; border-right: 1px solid #eee; padding: 12px 20px">mAP</th>
+      <th style="text-align: center; padding: 12px 20px">HOTA</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td style="border-right: 2px solid #ddd; padding: 10px 20px">Human</td>
+      <td style="text-align: center; padding: 10px 20px">53.1</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">70.5</td>
+      <td style="text-align: center; padding: 10px 20px">71.2</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">78.4</td>
+      <td style="text-align: center; padding: 10px 20px">58.5</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">72.3</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">-</td>
+      <td style="text-align: center; padding: 10px 20px">-</td>
+    </tr>
+    <tr style="border-top: 2px solid #b19c9cff">
+      <td style="border-right: 2px solid #ddd; padding: 10px 20px">SAM 3</td>
+      <td style="text-align: center; padding: 10px 20px">30.3</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">58.0</td>
+      <td style="text-align: center; padding: 10px 20px">50.8</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">69.9</td>
+      <td style="text-align: center; padding: 10px 20px">36.4</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">63.6</td>
+      <td style="text-align: center; border-right: 1px solid #eee; padding: 10px 20px">36.3</td>
+      <td style="text-align: center; padding: 10px 20px">44.5</td>
+    </tr>
+  </tbody>
+</table>
+</div>
+
+## SA-Co Dataset
+
+We release 2 image benchmarks, [SA-Co/Gold](scripts/eval/gold/README.md) and
+[SA-Co/Silver](scripts/eval/silver/README.md), and a video benchmark
+[SA-Co/VEval](scripts/eval/veval/README.md). The datasets contain images (or videos) with annotated noun phrases. Each image/video and noun phrase pair is annotated with instance masks and unique IDs of each object matching the phrase. Phrases that have no matching objects (negative prompts) have no masks, shown in red font in the figure. See the linked READMEs for more details on how to download and run evaluations on the datasets.
+
+* HuggingFace host: [SA-Co/Gold](https://huggingface.co/datasets/facebook/SACo-Gold), [SA-Co/Silver](https://huggingface.co/datasets/facebook/SACo-Silver) and [SA-Co/VEval](https://huggingface.co/datasets/facebook/SACo-VEval)
+* Roboflow host: [SA-Co/Gold](https://universe.roboflow.com/sa-co-gold), [SA-Co/Silver](https://universe.roboflow.com/sa-co-silver) and [SA-Co/VEval](https://universe.roboflow.com/sa-co-veval)
+
+![SA-Co dataset](assets/sa_co_dataset.jpg?raw=true)
+
+## Development
+
+To set up the development environment:
+
+```bash
+pip install -e ".[dev,train]"
+```
+
+To format the code:
+
+```bash
+ufmt format .
+```
+
+## Contributing
+
+See [contributing](CONTRIBUTING.md) and the
+[code of conduct](CODE_OF_CONDUCT.md).
+
+## License
+
+This project is licensed under the SAM License - see the [LICENSE](LICENSE) file
+for details.
+
+## Acknowledgements
+
+We would like to thank the following people for their contributions to the SAM 3 project: Alex He, Alexander Kirillov,
+Alyssa Newcomb, Ana Paula Kirschner Mofarrej, Andrea Madotto, Andrew Westbury, Ashley Gabriel, Azita Shokpour,
+Ben Samples, Bernie Huang, Carleigh Wood, Ching-Feng Yeh, Christian Puhrsch, Claudette Ward, Daniel Bolya,
+Daniel Li, Facundo Figueroa, Fazila Vhora, George Orlin, Hanzi Mao, Helen Klein, Hu Xu, Ida Cheng, Jake Kinney,
+Jiale Zhi, Jo Sampaio, Joel Schlosser, Justin Johnson, Kai Brown, Karen Bergan, Karla Martucci, Kenny Lehmann,
+Maddie Mintz, Mallika Malhotra, Matt Ward, Michelle Chan, Michelle Restrepo, Miranda Hartley, Muhammad Maaz,
+Nisha Deo, Peter Park, Phillip Thomas, Raghu Nayani, Rene Martinez Doehner, Robbie Adkins, Ross Girshik, Sasha
+Mitts, Shashank Jain, Spencer Whitehead, Ty Toledano, Valentin Gabeur, Vincent Cho, Vivian Lee, William Ngan,
+Xuehai He, Yael Yungster, Ziqi Pang, Ziyi Dou, Zoe Quake.
+
+## Citing SAM 3
+
+If you use SAM 3 or the SA-Co dataset in your research, please use the following BibTeX entry.
+
+```bibtex
+@misc{carion2025sam3segmentconcepts,
+      title={SAM 3: Segment Anything with Concepts},
+      author={Nicolas Carion and Laura Gustafson and Yuan-Ting Hu and Shoubhik Debnath and Ronghang Hu and Didac Suris and Chaitanya Ryali and Kalyan Vasudev Alwala and Haitham Khedr and Andrew Huang and Jie Lei and Tengyu Ma and Baishan Guo and Arpit Kalla and Markus Marks and Joseph Greer and Meng Wang and Peize Sun and Roman Rädle and Triantafyllos Afouras and Effrosyni Mavroudi and Katherine Xu and Tsung-Han Wu and Yu Zhou and Liliane Momeni and Rishi Hazra and Shuangrui Ding and Sagar Vaze and Francois Porcher and Feng Li and Siyuan Li and Aishwarya Kamath and Ho Kei Cheng and Piotr Dollár and Nikhila Ravi and Kate Saenko and Pengchuan Zhang and Christoph Feichtenhofer},
+      year={2025},
+      eprint={2511.16719},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2511.16719},
+}
+```

third_party/GraspGen/sam3/README_TRAIN.md

@@ -0,0 +1,190 @@
+# Training
+
+This repository supports finetuning SAM3 models on custom datasets in multi-node setup or local execution. The training script is located at `sam3/train.py` and uses Hydra configuration management to handle complex training setups.
+
+
+## Installation
+
+```bash
+cd sam3
+pip install -e ".[train]"
+```
+
+### Training Script Usage
+
+The main training script is located at `sam3/train.py`. It uses Hydra configuration management to handle complex training setups.
+
+#### Basic Usage
+
+```bash
+# Example: Train on Roboflow dataset
+python sam3/train/train.py -c configs/roboflow_v100/roboflow_v100_full_ft_100_images.yaml
+# Example: Train on ODinW13 dataset
+python sam3/train/train.py -c configs/odinw13/odinw_text_only_train.yaml
+```
+Follow [`Roboflow 100-VL`](https://github.com/roboflow/rf100-vl/) to download the roboflow 100-vl datasets. Follow [`GLIP`](https://github.com/microsoft/GLIP) to download the ODinW datasets. The data folder should be organized as follows, and put your roboflow_vl_100_root and odinw_data_root in the job configs.
+```
+roboflow_vl_100_root:
+  13-lkc01
+    train
+    valid
+    test
+  2024-frc
+  actions
+  ...
+odinw_data_root:
+  AerialMaritimeDrone
+    large
+      train
+      valid
+      test
+  Aquarium
+  ...
+```
+
+#### Command Line Arguments
+
+The training script supports several command line arguments:
+
+```bash
+python sam3/train/train.py \
+    -c CONFIG_NAME \
+    [--use-cluster 0|1] \
+    [--partition PARTITION_NAME] \
+    [--account ACCOUNT_NAME] \
+    [--qos QOS_NAME] \
+    [--num-gpus NUM_GPUS] \
+    [--num-nodes NUM_NODES]
+```
+
+**Arguments:**
+- `-c, --config`: **Required.** Path to the configuration file (e.g., `sam3/train/configs/roboflow_v100_full_ft_100_images.yaml`)
+- `--use-cluster`: Whether to launch on a cluster (0: local, 1: cluster). Default: uses config setting
+- `--partition`: SLURM partition name for cluster execution
+- `--account`: SLURM account name for cluster execution
+- `--qos`: SLURM QOS (Quality of Service) setting
+- `--num-gpus`: Number of GPUs per node. Default: uses config setting
+- `--num-nodes`: Number of nodes for distributed training. Default: uses config setting
+
+#### Local Training Examples
+
+```bash
+# Single GPU training
+python sam3/train/train.py -c configs/roboflow_v100/roboflow_v100_full_ft_100_images.yaml --use-cluster 0 --num-gpus 1
+
+# Multi-GPU training on a single node
+python sam3/train/train.py -c configs/roboflow_v100/roboflow_v100_full_ft_100_images.yaml --use-cluster 0 --num-gpus 4
+
+# Force local execution even if config specifies GPUs
+python sam3/train/train.py -c configs/roboflow_v100/roboflow_v100_full_ft_100_images.yaml --use-cluster 0
+```
+
+#### Cluster Training Examples
+
+```bash
+# Basic cluster training with default settings from config
+python sam3/train/train.py -c configs/roboflow_v100/roboflow_v100_full_ft_100_images.yaml --use-cluster 1
+
+# Cluster training with specific SLURM settings
+python sam3/train/train.py -c configs/roboflow_v100/roboflow_v100_full_ft_100_images.yaml \
+    --use-cluster 1 \
+    --partition gpu_partition \
+    --account my_account \
+    --qos high_priority \
+    --num-gpus 8 \
+    --num-nodes 2
+```
+
+### Configuration Files
+
+Training configurations are stored in `sam3/train/configs/`. The configuration files use Hydra's YAML format and support:
+
+- **Dataset Configuration**: Data paths, transforms, and loading parameters
+- **Model Configuration**: Architecture settings, checkpoint paths, and model parameters
+- **Training Configuration**: Batch sizes, learning rates, optimization settings
+- **Launcher Configuration**: Distributed training and cluster settings
+- **Logging Configuration**: TensorBoard, experiment tracking, and output directories
+
+#### Key Configuration Sections
+
+```yaml
+# Paths to datasets and checkpoints
+paths:
+  bpe_path: /path/to/bpe/file
+  dataset_root: /path/to/dataset
+  experiment_log_dir: /path/to/logs
+
+# Launcher settings for local/cluster execution
+launcher:
+  num_nodes: 1
+  gpus_per_node: 2
+  experiment_log_dir: ${paths.experiment_log_dir}
+
+# Cluster execution settings
+submitit:
+  use_cluster: True
+  timeout_hour: 72
+  cpus_per_task: 10
+  partition: null
+  account: null
+```
+
+### Monitoring Training
+
+The training script automatically sets up logging and saves outputs to the experiment directory:
+
+```bash
+# Logs are saved to the experiment_log_dir specified in config
+experiment_log_dir/
+├── config.yaml              # Original configuration
+├── config_resolved.yaml     # Resolved configuration with all variables expanded
+├── checkpoints/             # Model checkpoints (if skip_checkpointing=False)
+├── tensorboard/             # TensorBoard logs
+├── logs/                    # Text logs
+└── submitit_logs/           # Cluster job logs (if using cluster)
+```
+
+You can monitor training progress using TensorBoard:
+
+```bash
+tensorboard --logdir /path/to/experiment_log_dir/tensorboard
+```
+
+### Job Arrays for Dataset Sweeps
+
+The Roboflow and ODinW configuration supports job arrays for training multiple models on different datasets:
+
+This feature is specifically enabled via,
+```yaml
+submitit:
+  job_array:
+    num_tasks: 100
+    task_index: 0
+```
+
+The configuration includes a complete list of 100 Roboflow supercategories, and the `submitit.job_array.task_index` automatically selects which dataset to use based on the array job index.
+
+```bash
+# Submit job array to train on different Roboflow datasets
+# The job array index selects which dataset from all_roboflow_supercategories
+python sam3/train/train.py -c configs/roboflow_v100/roboflow_v100_full_ft_100_images.yaml \
+    --use-cluster 1
+```
+
+### Reproduce ODinW13 10-shot results
+Running the following job will give the results on the ODinW13 seed 300, see `odinw_train.train_file: fewshot_train_shot10_seed300` in the config file.
+```bash
+# Example: Train on ODinW13 dataset
+python sam3/train/train.py -c configs/odinw13/odinw_text_only_train.yaml
+```
+Change `odinw_train.train_file` to `fewshot_train_shot10_seed30` and `fewshot_train_shot10_seed3` to get the results for the other two seeds. Final results are aggregated from the three seeds. Notice that a small number of jobs may diverge during training, in which case we just use the last checkpoint's result before it diverges.
+
+
+### Eval Script Usage
+With a similar setup as the training config, the training script `sam3/train.py` can also be used for evaluation, too, when setting `trainer.mode = val` in the job config. Run the following job will give the results on the zero-shot results on RF100-VL and ODinW13 datasets.
+```bash
+# Example: Evaluate on Roboflow dataset
+python sam3/train/train.py -c configs/roboflow_v100/roboflow_v100_eval.yaml
+# Example: Evaluate on ODinW13 dataset
+python sam3/train/train.py -c configs/odinw13/odinw_text_only.yaml
+```

third_party/GraspGen/sam3/examples/saco_gold_silver_vis_example.ipynb

@@ -0,0 +1,256 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "37048f21",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Copyright (c) Meta Platforms, Inc. and affiliates."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "154d8663",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "using_colab = False"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "b85d99d9",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "if using_colab:\n",
+        "    import torch\n",
+        "    import torchvision\n",
+        "    print(\"PyTorch version:\", torch.__version__)\n",
+        "    print(\"Torchvision version:\", torchvision.__version__)\n",
+        "    print(\"CUDA is available:\", torch.cuda.is_available())\n",
+        "    import sys\n",
+        "    !{sys.executable} -m pip install opencv-python matplotlib scikit-learn\n",
+        "    !{sys.executable} -m pip install 'git+https://github.com/facebookresearch/sam3.git'"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "da21a3bc",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "from glob import glob\n",
+        "\n",
+        "import numpy as np\n",
+        "import sam3.visualization_utils as utils\n",
+        "\n",
+        "from matplotlib import pyplot as plt\n",
+        "\n",
+        "COLORS = utils.pascal_color_map()[1:]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "57e85e7e",
+      "metadata": {},
+      "source": [
+        "1. Load the data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "a796734e",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Preapre the data path\n",
+        "ANNOT_DIR = None # PUT YOUR ANNOTATION PATH HERE\n",
+        "IMG_DIR = None # PUT YOUR IMAGE PATH HERE\n",
+        "\n",
+        "# Load the SA-CO/Gold annotation files\n",
+        "annot_file_list = glob(os.path.join(ANNOT_DIR, \"*gold*.json\"))\n",
+        "annot_dfs = utils.get_annot_dfs(file_list=annot_file_list)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "74bf92b1",
+      "metadata": {},
+      "source": [
+        "Show the annotation files being loaded"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "a95620ec",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "annot_dfs.keys()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "5ce211d3",
+      "metadata": {},
+      "source": [
+        "2. Examples of the data format"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "6ba749db",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "annot_dfs[\"gold_fg_sports_equipment_merged_a_release_test\"].keys()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "4b6dc186",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "annot_dfs[\"gold_fg_sports_equipment_merged_a_release_test\"][\"info\"]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "c41091b3",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "annot_dfs[\"gold_fg_sports_equipment_merged_a_release_test\"][\"images\"].head(3)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "a7df5771",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "annot_dfs[\"gold_fg_sports_equipment_merged_a_release_test\"][\"annotations\"].head(3)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "5673a63f",
+      "metadata": {},
+      "source": [
+        "3. Visualize the data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "b1fc2a24",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Select a target dataset\n",
+        "target_dataset_name = \"gold_fg_food_merged_a_release_test\"\n",
+        "\n",
+        "import cv2\n",
+        "from pycocotools import mask as mask_util\n",
+        "from collections import defaultdict\n",
+        "\n",
+        "# Group GT annotations by image_id\n",
+        "gt_image_np_pairs = annot_dfs[target_dataset_name][\"images\"]\n",
+        "gt_annotations = annot_dfs[target_dataset_name][\"annotations\"]\n",
+        "\n",
+        "gt_image_np_map = {img[\"id\"]: img for _, img in gt_image_np_pairs.iterrows()}\n",
+        "gt_image_np_ann_map = defaultdict(list)\n",
+        "for _, ann in gt_annotations.iterrows():\n",
+        "    image_id = ann[\"image_id\"]\n",
+        "    if image_id not in gt_image_np_ann_map:\n",
+        "        gt_image_np_ann_map[image_id] = []\n",
+        "    gt_image_np_ann_map[image_id].append(ann)\n",
+        "\n",
+        "positiveNPs = common_image_ids = [img_id for img_id in gt_image_np_map.keys() if img_id in gt_image_np_ann_map and gt_image_np_ann_map[img_id]]\n",
+        "negativeNPs = [img_id for img_id in gt_image_np_map.keys() if img_id not in gt_image_np_ann_map or not gt_image_np_ann_map[img_id]]\n",
+        "\n",
+        "num_image_nps_to_show = 10\n",
+        "fig, axes = plt.subplots(num_image_nps_to_show, 3, figsize=(15, 5 * num_image_nps_to_show))\n",
+        "for idx in range(num_image_nps_to_show):\n",
+        "    rand_idx = np.random.randint(len(positiveNPs))\n",
+        "    image_id = positiveNPs[rand_idx]\n",
+        "    noun_phrase = gt_image_np_map[image_id][\"text_input\"]\n",
+        "    img_rel_path = gt_image_np_map[image_id][\"file_name\"]\n",
+        "    full_path = os.path.join(IMG_DIR, f\"{img_rel_path}\")\n",
+        "    img = cv2.imread(full_path)\n",
+        "    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
+        "    gt_annotation = gt_image_np_ann_map[image_id]\n",
+        "\n",
+        "    def display_image_in_subplot(img, axes, row, col, title=\"\"):\n",
+        "        axes[row, col].imshow(img)\n",
+        "        axes[row, col].set_title(title)\n",
+        "        axes[row, col].axis('off')\n",
+        "\n",
+        "\n",
+        "    noun_phrases = [noun_phrase]\n",
+        "    annot_masks = [mask_util.decode(ann[\"segmentation\"]) for ann in gt_annotation]\n",
+        "\n",
+        "    # Show the image\n",
+        "    display_image_in_subplot(img, axes, idx, 0, f\"{noun_phrase}\")\n",
+        "\n",
+        "    # Show all masks over a white background\n",
+        "    all_masks = utils.draw_masks_to_frame(\n",
+        "        frame=np.ones_like(img)*255, masks=annot_masks, colors=COLORS[: len(annot_masks)]\n",
+        "    )\n",
+        "    display_image_in_subplot(all_masks, axes, idx, 1, f\"{noun_phrase} - Masks only\")\n",
+        "\n",
+        "    # Show masks overlaid on the image\n",
+        "    masked_frame = utils.draw_masks_to_frame(\n",
+        "        frame=img, masks=annot_masks, colors=COLORS[: len(annot_masks)]\n",
+        "    )\n",
+        "    display_image_in_subplot(masked_frame, axes, idx, 2, f\"{noun_phrase} - Masks overlaid\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "84a20e0e",
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "fileHeader": "",
+    "fileUid": "a2cedcd3-26e1-430d-b718-764d51077f86",
+    "isAdHoc": false,
+    "kernelspec": {
+      "display_name": "Python 3 (ipykernel)",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.10.13"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

third_party/GraspGen/sam3/examples/saco_veval_eval_example.ipynb

@@ -0,0 +1,137 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "0e0d2e74",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import json\n",
+        "import os\n",
+        "\n",
+        "from sam3.eval.saco_veval_eval import VEvalEvaluator"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "b31ab5d3",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "DATASETS_TO_EVAL = [\n",
+        "    \"saco_veval_sav_test\",\n",
+        "    \"saco_veval_yt1b_test\",\n",
+        "    \"saco_veval_smartglasses_test\",\n",
+        "]\n",
+        "# Update to the directory where the GT annotation and PRED files exist\n",
+        "GT_DIR = None # PUT YOUR ANNOTATION PATH HERE\n",
+        "PRED_DIR = None # PUT YOUR IMAGE PATH HERE"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "3a602fef",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "all_eval_res = {}\n",
+        "for dataset_name in DATASETS_TO_EVAL:\n",
+        "    gt_annot_file = os.path.join(GT_DIR, dataset_name + \".json\")\n",
+        "    pred_file = os.path.join(PRED_DIR, dataset_name + \"_preds.json\")\n",
+        "    eval_res_file = os.path.join(PRED_DIR, dataset_name + \"_eval_res.json\")\n",
+        "\n",
+        "    if os.path.exists(eval_res_file):\n",
+        "        with open(eval_res_file, \"r\") as f:\n",
+        "            eval_res = json.load(f)\n",
+        "    else:\n",
+        "        # Alternatively, we can run the evaluator offline first\n",
+        "        # by leveraging sam3/eval/saco_veval_eval.py\n",
+        "        print(f\"=== Running evaluation for Pred {pred_file} vs GT {gt_annot_file} ===\")\n",
+        "        veval_evaluator = VEvalEvaluator(\n",
+        "            gt_annot_file=gt_annot_file, eval_res_file=eval_res_file\n",
+        "        )\n",
+        "        eval_res = veval_evaluator.run_eval(pred_file=pred_file)\n",
+        "        print(f\"=== Results saved to {eval_res_file} ===\")\n",
+        "\n",
+        "    all_eval_res[dataset_name] = eval_res"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "a6dbec47",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "REPORT_METRICS = {\n",
+        "    \"video_mask_demo_cgf1_micro_50_95\": \"cgf1\",\n",
+        "    \"video_mask_all_phrase_HOTA\": \"pHOTA\",\n",
+        "}"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "cc28d29f",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "res_to_print = []\n",
+        "for dataset_name in DATASETS_TO_EVAL:\n",
+        "    eval_res = all_eval_res[dataset_name]\n",
+        "    row = [dataset_name]\n",
+        "    for metric_k, metric_v in REPORT_METRICS.items():\n",
+        "        row.append(eval_res[\"dataset_results\"][metric_k])\n",
+        "    res_to_print.append(row)\n",
+        "\n",
+        "# Print dataset header (each dataset spans 2 metrics: 13 + 3 + 13 = 29 chars)\n",
+        "print(\"| \" + \" | \".join(f\"{ds:^29}\" for ds in DATASETS_TO_EVAL) + \" |\")\n",
+        "\n",
+        "# Print metric header\n",
+        "metrics = list(REPORT_METRICS.values())\n",
+        "print(\"| \" + \" | \".join(f\"{m:^13}\" for _ in DATASETS_TO_EVAL for m in metrics) + \" |\")\n",
+        "\n",
+        "# Print eval results\n",
+        "values = []\n",
+        "for row in res_to_print:\n",
+        "    values.extend([f\"{v * 100:^13.1f}\" for v in row[1:]])\n",
+        "print(\"| \" + \" | \".join(values) + \" |\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "9976908b",
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "fileHeader": "",
+    "fileUid": "bdaa3851-85de-435f-9582-efb46951a1d0",
+    "isAdHoc": false,
+    "kernelspec": {
+      "display_name": "Python 3 (ipykernel)",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.10.13"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

third_party/GraspGen/sam3/examples/saco_veval_vis_example.ipynb

@@ -0,0 +1,269 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "37048f21",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Copyright (c) Meta Platforms, Inc. and affiliates."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "154d8663",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "using_colab = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b85d99d9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if using_colab:\n",
+    "    import torch\n",
+    "    import torchvision\n",
+    "    print(\"PyTorch version:\", torch.__version__)\n",
+    "    print(\"Torchvision version:\", torchvision.__version__)\n",
+    "    print(\"CUDA is available:\", torch.cuda.is_available())\n",
+    "    import sys\n",
+    "    !{sys.executable} -m pip install opencv-python matplotlib scikit-learn\n",
+    "    !{sys.executable} -m pip install 'git+https://github.com/facebookresearch/sam3.git'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da21a3bc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from glob import glob\n",
+    "\n",
+    "import numpy as np\n",
+    "import utils\n",
+    "\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "COLORS = utils.pascal_color_map()[1:]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57e85e7e",
+   "metadata": {},
+   "source": [
+    "1. Load the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a796734e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Preapre the data path\n",
+    "DATA_DIR = \"./sam3_saco_veval_data\" # PUT YOUR DATA PATH HERE\n",
+    "ANNOT_DIR = os.path.join(DATA_DIR, \"annotation\")\n",
+    "\n",
+    "# Load the SACO/Veval annotation files\n",
+    "annot_file_list = glob(os.path.join(ANNOT_DIR, \"*veval*.json\"))\n",
+    "annot_dfs = utils.get_annot_dfs(file_list=annot_file_list)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "74bf92b1",
+   "metadata": {},
+   "source": [
+    "Show the annotation files being loaded"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a95620ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annot_dfs.keys()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5ce211d3",
+   "metadata": {},
+   "source": [
+    "2. Examples of the data format"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6ba749db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annot_dfs[\"saco_veval_yt1b_val\"].keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4b6dc186",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annot_dfs[\"saco_veval_yt1b_val\"][\"info\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c41091b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annot_dfs[\"saco_veval_yt1b_val\"][\"videos\"].head(3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a7df5771",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annot_dfs[\"saco_veval_yt1b_val\"][\"annotations\"].head(3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24d2861c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annot_dfs[\"saco_veval_yt1b_val\"][\"categories\"].head(3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f9f98f27",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annot_dfs[\"saco_veval_yt1b_val\"][\"video_np_pairs\"].head(3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5673a63f",
+   "metadata": {},
+   "source": [
+    "3. Visualize the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da827d09",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Select a target dataset\n",
+    "target_dataset_name = \"saco_veval_yt1b_val\"\n",
+    "\n",
+    "# visualize a random positive video-np pair\n",
+    "df_pairs = annot_dfs[target_dataset_name][\"video_np_pairs\"]\n",
+    "df_positive_pairs = df_pairs[df_pairs.num_masklets > 0]\n",
+    "rand_idx = np.random.randint(len(df_positive_pairs))\n",
+    "pair_row = df_positive_pairs.iloc[rand_idx]\n",
+    "video_id = pair_row.video_id\n",
+    "noun_phrase = pair_row.noun_phrase\n",
+    "print(f\"Randomly selected video-np pair: video_id={video_id}, noun_phrase={noun_phrase}\")\n",
+    "\n",
+    "def display_image_in_subplot(img, axes, row, col, title=\"\"):\n",
+    "    axes[row, col].imshow(img)\n",
+    "    axes[row, col].set_title(title)\n",
+    "    axes[row, col].axis('off')\n",
+    "\n",
+    "num_frames_to_show = 5  # Number of frames to show per dataset\n",
+    "every_n_frames = 4  # Interval between frames to show\n",
+    "\n",
+    "fig, axes = plt.subplots(num_frames_to_show, 3, figsize=(15, 5 * num_frames_to_show))\n",
+    "\n",
+    "for idx in range(0, num_frames_to_show):\n",
+    "    sampled_frame_idx = idx * every_n_frames\n",
+    "    print(f\"Reading annotations for frame {sampled_frame_idx}\")\n",
+    "    # Get the frame and the corresponding masks and noun phrases\n",
+    "    frame, annot_masks, annot_noun_phrases = utils.get_all_annotations_for_frame(\n",
+    "        annot_dfs[target_dataset_name], video_id=video_id, frame_idx=sampled_frame_idx, data_dir=DATA_DIR, dataset=target_dataset_name\n",
+    "    )\n",
+    "    # Filter masks and noun phrases by the selected noun phrase\n",
+    "    annot_masks = [m for m, np in zip(annot_masks, annot_noun_phrases) if np == noun_phrase]\n",
+    "\n",
+    "    # Show the frame\n",
+    "    display_image_in_subplot(frame, axes, idx, 0, f\"{target_dataset_name} - {noun_phrase} - Frame {sampled_frame_idx}\")\n",
+    "\n",
+    "    # Show the annotated masks\n",
+    "    if annot_masks is None:\n",
+    "        print(f\"No masks found for video_id {video_id} at frame {sampled_frame_idx}\")\n",
+    "    else:\n",
+    "        # Show all masks over a white background\n",
+    "        all_masks = utils.draw_masks_to_frame(\n",
+    "            frame=np.ones_like(frame)*255, masks=annot_masks, colors=COLORS[: len(annot_masks)]\n",
+    "        )\n",
+    "        display_image_in_subplot(all_masks, axes, idx, 1, f\"{target_dataset_name} - {noun_phrase} - Frame {sampled_frame_idx} - Masks\")\n",
+    "        \n",
+    "        # Show masks overlaid on the frame\n",
+    "        masked_frame = utils.draw_masks_to_frame(\n",
+    "            frame=frame, masks=annot_masks, colors=COLORS[: len(annot_masks)]\n",
+    "        )\n",
+    "        display_image_in_subplot(masked_frame, axes, idx, 2, f\"Dataset: {target_dataset_name} - {noun_phrase} - Frame {sampled_frame_idx} - Masks overlaid\")\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a2a23152",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

third_party/GraspGen/sam3/examples/sam3_agent.ipynb

@@ -0,0 +1,242 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Copyright (c) Meta Platforms, Inc. and affiliates."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# SAM 3 Agent"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "This notebook shows an example of how an MLLM can use SAM 3 as a tool, i.e., \"SAM 3 Agent\", to segment more complex text queries such as \"the leftmost child wearing blue vest\"."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Env Setup"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "First install `sam3` in your environment using the [installation instructions](https://github.com/facebookresearch/sam3?tab=readme-ov-file#installation) in the repository."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import torch\n",
+        "# turn on tfloat32 for Ampere GPUs\n",
+        "# https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices\n",
+        "torch.backends.cuda.matmul.allow_tf32 = True\n",
+        "torch.backends.cudnn.allow_tf32 = True\n",
+        "\n",
+        "# use bfloat16 for the entire notebook. If your card doesn't support it, try float16 instead\n",
+        "torch.autocast(\"cuda\", dtype=torch.bfloat16).__enter__()\n",
+        "\n",
+        "# inference mode for the whole notebook. Disable if you need gradients\n",
+        "torch.inference_mode().__enter__()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "\n",
+        "SAM3_ROOT = os.path.dirname(os.getcwd())\n",
+        "os.chdir(SAM3_ROOT)\n",
+        "\n",
+        "# setup GPU to use -  A single GPU is good with the purpose of this demo\n",
+        "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n",
+        "_ = os.system(\"nvidia-smi\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Build SAM3 Model"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import sam3\n",
+        "from sam3 import build_sam3_image_model\n",
+        "from sam3.model.sam3_image_processor import Sam3Processor\n",
+        "\n",
+        "sam3_root = os.path.dirname(sam3.__file__)\n",
+        "bpe_path = f\"{sam3_root}/assets/bpe_simple_vocab_16e6.txt.gz\"\n",
+        "model = build_sam3_image_model(bpe_path=bpe_path)\n",
+        "processor = Sam3Processor(model, confidence_threshold=0.5)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## LLM Setup\n",
+        "\n",
+        "Config which MLLM to use, it can either be a model served by vLLM that you launch from your own machine or a model is served via external API. If you want to using a vLLM model, we also provided insturctions below."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "LLM_CONFIGS = {\n",
+        "    # vLLM-served models\n",
+        "    \"qwen3_vl_8b_thinking\": {\n",
+        "        \"provider\": \"vllm\",\n",
+        "        \"model\": \"Qwen/Qwen3-VL-8B-Thinking\",\n",
+        "    },\n",
+        "    # models served via external APIs\n",
+        "    # add your own\n",
+        "}\n",
+        "\n",
+        "model = \"qwen3_vl_8b_thinking\"\n",
+        "LLM_API_KEY = \"DUMMY_API_KEY\"\n",
+        "\n",
+        "llm_config = LLM_CONFIGS[model]\n",
+        "llm_config[\"api_key\"] = LLM_API_KEY\n",
+        "llm_config[\"name\"] = model\n",
+        "\n",
+        "# setup API endpoint\n",
+        "if llm_config[\"provider\"] == \"vllm\":\n",
+        "    LLM_SERVER_URL = \"http://0.0.0.0:8001/v1\"  # replace this with your vLLM server address as needed\n",
+        "else:\n",
+        "    LLM_SERVER_URL = llm_config[\"base_url\"]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Setup vLLM server \n",
+        "This step is only required if you are using a model served by vLLM, skip this step if you are calling LLM using an API like Gemini and GPT.\n",
+        "\n",
+        "* Install vLLM (in a separate conda env from SAM 3 to avoid dependency conflicts).\n",
+        "  ```bash\n",
+        "    conda create -n vllm python=3.12\n",
+        "    pip install vllm --extra-index-url https://download.pytorch.org/whl/cu128\n",
+        "  ```\n",
+        "* Start vLLM server on the same machine of this notebook\n",
+        "  ```bash\n",
+        "    # qwen 3 VL 8B thinking\n",
+        "    vllm serve Qwen/Qwen3-VL-8B-Thinking --tensor-parallel-size 4 --allowed-local-media-path / --enforce-eager --port 8001\n",
+        "  ```"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Run SAM3 Agent Inference"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from functools import partial\n",
+        "from IPython.display import display, Image\n",
+        "from sam3.agent.client_llm import send_generate_request as send_generate_request_orig\n",
+        "from sam3.agent.client_sam3 import call_sam_service as call_sam_service_orig\n",
+        "from sam3.agent.inference import run_single_image_inference"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "output": {
+          "id": 689664053567678,
+          "loadingStatus": "loaded"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "# prepare input args and run single image inference\n",
+        "image = \"assets/images/test_image.jpg\"\n",
+        "prompt = \"the leftmost child wearing blue vest\"\n",
+        "image = os.path.abspath(image)\n",
+        "send_generate_request = partial(send_generate_request_orig, server_url=LLM_SERVER_URL, model=llm_config[\"model\"], api_key=llm_config[\"api_key\"])\n",
+        "call_sam_service = partial(call_sam_service_orig, sam3_processor=processor)\n",
+        "output_image_path = run_single_image_inference(\n",
+        "    image, prompt, llm_config, send_generate_request, call_sam_service,\n",
+        "    debug=True, output_dir=\"agent_output\"\n",
+        ")\n",
+        "\n",
+        "# display output\n",
+        "if output_image_path is not None:\n",
+        "    display(Image(filename=output_image_path))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "fileHeader": "",
+    "fileUid": "be59e249-6c09-4634-a9e7-1f06fd233c42",
+    "isAdHoc": false,
+    "kernelspec": {
+      "display_name": "Python 3 (ipykernel)",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.12.11"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

third_party/GraspGen/sam3/examples/sam3_for_sam1_task_example.ipynb

@@ -0,0 +1,846 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f400486b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Copyright (c) Meta Platforms, Inc. and affiliates."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a1ae39ff",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "# Interactive Instance Segmentation using SAM 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b4a4b25c",
+   "metadata": {},
+   "source": [
+    "Segment Anything Model 3 (SAM 3) predicts instance masks that indicate the desired object given geometric prompts (SAM 1 task).\n",
+    "The `SAM3Image` and `Sam3Processor` classes provide an easy interface to prompt the model. The user first sets an image using the `Sam3Processor.set_image` method, which computes the necessary image embeddings. Then, prompts can be provided via the `predict` method to efficiently predict masks from those prompts. The model can take as input both point and box prompts, as well as masks from the previous iteration of prediction.\n",
+    "\n",
+    "This notebook follows the SAM 2 API for interactive image segmentation.\n",
+    "\n",
+    "# <a target=\"_blank\" href=\"https://colab.research.google.com/github/facebookresearch/sam3/blob/main/notebooks/sam3_for_sam1_task_example.ipynb\">\n",
+    "#   <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
+    "# </a>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "644532a8",
+   "metadata": {},
+   "source": [
+    "## Environment Set-up"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "07fabfee",
+   "metadata": {},
+   "source": [
+    "First install `sam3` in your environment using the [installation instructions](https://github.com/facebookresearch/sam3?tab=readme-ov-file#installation) in the repository."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0be845da",
+   "metadata": {},
+   "source": [
+    "## Set-up"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "33681dd1",
+   "metadata": {},
+   "source": [
+    "Necessary imports and helper functions for displaying points, boxes, and masks."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe773ede",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "using_colab = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "79250a4e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if using_colab:\n",
+    "    import torch\n",
+    "    import torchvision\n",
+    "    print(\"PyTorch version:\", torch.__version__)\n",
+    "    print(\"Torchvision version:\", torchvision.__version__)\n",
+    "    print(\"CUDA is available:\", torch.cuda.is_available())\n",
+    "    import sys\n",
+    "    !{sys.executable} -m pip install opencv-python matplotlib scikit-learn\n",
+    "    !{sys.executable} -m pip install 'git+https://github.com/facebookresearch/sam3.git'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "69b28288",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "# if using Apple MPS, fall back to CPU for unsupported ops\n",
+    "os.environ[\"PYTORCH_ENABLE_MPS_FALLBACK\"] = \"1\"\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "import matplotlib.pyplot as plt\n",
+    "from PIL import Image\n",
+    "import sam3\n",
+    "sam3_root = os.path.join(os.path.dirname(sam3.__file__), \"..\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "33a15e2f-c7e1-4e5d-862f-fcb751a60b89",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# select the device for computation\n",
+    "if torch.cuda.is_available():\n",
+    "    device = torch.device(\"cuda\")\n",
+    "elif torch.backends.mps.is_available():\n",
+    "    device = torch.device(\"mps\")\n",
+    "else:\n",
+    "    device = torch.device(\"cpu\")\n",
+    "print(f\"using device: {device}\")\n",
+    "\n",
+    "if device.type == \"cuda\":\n",
+    "    # use bfloat16 for the entire notebook\n",
+    "    torch.autocast(\"cuda\", dtype=torch.bfloat16).__enter__()\n",
+    "    # turn on tfloat32 for Ampere GPUs (https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices)\n",
+    "    if torch.cuda.get_device_properties(0).major >= 8:\n",
+    "        torch.backends.cuda.matmul.allow_tf32 = True\n",
+    "        torch.backends.cudnn.allow_tf32 = True\n",
+    "elif device.type == \"mps\":\n",
+    "    print(\n",
+    "        \"\\nSupport for MPS devices is preliminary. SAM 3 is trained with CUDA and might \"\n",
+    "        \"give numerically different outputs and sometimes degraded performance on MPS. \"\n",
+    "        \"See e.g. https://github.com/pytorch/pytorch/issues/84936 for a discussion.\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "29bc90d5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.random.seed(3)\n",
+    "\n",
+    "def show_mask(mask, ax, random_color=False, borders = True):\n",
+    "    if random_color:\n",
+    "        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)\n",
+    "    else:\n",
+    "        color = np.array([30/255, 144/255, 255/255, 0.6])\n",
+    "    h, w = mask.shape[-2:]\n",
+    "    mask = mask.astype(np.uint8)\n",
+    "    mask_image =  mask.reshape(h, w, 1) * color.reshape(1, 1, -1)\n",
+    "    if borders:\n",
+    "        import cv2\n",
+    "        contours, _ = cv2.findContours(mask,cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) \n",
+    "        # Try to smooth contours\n",
+    "        contours = [cv2.approxPolyDP(contour, epsilon=0.01, closed=True) for contour in contours]\n",
+    "        mask_image = cv2.drawContours(mask_image, contours, -1, (1, 1, 1, 0.5), thickness=2) \n",
+    "    ax.imshow(mask_image)\n",
+    "\n",
+    "def show_points(coords, labels, ax, marker_size=375):\n",
+    "    pos_points = coords[labels==1]\n",
+    "    neg_points = coords[labels==0]\n",
+    "    ax.scatter(pos_points[:, 0], pos_points[:, 1], color='green', marker='*', s=marker_size, edgecolor='white', linewidth=1.25)\n",
+    "    ax.scatter(neg_points[:, 0], neg_points[:, 1], color='red', marker='*', s=marker_size, edgecolor='white', linewidth=1.25)   \n",
+    "\n",
+    "def show_box(box, ax):\n",
+    "    x0, y0 = box[0], box[1]\n",
+    "    w, h = box[2] - box[0], box[3] - box[1]\n",
+    "    ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0, 0, 0, 0), lw=2))    \n",
+    "\n",
+    "def show_masks(image, masks, scores, point_coords=None, box_coords=None, input_labels=None, borders=True):\n",
+    "    for i, (mask, score) in enumerate(zip(masks, scores)):\n",
+    "        plt.figure(figsize=(10, 10))\n",
+    "        plt.imshow(image)\n",
+    "        show_mask(mask, plt.gca(), borders=borders)\n",
+    "        if point_coords is not None:\n",
+    "            assert input_labels is not None\n",
+    "            show_points(point_coords, input_labels, plt.gca())\n",
+    "        if box_coords is not None:\n",
+    "            # boxes\n",
+    "            show_box(box_coords, plt.gca())\n",
+    "        if len(scores) > 1:\n",
+    "            plt.title(f\"Mask {i+1}, Score: {score:.3f}\", fontsize=18)\n",
+    "        plt.axis('off')\n",
+    "        plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23842fb2",
+   "metadata": {},
+   "source": [
+    "## Example image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3c2e4f6b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image = Image.open(f\"{sam3_root}/assets/images/truck.jpg\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e30125fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.imshow(image)\n",
+    "plt.axis('on')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "98b228b8",
+   "metadata": {},
+   "source": [
+    "## Selecting objects with SAM 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0bb1927b",
+   "metadata": {},
+   "source": [
+    "First, load the SAM 3 model. Running on CUDA and using the default model are recommended for best results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7e28150b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sam3 import build_sam3_image_model\n",
+    "from sam3.model.sam3_image_processor import Sam3Processor\n",
+    "\n",
+    "bpe_path = f\"{sam3_root}/assets/bpe_simple_vocab_16e6.txt.gz\"\n",
+    "model = build_sam3_image_model(bpe_path=bpe_path, enable_inst_interactivity=True)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c925e829",
+   "metadata": {},
+   "source": [
+    "Process the image to produce an image embedding by calling `Sam3Processor.set_image`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d95d48dd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "processor = Sam3Processor(model)\n",
+    "inference_state = processor.set_image(image)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8fc7a46",
+   "metadata": {},
+   "source": [
+    "To select the truck, choose a point on it. Points are input to the model in (x,y) format and come with labels 1 (foreground point) or 0 (background point). Multiple points can be input; here we use only one. The chosen point will be shown as a star on the image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c69570c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_point = np.array([[520, 375]])\n",
+    "input_label = np.array([1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a91ba973",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.imshow(image)\n",
+    "show_points(input_point, input_label, plt.gca())\n",
+    "plt.axis('on')\n",
+    "plt.show()  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c765e952",
+   "metadata": {},
+   "source": [
+    "Predict with `SAM3Image.predict_inst`. The model returns masks, quality predictions for those masks, and low resolution mask logits that can be passed to the next iteration of prediction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5373fd68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masks, scores, logits = model.predict_inst(\n",
+    "    inference_state,\n",
+    "    point_coords=input_point,\n",
+    "    point_labels=input_label,\n",
+    "    multimask_output=True,\n",
+    ")\n",
+    "sorted_ind = np.argsort(scores)[::-1]\n",
+    "masks = masks[sorted_ind]\n",
+    "scores = scores[sorted_ind]\n",
+    "logits = logits[sorted_ind]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7f0e938",
+   "metadata": {},
+   "source": [
+    "With `multimask_output=True` (the default setting), SAM 3 outputs 3 masks, where `scores` gives the model's own estimation of the quality of these masks. This setting is intended for ambiguous input prompts, and helps the model disambiguate different objects consistent with the prompt. When `False`, it will return a single mask. For ambiguous prompts such as a single point, it is recommended to use `multimask_output=True` even if only a single mask is desired; the best single mask can be chosen by picking the one with the highest score returned in `scores`. This will often result in a better mask."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "47821187",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masks.shape  # (number_of_masks) x H x W"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9c227a6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "show_masks(image, masks, scores, point_coords=input_point, input_labels=input_label, borders=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3fa31f7c",
+   "metadata": {},
+   "source": [
+    "## Specifying a specific object with additional points"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88d6d29a",
+   "metadata": {},
+   "source": [
+    "The single input point is ambiguous, and the model has returned multiple objects consistent with it. To obtain a single object, multiple points can be provided. If available, a mask from a previous iteration can also be supplied to the model to aid in prediction. When specifying a single object with multiple prompts, a single mask can be requested by setting `multimask_output=False`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6923b94",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_point = np.array([[500, 375], [1125, 625]])\n",
+    "input_label = np.array([1, 1])\n",
+    "\n",
+    "mask_input = logits[np.argmax(scores), :, :]  # Choose the model's best mask"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d98f96a1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masks, scores, _ = model.predict_inst(\n",
+    "    inference_state,\n",
+    "    point_coords=input_point,\n",
+    "    point_labels=input_label,\n",
+    "    mask_input=mask_input[None, :, :],\n",
+    "    multimask_output=False,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ce8b82f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masks.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e06d5c8d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "show_masks(image, masks, scores, point_coords=input_point, input_labels=input_label)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c93e2087",
+   "metadata": {},
+   "source": [
+    "To exclude the car and specify just the window, a background point (with label 0, here shown in red) can be supplied."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9a196f68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_point = np.array([[500, 375], [1125, 625]])\n",
+    "input_label = np.array([1, 0])\n",
+    "\n",
+    "mask_input = logits[np.argmax(scores), :, :]  # Choose the model's best mask"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81a52282",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masks, scores, _ = model.predict_inst(\n",
+    "    inference_state,\n",
+    "    point_coords=input_point,\n",
+    "    point_labels=input_label,\n",
+    "    mask_input=mask_input[None, :, :],\n",
+    "    multimask_output=False,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bfca709f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "show_masks(image, masks, scores, point_coords=input_point, input_labels=input_label)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "41e2d5a9",
+   "metadata": {},
+   "source": [
+    "## Specifying a specific object with a box"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d61ca7ac",
+   "metadata": {},
+   "source": [
+    "The model can also take a box as input, provided in xyxy format."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8ea92a7b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_box = np.array([425, 600, 700, 875])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b35a8814",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masks, scores, _ = model.predict_inst(\n",
+    "    inference_state,\n",
+    "    point_coords=None,\n",
+    "    point_labels=None,\n",
+    "    box=input_box[None, :],\n",
+    "    multimask_output=False,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3ffb4906",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "show_masks(image, masks, scores, box_coords=input_box)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c1ed9f0a",
+   "metadata": {},
+   "source": [
+    "## Combining points and boxes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8455d1c5",
+   "metadata": {},
+   "source": [
+    "Points and boxes may be combined, just by including both types of prompts to the predictor. Here this can be used to select just the trucks's tire, instead of the entire wheel."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "90e2e547",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_box = np.array([425, 600, 700, 875])\n",
+    "input_point = np.array([[575, 750]])\n",
+    "input_label = np.array([0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6956d8c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masks, scores, logits = model.predict_inst(\n",
+    "    inference_state,\n",
+    "    point_coords=input_point,\n",
+    "    point_labels=input_label,\n",
+    "    box=input_box,\n",
+    "    multimask_output=False,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eb519a31",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "show_masks(image, masks, scores, box_coords=input_box, point_coords=input_point, input_labels=input_label)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45ddbca3",
+   "metadata": {},
+   "source": [
+    "## Batched prompt inputs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "df6f18a0",
+   "metadata": {},
+   "source": [
+    "`SAM3Image` can take multiple input prompts for the same image, using `predict_inst` method. For example, imagine we have several box outputs from an object detector."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a06681b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_boxes = np.array([\n",
+    "    [75, 275, 1725, 850],\n",
+    "    [425, 600, 700, 875],\n",
+    "    [1375, 550, 1650, 800],\n",
+    "    [1240, 675, 1400, 750],\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "117521a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masks, scores, _ = model.predict_inst(\n",
+    "    inference_state,\n",
+    "    point_coords=None,\n",
+    "    point_labels=None,\n",
+    "    box=input_boxes,\n",
+    "    multimask_output=False,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6a8f5d49",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masks.shape  # (batch_size) x (num_predicted_masks_per_input) x H x W"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c00c3681",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.imshow(image)\n",
+    "for mask in masks:\n",
+    "    show_mask(mask.squeeze(0), plt.gca(), random_color=True)\n",
+    "for box in input_boxes:\n",
+    "    show_box(box, plt.gca())\n",
+    "plt.axis('off')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b9a27b5d",
+   "metadata": {},
+   "source": [
+    "## End-to-end batched inference\n",
+    "If all prompts are available in advance, it is possible to run SAM 3 directly in an end-to-end fashion. This also allows batching over images."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d485f75b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image1 = image  # truck.jpg from above\n",
+    "image1_boxes = np.array([\n",
+    "    [75, 275, 1725, 850],\n",
+    "    [425, 600, 700, 875],\n",
+    "    [1375, 550, 1650, 800],\n",
+    "    [1240, 675, 1400, 750],\n",
+    "])\n",
+    "\n",
+    "image2 = Image.open(f\"{sam3_root}/assets/images/groceries.jpg\")\n",
+    "image2_boxes = np.array([\n",
+    "    [450, 170, 520, 350],\n",
+    "    [350, 190, 450, 350],\n",
+    "    [500, 170, 580, 350],\n",
+    "    [580, 170, 640, 350],\n",
+    "])\n",
+    "\n",
+    "img_batch = [image1, image2]\n",
+    "boxes_batch = [image1_boxes, image2_boxes]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "47932c99",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inference_state = processor.set_image_batch(img_batch)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "97af3c54",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masks_batch, scores_batch, _ = model.predict_inst_batch(\n",
+    "    inference_state,\n",
+    "    None,\n",
+    "    None, \n",
+    "    box_batch=boxes_batch, \n",
+    "    multimask_output=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "226df881",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for image, boxes, masks in zip(img_batch, boxes_batch, masks_batch):\n",
+    "    plt.figure(figsize=(10, 10))\n",
+    "    plt.imshow(image)   \n",
+    "    for mask in masks:\n",
+    "        show_mask(mask.squeeze(0), plt.gca(), random_color=True)\n",
+    "    for box in boxes:\n",
+    "        show_box(box, plt.gca())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "46f30085",
+   "metadata": {},
+   "source": [
+    "Similarly, we can have a batch of point prompts defined over a batch of images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1ab929fc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image1 = image  # truck.jpg from above\n",
+    "image1_pts = np.array([\n",
+    "    [[500, 375]],\n",
+    "    [[650, 750]]\n",
+    "    ]) # Bx1x2 where B corresponds to number of objects \n",
+    "image1_labels = np.array([[1], [1]])\n",
+    "\n",
+    "image2_pts = np.array([\n",
+    "    [[400, 300]],\n",
+    "    [[630, 300]],\n",
+    "])\n",
+    "image2_labels = np.array([[1], [1]])\n",
+    "\n",
+    "pts_batch = [image1_pts, image2_pts]\n",
+    "labels_batch = [image1_labels, image2_labels]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "848f8287",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masks_batch, scores_batch, _ = model.predict_inst_batch(inference_state, pts_batch, labels_batch, box_batch=None, multimask_output=True)\n",
+    "\n",
+    "# Select the best single mask per object\n",
+    "best_masks = []\n",
+    "for masks, scores in zip(masks_batch,scores_batch):\n",
+    "    best_masks.append(masks[range(len(masks)), np.argmax(scores, axis=-1)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99b15c6c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for image, points, labels, masks in zip(img_batch, pts_batch, labels_batch, best_masks):\n",
+    "    plt.figure(figsize=(10, 10))\n",
+    "    plt.imshow(image)   \n",
+    "    for mask in masks:\n",
+    "        show_mask(mask, plt.gca(), random_color=True)\n",
+    "    show_points(points, labels, plt.gca())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4c1594a5-a0de-4477-91d4-db4504a78a83",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "74e3d07e-b0de-48a5-9d29-d639a0dbcdfc",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d8b1de3a-a253-48ff-8a1c-d80742acbe86",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

third_party/GraspGen/sam3/examples/sam3_for_sam2_video_task_example.ipynb

@@ -0,0 +1,979 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3c3b1c46-9f5c-41c1-9101-85db8709ec0d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Copyright (c) Meta Platforms, Inc. and affiliates."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e7a0db5-7f04-4845-8b11-684fe6e9f7f2",
+   "metadata": {},
+   "source": [
+    "# Video object segmentation with SAM 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "162d0b3c-4207-442d-969c-aa1cbb8fd4ad",
+   "metadata": {},
+   "source": [
+    "This notebook shows how to use SAM 3 for video object segmentation in videos, illustrating the use of the  `Sam3TrackerPredictor` class.\n",
+    "\n",
+    "\n",
+    "This notebook follows the SAM 2 API for interactive video segmentation.\n",
+    "\n",
+    "<a target=\"_blank\" href=\"https://colab.research.google.com/github/facebookresearch/sam3/blob/main/notebooks/sam3_for_sam2_video_task_example.ipynb\">\n",
+    "  <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
+    "</a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "26616201-06df-435b-98fd-ad17c373bb4a",
+   "metadata": {},
+   "source": [
+    "## Environment Set-up"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8491a127-4c01-48f5-9dc5-f148a9417fdf",
+   "metadata": {},
+   "source": [
+    "First install `sam3` in your environment using the [installation instructions](https://github.com/facebookresearch/sam3?tab=readme-ov-file#installation) in the repository."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f74c53be-aab1-46b9-8c0b-068b52ef5948",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "using_colab = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d824a4b2-71f3-4da3-bfc7-3249625e6730",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if using_colab:\n",
+    "    import torch\n",
+    "    import torchvision\n",
+    "    print(\"PyTorch version:\", torch.__version__)\n",
+    "    print(\"Torchvision version:\", torchvision.__version__)\n",
+    "    print(\"CUDA is available:\", torch.cuda.is_available())\n",
+    "    import sys\n",
+    "    !{sys.executable} -m pip install opencv-python matplotlib scikit-learn\n",
+    "    !{sys.executable} -m pip install 'git+https://github.com/facebookresearch/sam3.git'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22e6aa9d-487f-4207-b657-8cff0902343e",
+   "metadata": {},
+   "source": [
+    "## Set-up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d3cae821",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "# select the device for computation\n",
+    "if torch.cuda.is_available():\n",
+    "    device = torch.device(\"cuda\")\n",
+    "elif torch.backends.mps.is_available():\n",
+    "    device = torch.device(\"mps\")\n",
+    "else:\n",
+    "    device = torch.device(\"cpu\")\n",
+    "print(f\"using device: {device}\")\n",
+    "\n",
+    "if device.type == \"cuda\":\n",
+    "    # use bfloat16 for the entire notebook\n",
+    "    torch.autocast(\"cuda\", dtype=torch.bfloat16).__enter__()\n",
+    "    # turn on tfloat32 for Ampere GPUs (https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices)\n",
+    "    if torch.cuda.get_device_properties(0).major >= 8:\n",
+    "        torch.backends.cuda.matmul.allow_tf32 = True\n",
+    "        torch.backends.cudnn.allow_tf32 = True\n",
+    "\n",
+    "elif device.type == \"mps\":\n",
+    "    print(\n",
+    "        \"\\nSupport for MPS devices is preliminary. SAM 3 is trained with CUDA and might \"\n",
+    "        \"give numerically different outputs and sometimes degraded performance on MPS. \"\n",
+    "        \"See e.g. https://github.com/pytorch/pytorch/issues/84936 for a discussion.\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e5318a85-5bf7-4880-b2b3-15e4db24d796",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import glob\n",
+    "import os\n",
+    "\n",
+    "import cv2\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "import sam3\n",
+    "import torch\n",
+    "from PIL import Image\n",
+    "from sam3.visualization_utils import show_box, show_mask, show_points\n",
+    "\n",
+    "# font size for axes titles\n",
+    "plt.rcParams[\"axes.titlesize\"] = 12\n",
+    "plt.rcParams[\"figure.titlesize\"] = 12\n",
+    "\n",
+    "sam3_root = os.path.join(os.path.dirname(sam3.__file__), \"..\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae8e0779-751f-4224-9b04-ed0f0b406500",
+   "metadata": {},
+   "source": [
+    "### Loading the SAM 3 tracking predictor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f5f3245e-b4d6-418b-a42a-a67e0b3b5aec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sam3.model_builder import build_sam3_video_model\n",
+    "\n",
+    "sam3_model = build_sam3_video_model()\n",
+    "predictor = sam3_model.tracker\n",
+    "predictor.backbone = sam3_model.detector.backbone"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dff46b10-c17a-4a26-8004-8c6d80806b0a",
+   "metadata": {},
+   "source": [
+    "#### Initialize the inference state"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f594ac71-a6b9-461d-af27-500fa1d1a420",
+   "metadata": {},
+   "source": [
+    "Just like SAM 2, SAM 3 requires stateful inference for interactive video segmentation, so we need to initialize an **inference state** on this video.\n",
+    "\n",
+    "During initialization, it loads all the JPEG frames in `video_path` and stores their pixels in `inference_state` (as shown in the progress bar below)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9baa05c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "video_path = f\"{sam3_root}/assets/videos/bedroom.mp4\"\n",
+    "inference_state = predictor.init_state(video_path=video_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "edb1f3f6-d74d-4016-934c-8d2a14d1a543",
+   "metadata": {},
+   "source": [
+    "### Example 1: Segment & track one object"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa2d3127-67b2-45d2-9f32-8fe3e10dc5eb",
+   "metadata": {},
+   "source": [
+    "Note: if you have run any previous tracking using this `inference_state`, please reset it first via `clear_all_points_in_video`.\n",
+    "\n",
+    "(The cell below is just for illustration; it's not needed to call `clear_all_points_in_video` here as this `inference_state` is just freshly initialized above.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d2646a1d-3401-438c-a653-55e0e56b7d9d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "predictor.clear_all_points_in_video(inference_state)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "26aeb04d-8cba-4f57-95da-6e5a1796003e",
+   "metadata": {},
+   "source": [
+    "#### Step 1: Add a first click on a frame"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "695c7749-b523-4691-aad0-7558c5d1d68c",
+   "metadata": {},
+   "source": [
+    "To get started, let's try to segment the child on the left.\n",
+    "\n",
+    "Here we make a **positive click** at (x, y) = (210, 350) with label `1`, by sending their coordinates and labels into the `add_new_points` API.\n",
+    "\n",
+    "Note: label `1` indicates a *positive click (to add a region)* while label `0` indicates a *negative click (to remove a region)*."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dd6778a1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load the frames for visualization\n",
+    "cap = cv2.VideoCapture(video_path)\n",
+    "video_frames_for_vis = []\n",
+    "while True:\n",
+    "    ret, frame = cap.read()\n",
+    "    if not ret:\n",
+    "        break\n",
+    "    video_frames_for_vis.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))\n",
+    "cap.release()\n",
+    "frame0 = video_frames_for_vis[0]\n",
+    "\n",
+    "width, height = frame0.shape[1], frame0.shape[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3e749bab-0f36-4173-bf8d-0c20cd5214b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ann_frame_idx = 0  # the frame index we interact with\n",
+    "ann_obj_id = 1  # give a unique id to each object we interact with (it can be any integers)\n",
+    "\n",
+    "# Let's add a positive click at (x, y) = (210, 350) to get started\n",
+    "points = np.array([[210, 350]], dtype=np.float32)\n",
+    "# for labels, `1` means positive click and `0` means negative click\n",
+    "labels = np.array([1], np.int32)\n",
+    "\n",
+    "rel_points = [[x / width, y / height] for x, y in points]\n",
+    "\n",
+    "points_tensor = torch.tensor(rel_points, dtype=torch.float32)\n",
+    "points_labels_tensor = torch.tensor(labels, dtype=torch.int32)\n",
+    "\n",
+    "_, out_obj_ids, low_res_masks, video_res_masks = predictor.add_new_points(\n",
+    "    inference_state=inference_state,\n",
+    "    frame_idx=ann_frame_idx,\n",
+    "    obj_id=ann_obj_id,\n",
+    "    points=points_tensor,\n",
+    "    labels=points_labels_tensor,\n",
+    "    clear_old_points=False,\n",
+    ")\n",
+    "\n",
+    "# show the results on the current (interacted) frame\n",
+    "plt.figure(figsize=(9, 6))\n",
+    "plt.title(f\"frame {ann_frame_idx}\")\n",
+    "plt.imshow(frame0)\n",
+    "show_points(points, labels, plt.gca())\n",
+    "show_mask((video_res_masks[0] > 0.0).cpu().numpy(), plt.gca(), obj_id=out_obj_ids[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "89457875-93fa-40ed-b6dc-4e1c971a27f9",
+   "metadata": {},
+   "source": [
+    "#### Step 2: Add a second click to refine the prediction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a75eb21b-1413-452c-827b-a04093c30c78",
+   "metadata": {},
+   "source": [
+    "Hmm, it seems that although we wanted to segment the child on the left, the model predicts the mask for only the shorts -- this can happen since there is ambiguity from a single click about what the target object should be. We can refine the mask on this frame via another positive click on the child's shirt.\n",
+    "\n",
+    "Here we make a **second positive click** at (x, y) = (250, 220) with label `1` to expand the mask.\n",
+    "\n",
+    "Note: we need to send **all the clicks and their labels** (i.e. not just the last click) when calling `add_new_points`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e1ab3ec7-2537-4158-bf98-3d0977d8908d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ann_frame_idx = 0  # the frame index we interact with\n",
+    "ann_obj_id = 1  # give a unique id to each object we interact with (it can be any integers)\n",
+    "\n",
+    "# Let's add a 2nd positive click at (x, y) = (250, 220) to refine the mask\n",
+    "# sending all clicks (and their labels) to `add_new_points_or_box`\n",
+    "points = np.array([[210, 350], [250, 220]], dtype=np.float32)\n",
+    "# for labels, `1` means positive click and `0` means negative click\n",
+    "labels = np.array([1, 1], np.int32)\n",
+    "\n",
+    "rel_points = [[x / width, y / height] for x, y in points]\n",
+    "\n",
+    "points_tensor = torch.tensor(rel_points, dtype=torch.float32)\n",
+    "points_labels_tensor = torch.tensor(labels, dtype=torch.int32)\n",
+    "\n",
+    "_, out_obj_ids, low_res_masks, video_res_masks  = predictor.add_new_points(\n",
+    "    inference_state=inference_state,\n",
+    "    frame_idx=ann_frame_idx,\n",
+    "    obj_id=ann_obj_id,\n",
+    "    points=points_tensor,\n",
+    "    labels=points_labels_tensor,\n",
+    "    clear_old_points=False,\n",
+    ")\n",
+    "\n",
+    "# show the results on the current (interacted) frame\n",
+    "plt.figure(figsize=(9, 6))\n",
+    "plt.title(f\"frame {ann_frame_idx}\")\n",
+    "plt.imshow(frame0)\n",
+    "show_points(points, labels, plt.gca())\n",
+    "show_mask((video_res_masks[0] > 0.0).cpu().numpy(), plt.gca(), obj_id=out_obj_ids[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "df4ab457-d91d-4ac8-b350-fbcd549fd3fd",
+   "metadata": {},
+   "source": [
+    "With this 2nd refinement click, now we get a segmentation mask of the entire child on frame 0."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f52015ac-1b7b-4c59-bca3-c2b28484cf46",
+   "metadata": {},
+   "source": [
+    "#### Step 3: Propagate the prompts to get the masklet across the video"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30b025bd-cd58-4bfb-9572-c8d2fd0a02ef",
+   "metadata": {},
+   "source": [
+    "To get the masklet throughout the entire video, we propagate the prompts using the `propagate_in_video` API."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ab45e932-b0d5-4983-9718-6ee77d1ac31b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# run propagation throughout the video and collect the results in a dict\n",
+    "video_segments = {}  # video_segments contains the per-frame segmentation results\n",
+    "for frame_idx, obj_ids, low_res_masks, video_res_masks, obj_scores in predictor.propagate_in_video(inference_state, start_frame_idx=0, max_frame_num_to_track=240, reverse=False, propagate_preflight=True):\n",
+    "    video_segments[frame_idx] = {\n",
+    "        out_obj_id: (video_res_masks[i] > 0.0).cpu().numpy()\n",
+    "        for i, out_obj_id in enumerate(out_obj_ids)\n",
+    "    }\n",
+    "\n",
+    "# render the segmentation results every few frames\n",
+    "vis_frame_stride = 30\n",
+    "plt.close(\"all\")\n",
+    "for out_frame_idx in range(0, len(video_frames_for_vis), vis_frame_stride):\n",
+    "    plt.figure(figsize=(6, 4))\n",
+    "    plt.title(f\"frame {out_frame_idx}\")\n",
+    "    plt.imshow(video_frames_for_vis[out_frame_idx])\n",
+    "    for out_obj_id, out_mask in video_segments[out_frame_idx].items():\n",
+    "        show_mask(out_mask, plt.gca(), obj_id=out_obj_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3e801b70-72df-4a72-b3fe-84f145e5e3f6",
+   "metadata": {},
+   "source": [
+    "#### Step 4: Add new prompts to further refine the masklet"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "478958ab-29b4-4a75-bba4-adb1b03d0a2b",
+   "metadata": {},
+   "source": [
+    "It appears that in the output masklet above, there are some small imperfections in boundary details on frame 150.\n",
+    "\n",
+    "With SAM 3 we can fix the model predictions interactively. We can add a **negative click** at (x, y) = (82, 415) on this frame with label `0` to refine the masklet. Here we call the `add_new_points_or_box` API with a different `frame_idx` argument to indicate the frame index we want to refine."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1a572ea9-5b7e-479c-b30c-93c38b121131",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ann_frame_idx = 150  # further refine some details on this frame\n",
+    "ann_obj_id = 1  # give a unique id to the object we interact with (it can be any integers)\n",
+    "\n",
+    "# show the segment before further refinement\n",
+    "plt.figure(figsize=(9, 6))\n",
+    "plt.title(f\"frame {ann_frame_idx} -- before refinement\")\n",
+    "plt.imshow(video_frames_for_vis[ann_frame_idx])\n",
+    "show_mask(video_segments[ann_frame_idx][ann_obj_id], plt.gca(), obj_id=ann_obj_id)\n",
+    "\n",
+    "# Let's add a negative click on this frame at (x, y) = (82, 415) to refine the segment\n",
+    "points = np.array([[82, 410]], dtype=np.float32)\n",
+    "# for labels, `1` means positive click and `0` means negative click\n",
+    "labels = np.array([0], np.int32)\n",
+    "\n",
+    "rel_points = [[x / width, y / height] for x, y in points]\n",
+    "\n",
+    "points_tensor = torch.tensor(rel_points, dtype=torch.float32)\n",
+    "points_labels_tensor = torch.tensor(labels, dtype=torch.int32)\n",
+    "\n",
+    "_, out_obj_ids, low_res_masks, video_res_masks  = predictor.add_new_points(\n",
+    "    inference_state=inference_state,\n",
+    "    frame_idx=ann_frame_idx,\n",
+    "    obj_id=ann_obj_id,\n",
+    "    points=points_tensor,\n",
+    "    labels=points_labels_tensor,\n",
+    "    clear_old_points=False,\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# show the segment after the further refinement\n",
+    "plt.figure(figsize=(9, 6))\n",
+    "plt.title(f\"frame {ann_frame_idx} -- after refinement\")\n",
+    "plt.imshow(video_frames_for_vis[ann_frame_idx])\n",
+    "show_points(points, labels, plt.gca())\n",
+    "show_mask((video_res_masks > 0.0).cpu().numpy(), plt.gca(), obj_id=ann_obj_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50a3950a-acf1-435c-bd64-94297267b5e9",
+   "metadata": {},
+   "source": [
+    "#### Step 5: Propagate the prompts (again) to get the masklet across the video"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b1954ecf-c2ec-4f9c-8d10-c4f527a10cd2",
+   "metadata": {},
+   "source": [
+    "Let's get an updated masklet for the entire video. Here we call `propagate_in_video` again to propagate all the prompts after adding the new refinement click above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "baa96690-4a38-4a24-aa17-fd2f4db0e232",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# run propagation throughout the video and collect the results in a dict\n",
+    "video_segments = {}  # video_segments contains the per-frame segmentation results\n",
+    "for frame_idx, obj_ids, low_res_masks, video_res_masks, obj_scores in predictor.propagate_in_video(inference_state, start_frame_idx=0, max_frame_num_to_track=300, reverse=False, propagate_preflight=True):\n",
+    "    video_segments[frame_idx] = {\n",
+    "        out_obj_id: (video_res_masks[i] > 0.0).cpu().numpy()\n",
+    "        for i, out_obj_id in enumerate(out_obj_ids)\n",
+    "    }\n",
+    "\n",
+    "# render the segmentation results every few frames\n",
+    "vis_frame_stride = 30\n",
+    "plt.close(\"all\")\n",
+    "for out_frame_idx in range(0, len(video_frames_for_vis), vis_frame_stride):\n",
+    "    plt.figure(figsize=(6, 4))\n",
+    "    plt.title(f\"frame {out_frame_idx}\")\n",
+    "    plt.imshow(video_frames_for_vis[out_frame_idx])\n",
+    "    for out_obj_id, out_mask in video_segments[out_frame_idx].items():\n",
+    "        show_mask(out_mask, plt.gca(), obj_id=out_obj_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "607507e3-6a2b-4fd7-944c-2371bdab9d01",
+   "metadata": {},
+   "source": [
+    "The segments now look good on all frames."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2502bb5a-3e1f-43d0-9f58-33f8676fff0d",
+   "metadata": {},
+   "source": [
+    "### Example 2: Segment an object using box prompt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8e2d26c8-0432-48c6-997e-4a3b77bb5f6d",
+   "metadata": {},
+   "source": [
+    "Note: if you have run any previous tracking using this `inference_state`, please reset it first via `clear_all_points_in_video`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6dbe9183-abbb-4283-b0cb-d24f3d7beb34",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "predictor.clear_all_points_in_video(inference_state)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ceb6eae9-0f4c-434f-8089-a46c9ca59da5",
+   "metadata": {},
+   "source": [
+    "In addition to using clicks as inputs, SAM 3 also supports segmenting and tracking objects in a video via **bounding boxes**.\n",
+    "\n",
+    "In the example below, we segment the child on the right using a **box prompt** of (x_min, y_min, x_max, y_max) = (300, 0, 500, 400) on frame 0 as input into the `add_new_points_or_box` API."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1cbfb273-4e14-495b-bd89-87a8baf52ae7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ann_frame_idx = 0  # the frame index we interact with\n",
+    "ann_obj_id = 4  # give a unique id to each object we interact with (it can be any integers)\n",
+    "\n",
+    "# Let's add a box at (x_min, y_min, x_max, y_max) = (300, 0, 500, 400) to get started\n",
+    "box = np.array([[300, 0, 500, 400]], dtype=np.float32)\n",
+    "\n",
+    "rel_box = [[xmin / width, ymin / height, xmax / width, ymax / height] for xmin, ymin, xmax, ymax in box]\n",
+    "rel_box = np.array(rel_box, dtype=np.float32)\n",
+    "\n",
+    "_, out_obj_ids, low_res_masks, video_res_masks  = predictor.add_new_points_or_box(\n",
+    "    inference_state=inference_state,\n",
+    "    frame_idx=ann_frame_idx,\n",
+    "    obj_id=ann_obj_id,\n",
+    "    box=rel_box,\n",
+    ")\n",
+    "\n",
+    "# show the results on the current (interacted) frame\n",
+    "plt.figure(figsize=(9, 6))\n",
+    "plt.title(f\"frame {ann_frame_idx}\")\n",
+    "plt.imshow(video_frames_for_vis[ann_frame_idx])\n",
+    "show_box(box[0], plt.gca())\n",
+    "show_mask((video_res_masks[0] > 0.0).cpu().numpy(), plt.gca(), obj_id=ann_obj_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd3f9ba7-bf4d-47e5-9b02-8a424cab42cc",
+   "metadata": {},
+   "source": [
+    "Here, SAM 3 gets a pretty good segmentation mask of the entire child, even though the input bounding box is not perfectly tight around the object.\n",
+    "\n",
+    "Similar to the previous example, if the returned mask from is not perfect when using a box prompt, we can also further **refine** the output using positive or negative clicks. To illustrate this, here we make a **positive click** at (x, y) = (460, 60) with label `1` to expand the segment around the child's hair.\n",
+    "\n",
+    "Note: to refine the segmentation mask from a box prompt, we need to send **both the original box input and all subsequent refinement clicks and their labels** when calling `add_new_points_or_box`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "54906315-ab4c-4088-b866-4c22134d5b66",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ann_frame_idx = 0  # the frame index we interact with\n",
+    "ann_obj_id = 4  # give a unique id to each object we interact with (it can be any integers)\n",
+    "\n",
+    "# Let's add a positive click at (x, y) = (460, 60) to refine the mask\n",
+    "points = np.array([[460, 60]], dtype=np.float32)\n",
+    "# for labels, `1` means positive click and `0` means negative click\n",
+    "labels = np.array([1], np.int32)\n",
+    "# note that we also need to send the original box input along with\n",
+    "# the new refinement click together into `add_new_points_or_box`\n",
+    "box = np.array([[300, 0, 500, 400]], dtype=np.float32)\n",
+    "\n",
+    "rel_box = [[xmin / width, ymin / height, xmax / width, ymax / height] for xmin, ymin, xmax, ymax in box]\n",
+    "rel_box = np.array(rel_box, dtype=np.float32)\n",
+    "\n",
+    "rel_points = [[x / width, y / height] for x, y in points]\n",
+    "\n",
+    "points_tensor = torch.tensor(rel_points, dtype=torch.float32)\n",
+    "points_labels_tensor = torch.tensor(labels, dtype=torch.int32)\n",
+    "\n",
+    "_, out_obj_ids, low_res_masks, video_res_masks  = predictor.add_new_points_or_box(\n",
+    "    inference_state=inference_state,\n",
+    "    frame_idx=ann_frame_idx,\n",
+    "    obj_id=ann_obj_id,\n",
+    "    points=points_tensor,\n",
+    "    labels=points_labels_tensor,\n",
+    "    box=rel_box,\n",
+    ")\n",
+    "\n",
+    "# show the results on the current (interacted) frame\n",
+    "plt.figure(figsize=(9, 6))\n",
+    "plt.title(f\"frame {ann_frame_idx}\")\n",
+    "plt.imshow(video_frames_for_vis[ann_frame_idx])\n",
+    "show_box(box[0], plt.gca())\n",
+    "show_points(points, labels, plt.gca())\n",
+    "show_mask((video_res_masks[0][0] > 0.0).cpu().numpy(), plt.gca(), obj_id=out_obj_ids[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "73128cd6-dbfa-49f7-8d79-1a8e19835f7f",
+   "metadata": {},
+   "source": [
+    "Then, to get the masklet throughout the entire video, we propagate the prompts using the `propagate_in_video` API."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9cd90557-a0dc-442e-b091-9c74c831bef8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# run propagation throughout the video and collect the results in a dict\n",
+    "video_segments = {}  # video_segments contains the per-frame segmentation results\n",
+    "for frame_idx, obj_ids, low_res_masks, video_res_masks, obj_scores in predictor.propagate_in_video(inference_state, start_frame_idx=0, max_frame_num_to_track=300, reverse=False, propagate_preflight=True):\n",
+    "    video_segments[frame_idx] = {\n",
+    "        out_obj_id: (video_res_masks[i] > 0.0).cpu().numpy()\n",
+    "        for i, out_obj_id in enumerate(out_obj_ids)\n",
+    "    }\n",
+    "\n",
+    "# render the segmentation results every few frames\n",
+    "vis_frame_stride = 30\n",
+    "plt.close(\"all\")\n",
+    "for out_frame_idx in range(0, len(video_frames_for_vis), vis_frame_stride):\n",
+    "    plt.figure(figsize=(6, 4))\n",
+    "    plt.title(f\"frame {out_frame_idx}\")\n",
+    "    plt.imshow(video_frames_for_vis[out_frame_idx])\n",
+    "    for out_obj_id, out_mask in video_segments[out_frame_idx].items():\n",
+    "        show_mask(out_mask, plt.gca(), obj_id=out_obj_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e023f91f-0cc5-4980-ae8e-a13c5749112b",
+   "metadata": {},
+   "source": [
+    "Note that in addition to clicks or boxes, SAM 3 also supports directly using a **mask prompt** as input via the `add_new_mask` method in the `Sam3TrackerPredictor` class. This can be helpful in e.g. semi-supervised VOS evaluations (see [tools/vos_inference.py](https://github.com/facebookresearch/sam2/blob/main/tools/vos_inference.py) for an example)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "da018be8-a4ae-4943-b1ff-702c2b89cb68",
+   "metadata": {},
+   "source": [
+    "### Example 3: Segment multiple objects simultaneously"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dea6c04c-3072-4876-b394-879321a48c4a",
+   "metadata": {},
+   "source": [
+    "Note: if you have run any previous tracking using this `inference_state`, please reset it first via `clear_all_points_in_video`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "29b874c8-9f39-42d3-a667-54a0bd696410",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "predictor.clear_all_points_in_video(inference_state)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "48f3f7e6-4821-468c-84e4-f3a0435c9149",
+   "metadata": {},
+   "source": [
+    "#### Step 1: Add two objects on a frame"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "95158714-86d7-48a9-8365-b213f97cc9ca",
+   "metadata": {},
+   "source": [
+    "SAM 3 can also segment and track two or more objects at the same time. One way, of course, is to do them one by one. However, it would be more efficient to batch them together (e.g. so that we can share the image features between objects to reduce computation costs).\n",
+    "\n",
+    "This time, let's focus on object parts and segment **the shirts of both childen** in this video. Here we add prompts for these two objects and assign each of them a unique object id."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e22d896d-3cd5-4fa0-9230-f33e217035dc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompts = {}  # hold all the clicks we add for visualization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59d9ac57-b14a-4237-828d-927e422c518b",
+   "metadata": {},
+   "source": [
+    "Add the first object (the left child's shirt) with a **positive click** at (x, y) = (200, 300) on frame 0.\n",
+    "\n",
+    "We assign it to object id `2` (it can be arbitrary integers, and only needs to be unique for each object to track), which is passed to the `add_new_points_or_box` API to distinguish the object we are clicking upon."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d13432fc-f467-44d8-adfe-3e0c488046b7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ann_frame_idx = 0  # the frame index we interact with\n",
+    "ann_obj_id = 2  # give a unique id to each object we interact with (it can be any integers)\n",
+    "\n",
+    "# Let's add a positive click at (x, y) = (200, 300) to get started on the first object\n",
+    "points = np.array([[200, 300]], dtype=np.float32)\n",
+    "# for labels, `1` means positive click and `0` means negative click\n",
+    "labels = np.array([1], np.int32)\n",
+    "prompts[ann_obj_id] = points, labels\n",
+    "\n",
+    "rel_points = [[x / width, y / height] for x, y in points]\n",
+    "points_tensor = torch.tensor(rel_points, dtype=torch.float32)\n",
+    "points_labels_tensor = torch.tensor(labels, dtype=torch.int32)\n",
+    "\n",
+    "_, out_obj_ids, low_res_masks, video_res_masks = predictor.add_new_points_or_box(\n",
+    "    inference_state=inference_state,\n",
+    "    frame_idx=ann_frame_idx,\n",
+    "    obj_id=ann_obj_id,\n",
+    "    points=points_tensor,\n",
+    "    labels=points_labels_tensor,\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# show the results on the current (interacted) frame\n",
+    "plt.figure(figsize=(9, 6))\n",
+    "plt.title(f\"frame {ann_frame_idx}\")\n",
+    "plt.imshow(video_frames_for_vis[ann_frame_idx])\n",
+    "for i, out_obj_id in enumerate(out_obj_ids):\n",
+    "    show_points(points, labels, plt.gca())\n",
+    "    show_points(*prompts[out_obj_id], plt.gca())\n",
+    "    show_mask((video_res_masks[i][0] > 0.0).cpu().numpy(), plt.gca(), obj_id=out_obj_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1bbbd51b-e1e2-4c36-99ec-1d9a1b49b0cd",
+   "metadata": {},
+   "source": [
+    "Hmm, this time we just want to select the child's shirt, but the model predicts the mask for the entire child. Let's refine the prediction with a **negative click** at (x, y) = (275, 175)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "95ecf61d-662b-4f98-ae62-46557b219842",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# add the first object\n",
+    "ann_frame_idx = 0  # the frame index we interact with\n",
+    "ann_obj_id = 2  # give a unique id to each object we interact with (it can be any integers)\n",
+    "\n",
+    "# Let's add a 2nd negative click at (x, y) = (275, 175) to refine the first object\n",
+    "# sending all clicks (and their labels) to `add_new_points_or_box`\n",
+    "points = np.array([[200, 300], [275, 175]], dtype=np.float32)\n",
+    "# for labels, `1` means positive click and `0` means negative click\n",
+    "labels = np.array([1, 0], np.int32)\n",
+    "prompts[ann_obj_id] = points, labels\n",
+    "\n",
+    "rel_points = [[x / width, y / height] for x, y in points]\n",
+    "points_tensor = torch.tensor(rel_points, dtype=torch.float32)\n",
+    "points_labels_tensor = torch.tensor(labels, dtype=torch.int32)\n",
+    "\n",
+    "\n",
+    "_, out_obj_ids, low_res_masks, video_res_masks  = predictor.add_new_points_or_box(\n",
+    "    inference_state=inference_state,\n",
+    "    frame_idx=ann_frame_idx,\n",
+    "    obj_id=ann_obj_id,\n",
+    "    points=rel_points,\n",
+    "    labels=points_labels_tensor,\n",
+    ")\n",
+    "\n",
+    "# show the results on the current (interacted) frame\n",
+    "plt.figure(figsize=(9, 6))\n",
+    "plt.title(f\"frame {ann_frame_idx}\")\n",
+    "plt.imshow(video_frames_for_vis[ann_frame_idx])\n",
+    "for i, out_obj_id in enumerate(out_obj_ids):\n",
+    "    show_points(points, labels, plt.gca())\n",
+    "    show_points(*prompts[out_obj_id], plt.gca())\n",
+    "    show_mask((video_res_masks[i][0] > 0.0).cpu().numpy(), plt.gca(), obj_id=out_obj_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "194718c1-734d-446c-a3ef-361057de2f31",
+   "metadata": {},
+   "source": [
+    "After the 2nd negative click, now we get the left child's shirt as our first object.\n",
+    "\n",
+    "Let's move on to the second object (the right child's shirt) with a positive click at (x, y) = (400, 150) on frame 0. Here we assign object id `3` to this second object (it can be arbitrary integers, and only needs to be unique for each object to track).\n",
+    "\n",
+    "Note: when there are multiple objects, the `add_new_points_or_box` API will return a list of masks for each object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "86ca1bde-62a4-40e6-98e4-15606441e52f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ann_frame_idx = 0  # the frame index we interact with\n",
+    "ann_obj_id = 3  # give a unique id to each object we interact with (it can be any integers)\n",
+    "\n",
+    "# Let's now move on to the second object we want to track (giving it object id `3`)\n",
+    "# with a positive click at (x, y) = (400, 150)\n",
+    "points = np.array([[400, 150]], dtype=np.float32)\n",
+    "# for labels, `1` means positive click and `0` means negative click\n",
+    "labels = np.array([1], np.int32)\n",
+    "prompts[ann_obj_id] = points, labels\n",
+    "\n",
+    "rel_points = [[x / width, y / height] for x, y in points]\n",
+    "points_tensor = torch.tensor(rel_points, dtype=torch.float32)\n",
+    "points_labels_tensor = torch.tensor(labels, dtype=torch.int32)\n",
+    "\n",
+    "\n",
+    "# `add_new_points_or_box` returns masks for all objects added so far on this interacted frame\n",
+    "_, out_obj_ids, low_res_masks, video_res_masks = predictor.add_new_points_or_box(\n",
+    "    inference_state=inference_state,\n",
+    "    frame_idx=ann_frame_idx,\n",
+    "    obj_id=ann_obj_id,\n",
+    "    points=points_tensor,\n",
+    "    labels=points_labels_tensor,\n",
+    ")\n",
+    "\n",
+    "# show the results on the current (interacted) frame on all objects\n",
+    "plt.figure(figsize=(9, 6))\n",
+    "plt.title(f\"frame {ann_frame_idx}\")\n",
+    "plt.imshow(video_frames_for_vis[ann_frame_idx])\n",
+    "for i, out_obj_id in enumerate(out_obj_ids):\n",
+    "    show_points(points, labels, plt.gca())\n",
+    "    show_points(*prompts[out_obj_id], plt.gca())\n",
+    "    show_mask((video_res_masks[i][0] > 0.0).cpu().numpy(), plt.gca(), obj_id=out_obj_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a1f7add8-d577-4597-ae2f-654b8c7b05e0",
+   "metadata": {},
+   "source": [
+    "This time the model predicts the mask of the shirt we want to track in just one click. Nice!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "448733b8-ea8b-4078-995f-b676c3b558ba",
+   "metadata": {},
+   "source": [
+    "#### Step 2: Propagate the prompts to get masklets across the video"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "60bd73de-d669-41c8-b6ba-943883f0caa2",
+   "metadata": {},
+   "source": [
+    "Now, we propagate the prompts for both objects to get their masklets throughout the video.\n",
+    "\n",
+    "Note: when there are multiple objects, the `propagate_in_video` API will return a list of masks for each object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "17737191-d62b-4611-b2c6-6d0418a9ab74",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# run propagation throughout the video and collect the results in a dict\n",
+    "video_segments = {}  # video_segments contains the per-frame segmentation results\n",
+    "for frame_idx, obj_ids, low_res_masks, video_res_masks, obj_scores in predictor.propagate_in_video(inference_state, start_frame_idx=0, max_frame_num_to_track=300, reverse=False, propagate_preflight=True):\n",
+    "    video_segments[frame_idx] = {\n",
+    "        out_obj_id: (video_res_masks[i] > 0.0).cpu().numpy()\n",
+    "        for i, out_obj_id in enumerate(out_obj_ids)\n",
+    "    }\n",
+    "\n",
+    "# render the segmentation results every few frames\n",
+    "vis_frame_stride = 30\n",
+    "plt.close(\"all\")\n",
+    "for out_frame_idx in range(0, len(video_frames_for_vis), vis_frame_stride):\n",
+    "    plt.figure(figsize=(6, 4))\n",
+    "    plt.title(f\"frame {out_frame_idx}\")\n",
+    "    plt.imshow(video_frames_for_vis[out_frame_idx])\n",
+    "    for out_obj_id, out_mask in video_segments[out_frame_idx].items():\n",
+    "        show_mask(out_mask, plt.gca(), obj_id=out_obj_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "18a0b9d7-c78f-432b-afb0-11f2ea5b652a",
+   "metadata": {},
+   "source": [
+    "Looks like both children's shirts are well segmented in this video.\n",
+    "\n",
+    "Now you can try SAM 3 on your own videos and use cases! "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

third_party/GraspGen/sam3/examples/sam3_image_interactive.ipynb

@@ -0,0 +1,757 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5d0e0b69",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Copyright (c) Meta Platforms, Inc. and affiliates."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "11912666",
+   "metadata": {},
+   "source": [
+    "# <a target=\"_blank\" href=\"https://colab.research.google.com/github/facebookresearch/sam3/blob/main/notebooks/sam3_image_interactive.ipynb\">\n",
+    "#   <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
+    "# </a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8517f5f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "using_colab = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "2540e376",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if using_colab:\n",
+    "    import torch\n",
+    "    import torchvision\n",
+    "    print(\"PyTorch version:\", torch.__version__)\n",
+    "    print(\"Torchvision version:\", torchvision.__version__)\n",
+    "    print(\"CUDA is available:\", torch.cuda.is_available())\n",
+    "    import sys\n",
+    "    !{sys.executable} -m pip install opencv-python matplotlib scikit-learn\n",
+    "    !{sys.executable} -m pip install 'git+https://github.com/facebookresearch/sam3.git'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "90073483-58f6-404e-90ac-c22efcd76216",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib widget"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "13325376-658b-48d6-8528-2a006f223d44",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "# turn on tfloat32 for Ampere GPUs\n",
+    "# https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices\n",
+    "torch.backends.cuda.matmul.allow_tf32 = True\n",
+    "torch.backends.cudnn.allow_tf32 = True\n",
+    "\n",
+    "# use bfloat16 for the entire notebook. If your card doesn't support it, try float16 instead\n",
+    "torch.autocast(\"cuda\", dtype=torch.bfloat16).__enter__()\n",
+    "\n",
+    "# inference mode for the whole notebook. Disable if you need gradients\n",
+    "torch.inference_mode().__enter__()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fb863772-56a9-4ee2-be52-5d8933066519",
+   "metadata": {},
+   "source": [
+    "# Load the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f84b4ccc-9db2-4d88-ac8f-4c272694d25a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sam3\n",
+    "from sam3 import build_sam3_image_model\n",
+    "import os\n",
+    "sam3_root = os.path.join(os.path.dirname(sam3.__file__), \"..\")\n",
+    "bpe_path = f\"{sam3_root}/assets/bpe_simple_vocab_16e6.txt.gz\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "de01a36e-1221-4497-a5ab-e6c796689480",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = build_sam3_image_model(bpe_path=bpe_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b01ec8a9-d9f6-4baf-96ac-1e5d21fd90b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sam3.model.sam3_image_processor import Sam3Processor\n",
+    "processor = Sam3Processor(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e6172a69-35ca-487c-bd67-6f1f1ecb20d5",
+   "metadata": {},
+   "source": [
+    "# Jupyter widget"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "2a4ac22f-5d5c-4272-a5a1-dfe0c04253a7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import io\n",
+    "\n",
+    "import ipywidgets as widgets\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import PIL.Image\n",
+    "import requests\n",
+    "from IPython.display import clear_output, display, HTML\n",
+    "from matplotlib.patches import Rectangle\n",
+    "\n",
+    "\n",
+    "class Sam3SegmentationWidget:\n",
+    "    \"\"\"Interactive Jupyter widget for SAM3 segmentation with text and box prompts.\"\"\"\n",
+    "\n",
+    "    def __init__(self, processor):\n",
+    "        \"\"\"\n",
+    "        Initialize the segmentation widget.\n",
+    "\n",
+    "        Args:\n",
+    "            processor: Sam3Processor instance\n",
+    "        \"\"\"\n",
+    "        self.processor = processor\n",
+    "        self.state = None\n",
+    "        self.current_image = None\n",
+    "        self.current_image_array = None\n",
+    "        self.box_mode = \"positive\"\n",
+    "        self.drawing_box = False\n",
+    "        self.box_start = None\n",
+    "        self.current_rect = None\n",
+    "\n",
+    "        self._setup_ui()\n",
+    "        self._setup_plot()\n",
+    "\n",
+    "    def _setup_ui(self):\n",
+    "        \"\"\"Set up the UI components.\"\"\"\n",
+    "        self.upload_widget = widgets.FileUpload(\n",
+    "            accept=\"image/*\", multiple=False, description=\"Upload Image\"\n",
+    "        )\n",
+    "        self.upload_widget.observe(self._on_image_upload, names=\"value\")\n",
+    "\n",
+    "        self.url_input = widgets.Text(\n",
+    "            placeholder=\"Or enter image URL\",\n",
+    "        )\n",
+    "        self.url_button = widgets.Button(description=\"Load URL\", button_style=\"info\")\n",
+    "        self.url_button.on_click(self._on_load_url)\n",
+    "        url_box = widgets.HBox(\n",
+    "            [self.url_input, self.url_button],\n",
+    "            layout=widgets.Layout(width=\"100%\", justify_content=\"space-between\"),\n",
+    "        )\n",
+    "\n",
+    "        self.text_input = widgets.Text(\n",
+    "            placeholder='Enter segmentation prompt (e.g., \"person\", \"dog\")',\n",
+    "            continuous_update=False,\n",
+    "        )\n",
+    "        self.text_input.observe(self._on_text_submit, names=\"value\")\n",
+    "        self.text_button = widgets.Button(description=\"Segment\", button_style=\"success\")\n",
+    "        self.text_button.on_click(self._on_text_prompt)\n",
+    "        text_box = widgets.HBox(\n",
+    "            [self.text_input, self.text_button],\n",
+    "            layout=widgets.Layout(width=\"100%\", justify_content=\"space-between\"),\n",
+    "        )\n",
+    "\n",
+    "        self.box_mode_buttons = widgets.ToggleButtons(\n",
+    "            options=[\"Positive Boxes\", \"Negative Boxes\"],\n",
+    "            description=\"Box Mode:\",\n",
+    "            button_style=\"\",\n",
+    "            tooltips=[\n",
+    "                \"Draw boxes around objects to include\",\n",
+    "                \"Draw boxes around objects to exclude\",\n",
+    "            ],\n",
+    "        )\n",
+    "        self.box_mode_buttons.observe(self._on_box_mode_change, names=\"value\")\n",
+    "\n",
+    "        self.clear_button = widgets.Button(\n",
+    "            description=\"Clear All Prompts\", button_style=\"warning\"\n",
+    "        )\n",
+    "        self.clear_button.on_click(self._on_clear_prompts)\n",
+    "\n",
+    "        self.confidence_slider = widgets.FloatSlider(\n",
+    "            value=0.5,\n",
+    "            min=0.0,\n",
+    "            max=1.0,\n",
+    "            step=0.01,\n",
+    "            description=\"Confidence:\",\n",
+    "            continuous_update=False,\n",
+    "            style={\"description_width\": \"initial\"},\n",
+    "        )\n",
+    "        self.confidence_slider.observe(self._on_confidence_change, names=\"value\")\n",
+    "\n",
+    "        self.size_slider = widgets.IntSlider(\n",
+    "            value=960,\n",
+    "            min=300,\n",
+    "            max=2000,\n",
+    "            step=10,\n",
+    "            description=\"Image Size:\",\n",
+    "            continuous_update=False,\n",
+    "            style={\"description_width\": \"initial\"},\n",
+    "        )\n",
+    "        self.size_slider.observe(self._on_size_change, names=\"value\")\n",
+    "\n",
+    "        slider_box = widgets.HBox(\n",
+    "            [self.confidence_slider, self.size_slider],\n",
+    "            layout=widgets.Layout(justify_content=\"space-between\"),\n",
+    "        )\n",
+    "\n",
+    "        self.output = widgets.Output()\n",
+    "        self.status_label = widgets.Label(value=\"Upload an image to begin\")\n",
+    "\n",
+    "        # This box will hold our matplotlib output and we can target it with CSS.\n",
+    "        self.plot_container = widgets.Box([self.output])\n",
+    "        self.plot_container.add_class(\"no-drag\")\n",
+    "\n",
+    "        # CSS to make the cursor a crosshair over the matplotlib canvas\n",
+    "        css_style = widgets.HTML(\n",
+    "            \"\"\"\n",
+    "        <style>\n",
+    "            .jupyter-matplotlib-canvas, canvas {\n",
+    "                cursor: crosshair !important;\n",
+    "            }\n",
+    "        </style>\n",
+    "        \"\"\"\n",
+    "        )\n",
+    "        # Create VBoxes for each accordion pane\n",
+    "        source_pane = widgets.VBox([self.upload_widget, url_box])\n",
+    "        prompt_pane = widgets.VBox(\n",
+    "            [\n",
+    "                widgets.Label(\"Text Prompt:\"),\n",
+    "                text_box,\n",
+    "                self.box_mode_buttons,\n",
+    "                self.confidence_slider,\n",
+    "                self.clear_button,\n",
+    "            ]\n",
+    "        )\n",
+    "        display_pane = widgets.VBox([self.size_slider])\n",
+    "\n",
+    "        # Create the Accordion to hold the control panes\n",
+    "        self.accordion = widgets.Accordion(\n",
+    "            children=[source_pane, prompt_pane, display_pane]\n",
+    "        )\n",
+    "        self.accordion.set_title(0, \"Image Source\")\n",
+    "        self.accordion.set_title(1, \"Segmentation Prompts\")\n",
+    "        self.accordion.set_title(2, \"Display Settings\")\n",
+    "        self.accordion.selected_index = 0  # Start with the first pane open\n",
+    "\n",
+    "        # Create the left sidebar for controls\n",
+    "        sidebar = widgets.VBox(\n",
+    "            [self.status_label, widgets.HTML(\"<h4>Controls</h4>\"), self.accordion]\n",
+    "        )\n",
+    "        sidebar.layout = widgets.Layout(\n",
+    "            width=\"380px\",\n",
+    "            min_width=\"380px\",\n",
+    "            max_width=\"380px\",\n",
+    "            border=\"1px solid #e0e0e0\",\n",
+    "            padding=\"10px\",\n",
+    "            margin=\"0 15px 0 0\",\n",
+    "            flex=\"0 0 auto\",\n",
+    "        )\n",
+    "\n",
+    "        # Create the main area for the image display\n",
+    "        main_area = widgets.VBox([self.plot_container])\n",
+    "        main_area.layout = widgets.Layout(flex=\"1\", min_width=\"500px\", overflow=\"auto\")\n",
+    "\n",
+    "        # Combine sidebar and main area into the final app layout\n",
+    "        app_layout = widgets.HBox([sidebar, main_area])\n",
+    "        app_layout.layout = widgets.Layout(\n",
+    "            width=\"100%\",\n",
+    "            display=\"flex\",\n",
+    "            flex_flow=\"row\",\n",
+    "            align_items=\"stretch\",\n",
+    "        )\n",
+    "\n",
+    "        # Set the main container\n",
+    "        self.container = widgets.VBox(\n",
+    "            [\n",
+    "                css_style,\n",
+    "                widgets.HTML(\"<h3>🖼️ SAM3 Interactive Segmentation</h3>\"),\n",
+    "                app_layout,\n",
+    "            ]\n",
+    "        )\n",
+    "\n",
+    "    def _setup_plot(self):\n",
+    "        \"\"\"Set up the matplotlib figure.\"\"\"\n",
+    "        # plt.ioff()\n",
+    "        self.fig, self.ax = plt.subplots(figsize=(12, 8))\n",
+    "        # plt.ion()\n",
+    "        self.ax.axis(\"off\")\n",
+    "        self.fig.subplots_adjust(left=0, right=1, top=1, bottom=0)\n",
+    "        self.fig.canvas.toolbar_visible = False\n",
+    "        self.fig.canvas.header_visible = False\n",
+    "        self.fig.canvas.footer_visible = False\n",
+    "        self.fig.canvas.resizable = False\n",
+    "\n",
+    "        # plt.close(self.fig)\n",
+    "\n",
+    "    def _set_loading(self, is_loading, message=\"Processing...\"):\n",
+    "        \"\"\"Show/hide loading state and disable/enable controls.\"\"\"\n",
+    "        if is_loading:\n",
+    "            self.status_label.value = f\"⏳ {message}\"\n",
+    "            self.upload_widget.disabled = True\n",
+    "            self.url_button.disabled = True\n",
+    "            self.text_button.disabled = True\n",
+    "            self.clear_button.disabled = True\n",
+    "            self.box_mode_buttons.disabled = True\n",
+    "            self.confidence_slider.disabled = True\n",
+    "        else:\n",
+    "            self.upload_widget.disabled = False\n",
+    "            self.url_button.disabled = False\n",
+    "            self.text_button.disabled = False\n",
+    "            self.clear_button.disabled = False\n",
+    "            self.box_mode_buttons.disabled = False\n",
+    "            self.confidence_slider.disabled = False\n",
+    "\n",
+    "    def _on_image_upload(self, change):\n",
+    "        \"\"\"Handle image upload.\"\"\"\n",
+    "        if change[\"new\"]:\n",
+    "            uploaded_file = change[\"new\"][0]\n",
+    "            image = PIL.Image.open(io.BytesIO(uploaded_file[\"content\"])).convert(\"RGB\")\n",
+    "            self._set_image(image)\n",
+    "\n",
+    "    def _on_load_url(self, button):\n",
+    "        \"\"\"Handle loading image from URL.\"\"\"\n",
+    "        url = self.url_input.value.strip()\n",
+    "        if not url:\n",
+    "            self.status_label.value = \"Please enter a URL\"\n",
+    "            return\n",
+    "\n",
+    "        self._set_loading(True, \"Downloading image from URL...\")\n",
+    "\n",
+    "        try:\n",
+    "            response = requests.get(url, timeout=10)\n",
+    "            response.raise_for_status()\n",
+    "            image = PIL.Image.open(io.BytesIO(response.content)).convert(\"RGB\")\n",
+    "            self._set_image(image)\n",
+    "        except Exception as e:\n",
+    "            self._set_loading(False)\n",
+    "            self.status_label.value = f\"Error loading image: {str(e)}\"\n",
+    "\n",
+    "    def _set_image(self, image):\n",
+    "        \"\"\"Set the current image, adjust figure size, and initialize state.\"\"\"\n",
+    "        self._set_loading(True, \"Processing image through model...\")\n",
+    "\n",
+    "        try:\n",
+    "\n",
+    "            self.current_image = image\n",
+    "            self.current_image_array = np.array(image)\n",
+    "            self.state = self.processor.set_image(image)\n",
+    "            self._set_loading(False)\n",
+    "            self.status_label.value = (\n",
+    "                f\"Image loaded: {image.size[0]}x{image.size[1]} pixels\"\n",
+    "            )\n",
+    "            self._resize_figure()\n",
+    "            self._update_display()\n",
+    "            self._connect_plot_events()\n",
+    "            self.accordion.selected_index = 1\n",
+    "        except Exception as e:\n",
+    "            self._set_loading(False)\n",
+    "            self.status_label.value = f\"Error processing image: {str(e)}\"\n",
+    "\n",
+    "    def _on_text_submit(self, change):\n",
+    "        \"\"\"Handle text prompt submission via Enter key.\"\"\"\n",
+    "        # Call the same handler as the button click\n",
+    "        self._on_text_prompt(None)\n",
+    "\n",
+    "    def _on_text_prompt(self, button):\n",
+    "        \"\"\"Handle text prompt submission.\"\"\"\n",
+    "        if self.state is None:\n",
+    "            self.status_label.value = \"Please load an image first\"\n",
+    "            return\n",
+    "\n",
+    "        prompt = self.text_input.value.strip()\n",
+    "        if not prompt:\n",
+    "            self.status_label.value = \"Please enter a prompt\"\n",
+    "            return\n",
+    "\n",
+    "        self._set_loading(True, f'Segmenting with prompt: \"{prompt}\"...')\n",
+    "\n",
+    "        try:\n",
+    "            self.state = self.processor.set_text_prompt(prompt, self.state)\n",
+    "            self._set_loading(False)\n",
+    "            self.status_label.value = f'Segmented with prompt: \"{prompt}\"'\n",
+    "            self._update_display()\n",
+    "        except Exception as e:\n",
+    "            self._set_loading(False)\n",
+    "            self.status_label.value = f\"Error: {str(e)}\"\n",
+    "\n",
+    "    def _on_box_mode_change(self, change):\n",
+    "        \"\"\"Handle box mode toggle.\"\"\"\n",
+    "        self.box_mode = \"positive\" if change[\"new\"] == \"Positive Boxes\" else \"negative\"\n",
+    "\n",
+    "    def _on_clear_prompts(self, button):\n",
+    "        \"\"\"Clear all prompts and reset to image only.\"\"\"\n",
+    "        if self.current_image is not None:\n",
+    "            try:\n",
+    "                self._set_loading(True, \"Clearing prompts and resetting...\")\n",
+    "                self.state = self.processor.reset_all_prompts(self.state)\n",
+    "                if \"prompted_boxes\" in self.state:\n",
+    "                    del self.state[\"prompted_boxes\"]\n",
+    "                self.text_input.value = \"\"\n",
+    "                self._set_loading(False)\n",
+    "                self.status_label.value = \"Cleared all prompts\"\n",
+    "                self._update_display()\n",
+    "            except Exception as e:\n",
+    "                self._set_loading(False)\n",
+    "                import traceback\n",
+    "\n",
+    "                self.status_label.value = f\"Error: {str(e)} {traceback.format_exc()}\"\n",
+    "\n",
+    "    def _on_confidence_change(self, change):\n",
+    "        \"\"\"Handle confidence threshold change.\"\"\"\n",
+    "        if self.state is not None:\n",
+    "            self.state = self.processor.set_confidence_threshold(\n",
+    "                change[\"new\"], self.state\n",
+    "            )\n",
+    "            self._update_display()\n",
+    "\n",
+    "    def _connect_plot_events(self):\n",
+    "        \"\"\"Connect matplotlib event handlers for box drawing.\"\"\"\n",
+    "        # Disable matplotlib's toolbar navigation to allow custom box drawing\n",
+    "        if hasattr(self.fig.canvas, \"toolbar\") and self.fig.canvas.toolbar is not None:\n",
+    "            self.fig.canvas.toolbar.pan()\n",
+    "            self.fig.canvas.toolbar.pan()\n",
+    "\n",
+    "        self.fig.canvas.mpl_connect(\"button_press_event\", self._on_press)\n",
+    "        self.fig.canvas.mpl_connect(\"button_release_event\", self._on_release)\n",
+    "        self.fig.canvas.mpl_connect(\"motion_notify_event\", self._on_motion)\n",
+    "\n",
+    "    def _on_press(self, event):\n",
+    "        \"\"\"Handle mouse press for box drawing.\"\"\"\n",
+    "        if event.inaxes != self.ax:\n",
+    "            return\n",
+    "        self.drawing_box = True\n",
+    "        self.box_start = (event.xdata, event.ydata)\n",
+    "\n",
+    "    def _on_motion(self, event):\n",
+    "        \"\"\"Handle mouse motion for box preview.\"\"\"\n",
+    "        if not self.drawing_box or event.inaxes != self.ax or self.box_start is None:\n",
+    "            return\n",
+    "\n",
+    "        if self.current_rect is not None:\n",
+    "            self.current_rect.remove()\n",
+    "\n",
+    "        x0, y0 = self.box_start\n",
+    "        x1, y1 = event.xdata, event.ydata\n",
+    "        width = x1 - x0\n",
+    "        height = y1 - y0\n",
+    "\n",
+    "        color = \"green\" if self.box_mode == \"positive\" else \"red\"\n",
+    "        self.current_rect = Rectangle(\n",
+    "            (x0, y0),\n",
+    "            width,\n",
+    "            height,\n",
+    "            fill=False,\n",
+    "            edgecolor=color,\n",
+    "            linewidth=2,\n",
+    "            linestyle=\"--\",\n",
+    "        )\n",
+    "        self.ax.add_patch(self.current_rect)\n",
+    "        self.fig.canvas.draw_idle()\n",
+    "\n",
+    "    def _on_release(self, event):\n",
+    "        \"\"\"Handle mouse release to finalize box.\"\"\"\n",
+    "        if not self.drawing_box or event.inaxes != self.ax or self.box_start is None:\n",
+    "            self.drawing_box = False\n",
+    "            return\n",
+    "\n",
+    "        self.drawing_box = False\n",
+    "\n",
+    "        if self.current_rect is not None:\n",
+    "            self.current_rect.remove()\n",
+    "            self.current_rect = None\n",
+    "\n",
+    "        if self.state is None:\n",
+    "            return\n",
+    "\n",
+    "        x0, y0 = self.box_start\n",
+    "        x1, y1 = event.xdata, event.ydata\n",
+    "\n",
+    "        x_min = min(x0, x1)\n",
+    "        x_max = max(x0, x1)\n",
+    "        y_min = min(y0, y1)\n",
+    "        y_max = max(y0, y1)\n",
+    "\n",
+    "        if abs(x_max - x_min) < 5 or abs(y_max - y_min) < 5:\n",
+    "            return\n",
+    "\n",
+    "        # Get image dimensions\n",
+    "        img_h = self.state[\"original_height\"]\n",
+    "        img_w = self.state[\"original_width\"]\n",
+    "\n",
+    "        # Convert from xyxy pixel coordinates to cxcywh normalized format\n",
+    "        center_x = (x_min + x_max) / 2.0 / img_w\n",
+    "        center_y = (y_min + y_max) / 2.0 / img_h\n",
+    "        width = (x_max - x_min) / img_w\n",
+    "        height = (y_max - y_min) / img_h\n",
+    "\n",
+    "        box = [center_x, center_y, width, height]\n",
+    "        label = self.box_mode == \"positive\"\n",
+    "        mode_str = \"positive\" if label else \"negative\"\n",
+    "\n",
+    "        # Store the prompted box in pixel coordinates for display\n",
+    "        if \"prompted_boxes\" not in self.state:\n",
+    "            self.state[\"prompted_boxes\"] = []\n",
+    "        self.state[\"prompted_boxes\"].append(\n",
+    "            {\"box\": [x_min, y_min, x_max, y_max], \"label\": label}\n",
+    "        )\n",
+    "\n",
+    "        self._set_loading(True, f\"Adding {mode_str} box and re-segmenting...\")\n",
+    "\n",
+    "        try:\n",
+    "            self.state = self.processor.add_geometric_prompt(box, label, self.state)\n",
+    "            self._set_loading(False)\n",
+    "            self.status_label.value = f\"Added {mode_str} box\"\n",
+    "            self._update_display()\n",
+    "        except Exception as e:\n",
+    "            self._set_loading(False)\n",
+    "            self.status_label.value = f\"Error adding box: {str(e)}\"\n",
+    "\n",
+    "    def _resize_figure(self):\n",
+    "        \"\"\"Calculate and apply new figure size based on image and slider value.\"\"\"\n",
+    "        if self.current_image is None:\n",
+    "            return\n",
+    "\n",
+    "        # 1. Get original image dimensions\n",
+    "        img_w, img_h = self.current_image.size\n",
+    "\n",
+    "        # 2. The slider's value is now the direct target width for the display\n",
+    "        display_w = float(self.size_slider.value)\n",
+    "\n",
+    "        # 3. Calculate the corresponding height to maintain the original aspect ratio\n",
+    "        aspect_ratio = img_h / img_w\n",
+    "        display_h = int(display_w * aspect_ratio)\n",
+    "\n",
+    "        # 4. Convert pixel dimensions to inches for Matplotlib and apply\n",
+    "        dpi = self.fig.dpi\n",
+    "        new_figsize = (display_w / dpi, display_h / dpi)\n",
+    "        self.fig.set_size_inches(new_figsize, forward=True)\n",
+    "\n",
+    "    def _on_size_change(self, change):\n",
+    "        \"\"\"Handle a change from the image size slider.\"\"\"\n",
+    "        if self.current_image is not None:\n",
+    "            self._resize_figure()\n",
+    "            # After resizing the canvas, we must redraw the content\n",
+    "            self._update_display()\n",
+    "\n",
+    "    def _update_display(self):\n",
+    "        \"\"\"Update the display with current results.\"\"\"\n",
+    "        if self.current_image_array is None:\n",
+    "            return\n",
+    "\n",
+    "        with self.output:\n",
+    "            clear_output(wait=True)\n",
+    "\n",
+    "            self.ax.clear()\n",
+    "            self.ax.axis(\"off\")\n",
+    "            self.ax.imshow(self.current_image_array)\n",
+    "\n",
+    "            if self.state is not None and \"masks\" in self.state:\n",
+    "                masks = self.state.get(\"masks\", [])\n",
+    "                boxes = self.state.get(\"boxes\", [])\n",
+    "                scores = self.state.get(\"scores\", [])\n",
+    "\n",
+    "                if len(masks) > 0:\n",
+    "                    mask_overlay = np.zeros((*self.current_image_array.shape[:2], 4))\n",
+    "\n",
+    "                    for i, (mask, box, score) in enumerate(zip(masks, boxes, scores)):\n",
+    "                        mask_np = mask[0].cpu().numpy()\n",
+    "\n",
+    "                        color = plt.cm.tab10(i % 10)[:3]\n",
+    "                        mask_overlay[mask_np > 0.5] = (*color, 0.5)\n",
+    "\n",
+    "                        x0, y0, x1, y1 = box.cpu().numpy()\n",
+    "                        rect = Rectangle(\n",
+    "                            (x0, y0),\n",
+    "                            x1 - x0,\n",
+    "                            y1 - y0,\n",
+    "                            fill=False,\n",
+    "                            edgecolor=color,\n",
+    "                            linewidth=2,\n",
+    "                        )\n",
+    "                        self.ax.add_patch(rect)\n",
+    "\n",
+    "                        self.ax.text(\n",
+    "                            x0,\n",
+    "                            y0 - 5,\n",
+    "                            f\"{score:.2f}\",\n",
+    "                            color=\"white\",\n",
+    "                            fontsize=10,\n",
+    "                            bbox=dict(\n",
+    "                                facecolor=color, alpha=0.7, edgecolor=\"none\", pad=2\n",
+    "                            ),\n",
+    "                        )\n",
+    "\n",
+    "                    self.ax.imshow(mask_overlay)\n",
+    "                    self.status_label.value = f\"Found {len(masks)} object(s)\"\n",
+    "                else:\n",
+    "                    self.status_label.value = (\n",
+    "                        \"No objects found above confidence threshold\"\n",
+    "                    )\n",
+    "\n",
+    "            # Display prompted boxes with dashed lines\n",
+    "            if self.state is not None and \"prompted_boxes\" in self.state:\n",
+    "                for prompted_box in self.state[\"prompted_boxes\"]:\n",
+    "                    box_coords = prompted_box[\"box\"]\n",
+    "                    is_positive = prompted_box[\"label\"]\n",
+    "\n",
+    "                    x0, y0, x1, y1 = box_coords\n",
+    "                    color = \"green\" if is_positive else \"red\"\n",
+    "\n",
+    "                    rect = Rectangle(\n",
+    "                        (x0, y0),\n",
+    "                        x1 - x0,\n",
+    "                        y1 - y0,\n",
+    "                        fill=False,\n",
+    "                        edgecolor=color,\n",
+    "                        linewidth=2,\n",
+    "                        linestyle=\"--\",\n",
+    "                    )\n",
+    "                    self.ax.add_patch(rect)\n",
+    "\n",
+    "            # display(self.fig.canvas)\n",
+    "\n",
+    "    def display(self):\n",
+    "        display(self.container)\n",
+    "\n",
+    "    # Add this for more convenient display in notebooks\n",
+    "    def _ipython_display_(self):\n",
+    "        self.display()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b9bda74-b455-4957-9767-2a46a041b50f",
+   "metadata": {},
+   "source": [
+    "# Run!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "ebfb9b85-2318-4328-bb0e-e93e4a57fefe",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ea0e04a1bfd7486b93baae650d87e0b2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HTML(value='\\n        <style>\\n            .jupyter-matplotlib-canvas, canvas {\\n              …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bbdcb3374c29461bb379d4bf9c319a49",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=1200.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(footer_visible=False, header_visible=False, resizable=False, toolbar=Toolbar(toolitems=[('Home', 'Reset…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "widget = Sam3SegmentationWidget(processor)\n",
+    "widget.display()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "50a14560-573a-4784-9f55-689fda9147be",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

third_party/GraspGen/sam3/examples/sam3_video_predictor_example.ipynb

@@ -0,0 +1,1603 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "License Information",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1762496606600,
+        "executionStopTime": 1762496607864,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "bentoCellName": {
+            "name": "Copyright Notice",
+            "origin": "ai"
+          },
+          "collapsed": false,
+          "customInput": null,
+          "customOutput": null,
+          "executionStartTime": 1761950741027,
+          "executionStopTime": 1761950741468,
+          "isCommentPanelOpen": false,
+          "language": "python",
+          "originalKey": "49a54601-c2fe-47f2-a436-9a1f91503520",
+          "outputsInitialized": true,
+          "requestMsgId": "da31cd52-f746-4a69-bfae-b2037e84d00c",
+          "serverExecutionDuration": 2.3454379988834,
+          "showInput": true
+        },
+        "originalKey": "913d6f63-449f-4836-ae81-7d55a42ccf8c",
+        "output": {
+          "id": 863592039347424,
+          "loadingStatus": "loaded"
+        },
+        "outputsInitialized": false,
+        "requestMsgId": "913d6f63-449f-4836-ae81-7d55a42ccf8c",
+        "serverExecutionDuration": 2.4641010004416
+      },
+      "outputs": [],
+      "source": [
+        "# Copyright (c) Meta Platforms, Inc. and affiliates."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "attachments": [],
+        "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
+        "language": "markdown",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "customInput": null,
+          "isCommentPanelOpen": false,
+          "language": "markdown",
+          "originalKey": "50280cd0-12eb-4f23-a78d-c37f5bda1fe6",
+          "outputsInitialized": false,
+          "showInput": false
+        },
+        "originalKey": "9e88cae8-b006-498d-9a02-c1c369a95f57",
+        "outputsInitialized": false,
+        "showInput": true
+      },
+      "source": [
+        "## Video segmentation and tracking with SAM 3\n",
+        "\n",
+        "This notebook demonstrates how to use SAM 3 for interactive video segmentation and dense tracking. It covers the following capabilities:\n",
+        "\n",
+        "- **Text prompts**: Using natural language descriptions to segment objects (e.g., \"person\", \"shoe\")\n",
+        "- **Point prompts**: Adding positive/negative clicks to segment and refine objects\n",
+        "\n",
+        "We use the terms _segment_ or _mask_ to refer to the model prediction for an object on a single frame, and _masklet_ to refer to the spatio-temporal masks across the entire video. "
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# <a target=\"_blank\" href=\"https://colab.research.google.com/github/facebookresearch/sam3/blob/main/notebooks/sam3_video_predictor_example.ipynb\">\n",
+        "#   <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
+        "# </a>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "using_colab = False"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "if using_colab:\n",
+        "    import torch\n",
+        "    import torchvision\n",
+        "    print(\"PyTorch version:\", torch.__version__)\n",
+        "    print(\"Torchvision version:\", torchvision.__version__)\n",
+        "    print(\"CUDA is available:\", torch.cuda.is_available())\n",
+        "    import sys\n",
+        "    !{sys.executable} -m pip install opencv-python matplotlib scikit-learn\n",
+        "    !{sys.executable} -m pip install 'git+https://github.com/facebookresearch/sam3.git'"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Display GPU Status",
+          "origin": "ai"
+        },
+        "customOutput": null,
+        "executionStartTime": 1762496607874,
+        "executionStopTime": 1762496609713,
+        "isCommentPanelOpen": false,
+        "language": "python",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "bentoCellName": {
+            "name": "Check GPU Status",
+            "origin": "ai"
+          },
+          "collapsed": false,
+          "customInput": null,
+          "customOutput": null,
+          "executionStartTime": 1761950741471,
+          "executionStopTime": 1761950742878,
+          "isCommentPanelOpen": false,
+          "language": "python",
+          "originalKey": "c3f5a31b-c8df-45db-ae6d-0d219ee60382",
+          "outputsInitialized": true,
+          "requestMsgId": "cea571e0-345b-461d-b2ee-8f95e0ea4b4e",
+          "serverExecutionDuration": 1091.9901590096,
+          "showInput": true
+        },
+        "originalKey": "fb0eb6a0-acd2-4c80-bacd-bafd09669e7e",
+        "output": {
+          "id": "794918370206651",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "fb0eb6a0-acd2-4c80-bacd-bafd09669e7e",
+        "serverExecutionDuration": 1123.5525669999
+      },
+      "outputs": [],
+      "source": [
+        "!nvidia-smi"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "attachments": [],
+        "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
+        "language": "markdown",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "collapsed": false,
+          "customInput": null,
+          "executionStartTime": 1761927188199,
+          "executionStopTime": 1761927188659,
+          "isCommentPanelOpen": false,
+          "language": "markdown",
+          "originalKey": "8304fc58-e145-4f5f-8bdc-a6d2dfba8a04",
+          "outputsInitialized": false,
+          "requestMsgId": "8304fc58-e145-4f5f-8bdc-a6d2dfba8a04",
+          "serverExecutionDuration": 3.739742009202,
+          "showInput": false
+        },
+        "originalKey": "6702b9f4-54e9-46be-aca8-82ad9f96e9cc",
+        "outputsInitialized": false,
+        "showInput": false
+      },
+      "source": [
+        "## Set-up\n",
+        "\n",
+        "In this example, we allow running inference either on a single GPU or multiple GPUs."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Configure GPU Usage",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1762496609726,
+        "executionStopTime": 1762496617098,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "bentoCellName": {
+            "name": "Import iopath library",
+            "origin": "ai"
+          },
+          "collapsed": false,
+          "customOutput": null,
+          "executionStartTime": 1761950742885,
+          "executionStopTime": 1761950745386,
+          "isCommentPanelOpen": false,
+          "language": "python",
+          "originalKey": "5faf15c7-5bbb-4b86-a9a8-70abbc76cba2",
+          "outputsInitialized": true,
+          "requestMsgId": "e63f2826-d537-4849-82ac-fe7280cc9de0",
+          "serverExecutionDuration": 2117.1291570063
+        },
+        "originalKey": "5d0ad6b6-0225-4371-9455-e6291e92604c",
+        "output": {
+          "id": "1459804151757142",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "5d0ad6b6-0225-4371-9455-e6291e92604c",
+        "serverExecutionDuration": 6628.1851309996
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import sam3\n",
+        "import torch\n",
+        "\n",
+        "sam3_root = os.path.join(os.path.dirname(sam3.__file__), \"..\")\n",
+        "\n",
+        "# use all available GPUs on the machine\n",
+        "gpus_to_use = range(torch.cuda.device_count())\n",
+        "# # use only a single GPU\n",
+        "# gpus_to_use = [torch.cuda.current_device()]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Initialize Video Predictor",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1762496617103,
+        "executionStopTime": 1762496677439,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "bentoCellName": {
+            "name": "Import Video Predictor",
+            "origin": "ai"
+          },
+          "collapsed": false,
+          "customInput": null,
+          "customOutput": null,
+          "executionStartTime": 1761950750102,
+          "executionStopTime": 1761950806603,
+          "isCommentPanelOpen": false,
+          "language": "python",
+          "originalKey": "01683eda-e85f-4af6-9d91-86b3f1822170",
+          "outputsInitialized": true,
+          "requestMsgId": "822fb211-d78e-4d1c-92fa-848e0e755100",
+          "serverExecutionDuration": 55998.664824001,
+          "showInput": true
+        },
+        "originalKey": "aea5a4b9-de9f-46ed-9fd1-20928ab60d2e",
+        "output": {
+          "id": "1581259049706846",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "aea5a4b9-de9f-46ed-9fd1-20928ab60d2e",
+        "serverExecutionDuration": 59514.871851999
+      },
+      "outputs": [],
+      "source": [
+        "from sam3.model_builder import build_sam3_video_predictor\n",
+        "\n",
+        "predictor = build_sam3_video_predictor(gpus_to_use=gpus_to_use)"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "collapsed": false,
+        "customInput": null,
+        "executionStartTime": 1762140878760,
+        "executionStopTime": 1762140879318,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "markdown",
+        "originalKey": "2cb37dda-a58c-46ae-85ff-118bb3ff4c02",
+        "outputsInitialized": false,
+        "requestMsgId": "2cb37dda-a58c-46ae-85ff-118bb3ff4c02",
+        "serverExecutionDuration": 3.7622059462592,
+        "showInput": false
+      },
+      "source": [
+        "#### Inference and visualization utils"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Set Up Video Processing",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1762496677450,
+        "executionStopTime": 1762496679879,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "originalKey": "10d98ae4-dd65-4824-8469-960a9801ec72",
+        "output": {
+          "id": "1183417547004803",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "10d98ae4-dd65-4824-8469-960a9801ec72",
+        "serverExecutionDuration": 1535.9860829994,
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "import glob\n",
+        "import os\n",
+        "\n",
+        "import cv2\n",
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "from sam3.visualization_utils import (\n",
+        "    load_frame,\n",
+        "    prepare_masks_for_visualization,\n",
+        "    visualize_formatted_frame_output,\n",
+        ")\n",
+        "\n",
+        "# font size for axes titles\n",
+        "plt.rcParams[\"axes.titlesize\"] = 12\n",
+        "plt.rcParams[\"figure.titlesize\"] = 12\n",
+        "\n",
+        "\n",
+        "def propagate_in_video(predictor, session_id):\n",
+        "    # we will just propagate from frame 0 to the end of the video\n",
+        "    outputs_per_frame = {}\n",
+        "    for response in predictor.handle_stream_request(\n",
+        "        request=dict(\n",
+        "            type=\"propagate_in_video\",\n",
+        "            session_id=session_id,\n",
+        "        )\n",
+        "    ):\n",
+        "        outputs_per_frame[response[\"frame_index\"]] = response[\"outputs\"]\n",
+        "\n",
+        "    return outputs_per_frame\n",
+        "\n",
+        "\n",
+        "def abs_to_rel_coords(coords, IMG_WIDTH, IMG_HEIGHT, coord_type=\"point\"):\n",
+        "    \"\"\"Convert absolute coordinates to relative coordinates (0-1 range)\n",
+        "\n",
+        "    Args:\n",
+        "        coords: List of coordinates\n",
+        "        coord_type: 'point' for [x, y] or 'box' for [x, y, w, h]\n",
+        "    \"\"\"\n",
+        "    if coord_type == \"point\":\n",
+        "        return [[x / IMG_WIDTH, y / IMG_HEIGHT] for x, y in coords]\n",
+        "    elif coord_type == \"box\":\n",
+        "        return [\n",
+        "            [x / IMG_WIDTH, y / IMG_HEIGHT, w / IMG_WIDTH, h / IMG_HEIGHT]\n",
+        "            for x, y, w, h in coords\n",
+        "        ]\n",
+        "    else:\n",
+        "        raise ValueError(f\"Unknown coord_type: {coord_type}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "attachments": [],
+        "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
+        "language": "markdown",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "customInput": null,
+          "isCommentPanelOpen": false,
+          "language": "markdown",
+          "originalKey": "2e38c5fe-1aa7-4000-9778-25e240daf5e5",
+          "outputsInitialized": false,
+          "showInput": false
+        },
+        "originalKey": "7f803ec4-a343-43c9-9be3-5d3b9b66ae9a",
+        "outputsInitialized": false,
+        "showInput": false
+      },
+      "source": [
+        "### Loading an example video\n",
+        "\n",
+        "We assume that the video is stored as either **a list of JPEG frames with filenames like `<frame_index>.jpg`** or **an MP4 video**.\n",
+        "\n",
+        "Note that you can extract their JPEG frames using ffmpeg (https://ffmpeg.org/) as follows:\n",
+        "```\n",
+        "ffmpeg -i <your_video>.mp4 -q:v 2 -start_number 0 <output_dir>/'%05d.jpg'\n",
+        "```\n",
+        "where `-q:v` generates high-quality JPEG frames and `-start_number 0` asks ffmpeg to start the JPEG file from `00000.jpg`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Set video path",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1762496679887,
+        "executionStopTime": 1762496680687,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "bentoCellName": {
+            "name": "Print SAM3 Directory Path",
+            "origin": "ai"
+          },
+          "collapsed": false,
+          "customInput": null,
+          "customOutput": null,
+          "executionStartTime": 1761950806610,
+          "executionStopTime": 1761950807097,
+          "isCommentPanelOpen": false,
+          "language": "python",
+          "originalKey": "59540fba-3749-4498-bd14-c28fb7d61dbc",
+          "outputsInitialized": true,
+          "requestMsgId": "2807b3b8-a4fb-41e9-9976-67e2cd1f2ca2",
+          "serverExecutionDuration": 5.3407719824463,
+          "showInput": true
+        },
+        "originalKey": "92d7b964-a3e4-4efb-98d4-202344994413",
+        "outputsInitialized": false,
+        "requestMsgId": "92d7b964-a3e4-4efb-98d4-202344994413",
+        "serverExecutionDuration": 3.5114740003337
+      },
+      "outputs": [],
+      "source": [
+        "# \"video_path\" needs to be either a JPEG folder or a MP4 video file\n",
+        "video_path = f\"{sam3_root}/assets/videos/0001\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Load Video Frames for Visualization",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1762496680695,
+        "executionStopTime": 1762496681428,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "bentoCellName": {
+            "name": "Load Video Frames for Visualization",
+            "origin": "ai"
+          },
+          "collapsed": false,
+          "customInput": null,
+          "customOutput": null,
+          "executionStartTime": 1761950807101,
+          "executionStopTime": 1761950807480,
+          "isCommentPanelOpen": false,
+          "language": "python",
+          "originalKey": "86f88968-93c4-4ca1-81fc-7fad55ccd566",
+          "outputsInitialized": true,
+          "requestMsgId": "96b17a72-b889-4a1f-af98-b40c773780f7",
+          "serverExecutionDuration": 7.6176410075277,
+          "showInput": true
+        },
+        "originalKey": "10fe83fd-eb12-4400-a8ac-b6e137819136",
+        "outputsInitialized": false,
+        "requestMsgId": "10fe83fd-eb12-4400-a8ac-b6e137819136",
+        "serverExecutionDuration": 8.1744140006776
+      },
+      "outputs": [],
+      "source": [
+        "# load \"video_frames_for_vis\" for visualization purposes (they are not used by the model)\n",
+        "if isinstance(video_path, str) and video_path.endswith(\".mp4\"):\n",
+        "    cap = cv2.VideoCapture(video_path)\n",
+        "    video_frames_for_vis = []\n",
+        "    while True:\n",
+        "        ret, frame = cap.read()\n",
+        "        if not ret:\n",
+        "            break\n",
+        "        video_frames_for_vis.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))\n",
+        "    cap.release()\n",
+        "else:\n",
+        "    video_frames_for_vis = glob.glob(os.path.join(video_path, \"*.jpg\"))\n",
+        "    try:\n",
+        "        # integer sort instead of string sort (so that e.g. \"2.jpg\" is before \"11.jpg\")\n",
+        "        video_frames_for_vis.sort(\n",
+        "            key=lambda p: int(os.path.splitext(os.path.basename(p))[0])\n",
+        "        )\n",
+        "    except ValueError:\n",
+        "        # fallback to lexicographic sort if the format is not \"<frame_index>.jpg\"\n",
+        "        print(\n",
+        "            f'frame names are not in \"<frame_index>.jpg\" format: {video_frames_for_vis[:5]=}, '\n",
+        "            f\"falling back to lexicographic sort.\"\n",
+        "        )\n",
+        "        video_frames_for_vis.sort()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "attachments": [],
+        "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
+        "language": "markdown",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "customInput": null,
+          "isCommentPanelOpen": false,
+          "language": "markdown",
+          "originalKey": "2f67df56-df50-470d-bb6d-f736a592dd47",
+          "outputsInitialized": false,
+          "showInput": false
+        },
+        "originalKey": "552fbb00-7387-4014-9161-7f9c32418701",
+        "outputsInitialized": false,
+        "showInput": false
+      },
+      "source": [
+        "### Opening an inference session on this video\n",
+        "\n",
+        "SAM 3 requires stateful inference for interactive video segmentation, so we need to initialize an **inference session** on this video.\n",
+        "\n",
+        "During initialization, it loads all the video frames and stores their pixels in the session state."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Start Video Session",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1762496681434,
+        "executionStopTime": 1762496694273,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "bentoCellName": {
+            "name": "Start Video Session",
+            "origin": "ai"
+          },
+          "collapsed": false,
+          "customInput": null,
+          "customOutput": null,
+          "executionStartTime": 1761950807485,
+          "executionStopTime": 1761950821459,
+          "isCommentPanelOpen": false,
+          "language": "python",
+          "originalKey": "eec3ee85-e95a-4fa7-8401-921fba35d6ee",
+          "outputsInitialized": true,
+          "requestMsgId": "262d936d-486c-4a75-8f25-ad2a2832c3f8",
+          "serverExecutionDuration": 13503.750298987,
+          "showInput": true
+        },
+        "originalKey": "2b5917e0-95da-409a-b2c6-4868fe5ff88e",
+        "output": {
+          "id": "816533627765185",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "2b5917e0-95da-409a-b2c6-4868fe5ff88e",
+        "serverExecutionDuration": 11971.027362999
+      },
+      "outputs": [],
+      "source": [
+        "response = predictor.handle_request(\n",
+        "    request=dict(\n",
+        "        type=\"start_session\",\n",
+        "        resource_path=video_path,\n",
+        "    )\n",
+        ")\n",
+        "session_id = response[\"session_id\"]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "attachments": [],
+        "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
+        "language": "markdown",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "customInput": null,
+          "isCommentPanelOpen": false,
+          "language": "markdown",
+          "originalKey": "4d26ec1b-d78f-4054-879a-cbf06b84a79f",
+          "outputsInitialized": false,
+          "showInput": false
+        },
+        "originalKey": "1da36b65-5759-4803-be41-ec6d2ec8c5d9",
+        "outputsInitialized": false,
+        "showInput": false
+      },
+      "source": [
+        "### Video promptable concept segmentation with text\n",
+        "\n",
+        "Using SAM 3 you can describe objects using natural language, and the model will automatically detect and track all instances of that object throughout the video.\n",
+        "\n",
+        "In the example below, we add a text prompt on frame 0 and propagation throughout the video. Here we use the text prompt \"person\" to detect all people in the video. SAM 3 will automatically identify multiple person instances and assign each a unique object ID.\n",
+        "\n",
+        "Note that the first call might be slower due to setting up buffers. **You can rerun all the cells below when measuring speed.**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Reset Session",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1762496694278,
+        "executionStopTime": 1762496694675,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "bentoCellName": {
+            "name": "Reset Prediction Session",
+            "origin": "ai"
+          },
+          "collapsed": false,
+          "customInput": null,
+          "customOutput": null,
+          "executionStartTime": 1761950821467,
+          "executionStopTime": 1761950821992,
+          "isCommentPanelOpen": false,
+          "language": "python",
+          "originalKey": "be47ff32-7721-43c2-a1ad-b9d1689cf1c1",
+          "outputsInitialized": true,
+          "requestMsgId": "c5eb2442-0530-4408-9ace-ba74e7441cf6",
+          "serverExecutionDuration": 10.527236998314,
+          "showInput": true
+        },
+        "originalKey": "f61b9bc5-5ec7-4c72-9071-e50bedb89f0a",
+        "output": {
+          "id": "4255598051433217",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "f61b9bc5-5ec7-4c72-9071-e50bedb89f0a",
+        "serverExecutionDuration": 9.9740919995384
+      },
+      "outputs": [],
+      "source": [
+        "# note: in case you already ran one text prompt and now want to switch to another text prompt\n",
+        "# it's required to reset the session first (otherwise the results would be wrong)\n",
+        "_ = predictor.handle_request(\n",
+        "    request=dict(\n",
+        "        type=\"reset_session\",\n",
+        "        session_id=session_id,\n",
+        "    )\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Add Text Prompt",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1762496694678,
+        "executionStopTime": 1762496699791,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "bentoCellName": {
+            "name": "Add Prompt to Frame",
+            "origin": "ai"
+          },
+          "collapsed": false,
+          "customInput": null,
+          "customOutput": null,
+          "executionStartTime": 1761950821995,
+          "executionStopTime": 1761950825751,
+          "isCommentPanelOpen": false,
+          "language": "python",
+          "originalKey": "ca780545-a450-4ed8-a192-f6033e0288ba",
+          "outputsInitialized": true,
+          "requestMsgId": "d784487d-5758-40a4-8a66-1ea26ad3bcfd",
+          "serverExecutionDuration": 3358.8370049838,
+          "showInput": true
+        },
+        "originalKey": "55538638-8336-4b1c-9daf-517c0dc31806",
+        "output": {
+          "id": "2083947459075035",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "55538638-8336-4b1c-9daf-517c0dc31806",
+        "serverExecutionDuration": 3957.4137909985
+      },
+      "outputs": [],
+      "source": [
+        "prompt_text_str = \"person\"\n",
+        "frame_idx = 0  # add a text prompt on frame 0\n",
+        "response = predictor.handle_request(\n",
+        "    request=dict(\n",
+        "        type=\"add_prompt\",\n",
+        "        session_id=session_id,\n",
+        "        frame_index=frame_idx,\n",
+        "        text=prompt_text_str,\n",
+        "    )\n",
+        ")\n",
+        "out = response[\"outputs\"]\n",
+        "\n",
+        "plt.close(\"all\")\n",
+        "visualize_formatted_frame_output(\n",
+        "    frame_idx,\n",
+        "    video_frames_for_vis,\n",
+        "    outputs_list=[prepare_masks_for_visualization({frame_idx: out})],\n",
+        "    titles=[\"SAM 3 Dense Tracking outputs\"],\n",
+        "    figsize=(6, 4),\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Visualize Video Outputs",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1762496699796,
+        "executionStopTime": 1762496734325,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "bentoCellName": {
+            "name": "Visualize Video Outputs",
+            "origin": "ai"
+          },
+          "collapsed": false,
+          "customInput": null,
+          "customOutput": null,
+          "executionStartTime": 1761950827402,
+          "executionStopTime": 1761950861260,
+          "isCommentPanelOpen": false,
+          "language": "python",
+          "originalKey": "06edc7da-9dd1-42e8-b502-0afdbfbaddc2",
+          "outputsInitialized": true,
+          "requestMsgId": "33659e9c-a817-40fe-b3b7-727b7a344d74",
+          "serverExecutionDuration": 33374.819626013,
+          "showInput": true
+        },
+        "originalKey": "41e1b095-80a4-4997-9b3e-2baa28dba05f",
+        "output": {
+          "id": "2605449593181328",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "41e1b095-80a4-4997-9b3e-2baa28dba05f",
+        "serverExecutionDuration": 33588.144188001
+      },
+      "outputs": [],
+      "source": [
+        "# now we propagate the outputs from frame 0 to the end of the video and collect all outputs\n",
+        "outputs_per_frame = propagate_in_video(predictor, session_id)\n",
+        "\n",
+        "# finally, we reformat the outputs for visualization and plot the outputs every 60 frames\n",
+        "outputs_per_frame = prepare_masks_for_visualization(outputs_per_frame)\n",
+        "\n",
+        "vis_frame_stride = 60\n",
+        "plt.close(\"all\")\n",
+        "for frame_idx in range(0, len(outputs_per_frame), vis_frame_stride):\n",
+        "    visualize_formatted_frame_output(\n",
+        "        frame_idx,\n",
+        "        video_frames_for_vis,\n",
+        "        outputs_list=[outputs_per_frame],\n",
+        "        titles=[\"SAM 3 Dense Tracking outputs\"],\n",
+        "        figsize=(6, 4),\n",
+        "    )"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "customInput": null,
+        "isCommentPanelOpen": false,
+        "language": "markdown",
+        "originalKey": "e341c66f-6083-4731-b8e1-ebc7b4177a43",
+        "outputsInitialized": false,
+        "showInput": false
+      },
+      "source": [
+        "###  Removing objects\n",
+        "\n",
+        "We can remove individual objects using their id.\n",
+        "\n",
+        "As an example, let's remove object 2 (which is the dancer in the front)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Remove Front Dancer",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1762496734333,
+        "executionStopTime": 1762496735487,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "originalKey": "cf97330e-68f5-4f4e-931f-bc5b6faa77ff",
+        "output": {
+          "id": "1345936250272478",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "cf97330e-68f5-4f4e-931f-bc5b6faa77ff",
+        "serverExecutionDuration": 127.66883199947,
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# we pick id 2, which is the dancer in the front\n",
+        "obj_id = 2\n",
+        "response = predictor.handle_request(\n",
+        "    request=dict(\n",
+        "        type=\"remove_object\",\n",
+        "        session_id=session_id,\n",
+        "        obj_id=obj_id,\n",
+        "    )\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Visualize Video Outputs",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1762496735493,
+        "executionStopTime": 1762496742056,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "originalKey": "a4552ab0-1b08-42b6-b90d-bfd1814c9398",
+        "output": {
+          "id": "1747332999309403",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "a4552ab0-1b08-42b6-b90d-bfd1814c9398",
+        "serverExecutionDuration": 5491.8713629995,
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# now we propagate the outputs from frame 0 to the end of the video and collect all outputs\n",
+        "outputs_per_frame = propagate_in_video(predictor, session_id)\n",
+        "\n",
+        "# finally, we reformat the outputs for visualization and plot the outputs every 60 frames\n",
+        "outputs_per_frame = prepare_masks_for_visualization(outputs_per_frame)\n",
+        "\n",
+        "vis_frame_stride = 60\n",
+        "plt.close(\"all\")\n",
+        "for frame_idx in range(0, len(outputs_per_frame), vis_frame_stride):\n",
+        "    visualize_formatted_frame_output(\n",
+        "        frame_idx,\n",
+        "        video_frames_for_vis,\n",
+        "        outputs_list=[outputs_per_frame],\n",
+        "        titles=[\"SAM 3 Dense Tracking outputs\"],\n",
+        "        figsize=(6, 4),\n",
+        "    )"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "customInput": null,
+        "isCommentPanelOpen": false,
+        "language": "markdown",
+        "originalKey": "4606cb85-5007-4b11-baa6-41ce9017de8e",
+        "outputsInitialized": false,
+        "showInput": false
+      },
+      "source": [
+        "### Adding new objects with point prompts\n",
+        "\n",
+        "We can add new objects through point prompts.\n",
+        "\n",
+        "Assuming that we've changed our mind, and now that we want to add back the dancer in the front (whom we just removed in the step above). We can use interactive clicks to add her back."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Get image dimensions",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1762496742064,
+        "executionStopTime": 1762496743435,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "originalKey": "2ad8f8e9-49d8-4003-ad2f-f289ab5befc8",
+        "outputsInitialized": false,
+        "requestMsgId": "2ad8f8e9-49d8-4003-ad2f-f289ab5befc8",
+        "serverExecutionDuration": 15.222899999571,
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "sample_img = Image.fromarray(load_frame(video_frames_for_vis[0]))\n",
+        "\n",
+        "IMG_WIDTH, IMG_HEIGHT = sample_img.size"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Convert Absolute to Relative Coordinates",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1762496743442,
+        "executionStopTime": 1762496744333,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "originalKey": "3baca8f9-8e19-46da-a320-29524ddbf950",
+        "outputsInitialized": false,
+        "requestMsgId": "3baca8f9-8e19-46da-a320-29524ddbf950",
+        "serverExecutionDuration": 3.9295850001508,
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# let's add back the dancer via point prompts.\n",
+        "# we will use a single positive click to add the dancer back.\n",
+        "\n",
+        "frame_idx = 0\n",
+        "obj_id = 2\n",
+        "points_abs = np.array(\n",
+        "    [\n",
+        "        [760, 550],  # positive click\n",
+        "    ]\n",
+        ")\n",
+        "# positive clicks have label 1, while negative clicks have label 0\n",
+        "labels = np.array([1])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Display Data Points",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1762496744337,
+        "executionStopTime": 1762496748117,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "originalKey": "865e951f-8d0a-41bf-8d51-72092703e3cf",
+        "output": {
+          "id": "1240547311311464",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "865e951f-8d0a-41bf-8d51-72092703e3cf",
+        "serverExecutionDuration": 1224.9363859992,
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# convert points and labels to tensors; also convert to relative coordinates\n",
+        "points_tensor = torch.tensor(\n",
+        "    abs_to_rel_coords(points_abs, IMG_WIDTH, IMG_HEIGHT, coord_type=\"point\"),\n",
+        "    dtype=torch.float32,\n",
+        ")\n",
+        "points_labels_tensor = torch.tensor(labels, dtype=torch.int32)\n",
+        "\n",
+        "response = predictor.handle_request(\n",
+        "    request=dict(\n",
+        "        type=\"add_prompt\",\n",
+        "        session_id=session_id,\n",
+        "        frame_index=frame_idx,\n",
+        "        points=points_tensor,\n",
+        "        point_labels=points_labels_tensor,\n",
+        "        obj_id=obj_id,\n",
+        "    )\n",
+        ")\n",
+        "out = response[\"outputs\"]\n",
+        "\n",
+        "plt.close(\"all\")\n",
+        "visualize_formatted_frame_output(\n",
+        "    frame_idx,\n",
+        "    video_frames_for_vis,\n",
+        "    outputs_list=[prepare_masks_for_visualization({frame_idx: out})],\n",
+        "    titles=[\"SAM 3 Dense Tracking outputs\"],\n",
+        "    figsize=(6, 4),\n",
+        "    points_list=[points_abs],\n",
+        "    points_labels_list=[labels],\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Process Video Frames",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1762496748120,
+        "executionStopTime": 1762496774486,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "originalKey": "cf1d2dda-464b-4a6a-aff3-d729aa486ec3",
+        "output": {
+          "id": "824678093489712",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "cf1d2dda-464b-4a6a-aff3-d729aa486ec3",
+        "serverExecutionDuration": 25528.605932001,
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# now we propagate the outputs from frame 0 to the end of the video and collect all outputs\n",
+        "outputs_per_frame = propagate_in_video(predictor, session_id)\n",
+        "\n",
+        "# finally, we reformat the outputs for visualization and plot the outputs every 60 frames\n",
+        "outputs_per_frame = prepare_masks_for_visualization(outputs_per_frame)\n",
+        "\n",
+        "vis_frame_stride = 60\n",
+        "plt.close(\"all\")\n",
+        "for frame_idx in range(0, len(outputs_per_frame), vis_frame_stride):\n",
+        "    visualize_formatted_frame_output(\n",
+        "        frame_idx,\n",
+        "        video_frames_for_vis,\n",
+        "        outputs_list=[outputs_per_frame],\n",
+        "        titles=[\"SAM 3 Dense Tracking outputs\"],\n",
+        "        figsize=(6, 4),\n",
+        "    )"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "customInput": null,
+        "isCommentPanelOpen": false,
+        "language": "markdown",
+        "originalKey": "79b12d4e-cdf0-41b8-9939-bcc1d5422115",
+        "outputsInitialized": false,
+        "showInput": false
+      },
+      "source": [
+        "### Refining an existing object with point prompts\n",
+        "\n",
+        "We can also refine the segmentation mask of an existing object through point prompts.\n",
+        "\n",
+        "Assuming that we've changed our mind (again) -- for Object ID 2 (the dancer in the front whom we just added back in the step above), now we only want to segment her T-shirt instead of her whole body. We can adjust the segmentation mask with a few more positive and negative clicks."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Segment T-shirt with Clicks",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1762496774494,
+        "executionStopTime": 1762496775380,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "originalKey": "8114fb12-386d-45e0-b875-f74eee630d96",
+        "outputsInitialized": false,
+        "requestMsgId": "8114fb12-386d-45e0-b875-f74eee630d96",
+        "serverExecutionDuration": 4.0469909999956,
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# For the dancer in the front, suppose now we only want to segment her T-shirt instead of her whole body\n",
+        "# we will use 2 positive clicks and 2 negative clicks to select her shirt.\n",
+        "\n",
+        "frame_idx = 0\n",
+        "obj_id = 2\n",
+        "points_abs = np.array(\n",
+        "    [\n",
+        "        [740, 450],  # positive click\n",
+        "        [760, 630],  # negative click\n",
+        "        [840, 640],  # negative click\n",
+        "        [760, 550],  # positive click\n",
+        "    ]\n",
+        ")\n",
+        "# positive clicks have label 1, while negative clicks have label 0\n",
+        "labels = np.array([1, 0, 0, 1])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Process and Visualize Frame Outputs",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1762496775385,
+        "executionStopTime": 1762496777685,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "originalKey": "5e66f671-aa71-42d7-a68d-8dc6430df8fe",
+        "output": {
+          "id": "25486291537675748",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "5e66f671-aa71-42d7-a68d-8dc6430df8fe",
+        "serverExecutionDuration": 1227.9235379992,
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# convert points and labels to tensors; also convert to relative coordinates\n",
+        "points_tensor = torch.tensor(\n",
+        "    abs_to_rel_coords(points_abs, IMG_WIDTH, IMG_HEIGHT, coord_type=\"point\"),\n",
+        "    dtype=torch.float32,\n",
+        ")\n",
+        "points_labels_tensor = torch.tensor(labels, dtype=torch.int32)\n",
+        "\n",
+        "response = predictor.handle_request(\n",
+        "    request=dict(\n",
+        "        type=\"add_prompt\",\n",
+        "        session_id=session_id,\n",
+        "        frame_index=frame_idx,\n",
+        "        points=points_tensor,\n",
+        "        point_labels=points_labels_tensor,\n",
+        "        obj_id=obj_id,\n",
+        "    )\n",
+        ")\n",
+        "out = response[\"outputs\"]\n",
+        "\n",
+        "plt.close(\"all\")\n",
+        "visualize_formatted_frame_output(\n",
+        "    frame_idx,\n",
+        "    video_frames_for_vis,\n",
+        "    outputs_list=[prepare_masks_for_visualization({frame_idx: out})],\n",
+        "    titles=[\"SAM 3 Dense Tracking outputs\"],\n",
+        "    figsize=(6, 4),\n",
+        "    points_list=[points_abs],\n",
+        "    points_labels_list=[labels],\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Visualize Video Tracking Outputs",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1762496777688,
+        "executionStopTime": 1762496803927,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "originalKey": "5c4a35a7-e5cc-4c7d-ba05-25540665d125",
+        "output": {
+          "id": "1222230279729631",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "5c4a35a7-e5cc-4c7d-ba05-25540665d125",
+        "serverExecutionDuration": 25325.393453,
+        "showInput": true
+      },
+      "outputs": [],
+      "source": [
+        "# now we propagate the outputs from frame 0 to the end of the video and collect all outputs\n",
+        "outputs_per_frame = propagate_in_video(predictor, session_id)\n",
+        "\n",
+        "# finally, we reformat the outputs for visualization and plot the outputs every 60 frames\n",
+        "outputs_per_frame = prepare_masks_for_visualization(outputs_per_frame)\n",
+        "\n",
+        "vis_frame_stride = 60\n",
+        "plt.close(\"all\")\n",
+        "for frame_idx in range(0, len(outputs_per_frame), vis_frame_stride):\n",
+        "    visualize_formatted_frame_output(\n",
+        "        frame_idx,\n",
+        "        video_frames_for_vis,\n",
+        "        outputs_list=[outputs_per_frame],\n",
+        "        titles=[\"SAM 3 Dense Tracking outputs\"],\n",
+        "        figsize=(6, 4),\n",
+        "    )"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "attachments": [],
+        "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
+        "language": "markdown",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "customInput": null,
+          "isCommentPanelOpen": false,
+          "language": "markdown",
+          "originalKey": "3f8d998b-4585-4956-b15d-1d4078cf8927",
+          "outputsInitialized": false,
+          "showInput": false
+        },
+        "originalKey": "b1d99d9b-c26e-4d5a-a4a2-70aab345fd77",
+        "outputsInitialized": false,
+        "showInput": false
+      },
+      "source": [
+        "### Close session\n",
+        "\n",
+        "Each session is tied to a single video. We can close the session after inference to free up its resources.\n",
+        "\n",
+        "(Then, you may start a new session on another video.)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Close inference session",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1762496803937,
+        "executionStopTime": 1762496805854,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "bentoCellName": {
+            "name": "Reset Session Request",
+            "origin": "ai"
+          },
+          "collapsed": false,
+          "customInput": null,
+          "customOutput": null,
+          "executionStartTime": 1761950861264,
+          "executionStopTime": 1761950863082,
+          "isCommentPanelOpen": false,
+          "language": "python",
+          "originalKey": "d08a9e5f-3563-4aa1-ba8a-9f94615e4d7e",
+          "outputsInitialized": true,
+          "requestMsgId": "6e872e9a-3803-418f-827d-f1d817ef9cb9",
+          "serverExecutionDuration": 926.3133899949,
+          "showInput": true
+        },
+        "originalKey": "4f94819e-de3c-49bc-a25f-0790b2fa2cfb",
+        "output": {
+          "id": "1532190008092267",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "4f94819e-de3c-49bc-a25f-0790b2fa2cfb",
+        "serverExecutionDuration": 941.08029199924
+      },
+      "outputs": [],
+      "source": [
+        "# finally, close the inference session to free its GPU resources\n",
+        "# (you may start a new session on another video)\n",
+        "_ = predictor.handle_request(\n",
+        "    request=dict(\n",
+        "        type=\"close_session\",\n",
+        "        session_id=session_id,\n",
+        "    )\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "attachments": [],
+        "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
+        "language": "markdown",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "customInput": null,
+          "isCommentPanelOpen": false,
+          "language": "markdown",
+          "originalKey": "d79e36cd-a691-420d-8061-ad5222913770",
+          "outputsInitialized": false,
+          "showInput": false
+        },
+        "originalKey": "5f1ced4a-7f9b-4a3f-88bb-77fd601466eb",
+        "outputsInitialized": false,
+        "showInput": false
+      },
+      "source": [
+        "### Clean-up\n",
+        "\n",
+        "After all inference is done, we can shutdown the predictor to free up the multi-GPU process group."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Shutdown Predictor",
+          "origin": "ai"
+        },
+        "collapsed": false,
+        "customOutput": null,
+        "executionStartTime": 1762496805866,
+        "executionStopTime": 1762496807085,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "metadata": {
+          "bentoAICellStatus": "none",
+          "bentoCellName": {
+            "name": "Shutdown Predictor",
+            "origin": "ai"
+          },
+          "collapsed": false,
+          "customInput": null,
+          "customOutput": null,
+          "executionStartTime": 1761950863090,
+          "executionStopTime": 1761950863987,
+          "isCommentPanelOpen": false,
+          "language": "python",
+          "originalKey": "2de9666e-d888-4b2b-955a-82727363fc59",
+          "outputsInitialized": true,
+          "requestMsgId": "59e250c1-3d4c-436d-aa6e-fc0429fe4d8f",
+          "serverExecutionDuration": 282.37027197611,
+          "showInput": true
+        },
+        "originalKey": "bb5f6b72-d945-4193-8988-2490e9168882",
+        "output": {
+          "id": "1866958724222293",
+          "loadingStatus": "before loading"
+        },
+        "outputsInitialized": true,
+        "requestMsgId": "bb5f6b72-d945-4193-8988-2490e9168882",
+        "serverExecutionDuration": 284.71523799999
+      },
+      "outputs": [],
+      "source": [
+        "# after all inference is done, we can shutdown the predictor\n",
+        "# to free up the multi-GPU process group\n",
+        "predictor.shutdown()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "bentoAICellStatus": "none",
+        "bentoCellName": {
+          "name": "Cell 33",
+          "origin": "initial"
+        },
+        "collapsed": false,
+        "customInput": null,
+        "customOutput": null,
+        "executionStartTime": 1762496807093,
+        "executionStopTime": 1762496807812,
+        "isCommentPanelOpen": false,
+        "jupyter": {
+          "outputs_hidden": false
+        },
+        "language": "python",
+        "originalKey": "e4ad9f5f-c0df-4e30-97a2-40d389ba92ac",
+        "outputsInitialized": false,
+        "requestMsgId": "e4ad9f5f-c0df-4e30-97a2-40d389ba92ac",
+        "serverExecutionDuration": 3.5742059990298,
+        "showInput": true
+      },
+      "outputs": [],
+      "source": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "bento_stylesheets": {
+      "bento/extensions/flow/main.css": true,
+      "bento/extensions/kernel_selector/main.css": true,
+      "bento/extensions/kernel_ui/main.css": true,
+      "bento/extensions/new_kernel/main.css": true,
+      "bento/extensions/system_usage/main.css": true,
+      "bento/extensions/theme/main.css": true
+    },
+    "captumWidgetMessage": [],
+    "fileHeader": "",
+    "fileUid": "8685c221-c143-4b84-98ec-b1f023cedd6c",
+    "isAdHoc": false,
+    "kernelspec": {
+      "display_name": "Python 3 (ipykernel)",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.12.11"
+    },
+    "last_base_url": "https://bento.edge.x2p.facebook.net/",
+    "last_kernel_id": "b57809cb-57de-4b58-a47a-2cd14cd7dc51",
+    "last_msg_id": "be2245fc-daa1cc5649ef79144c475c5d_1965",
+    "last_server_session_id": "4fb65252-bdbd-4eea-b3c3-4a9f2995ad48",
+    "notebookId": "825823386977069",
+    "notebookNumber": "N8482762"
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}

third_party/GraspGen/sam3/pyproject.toml

@@ -0,0 +1,133 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sam3"
+dynamic = ["version"]
+description = "SAM3 (Segment Anything Model 3) implementation"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {file = "LICENSE"}
+authors = [
+    {name = "Meta AI Research"}
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "timm>=1.0.17",
+    "numpy>=1.26,<2",
+    "tqdm",
+    "ftfy==6.1.1",
+    "regex",
+    "iopath>=0.1.10",
+    "typing_extensions",
+    "huggingface_hub",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-cov",
+    "black==24.2.0",
+    "ufmt==2.8.0",
+    "ruff-api==0.1.0",
+    "usort==1.0.2",
+    "gitpython==3.1.31",
+    "yt-dlp",
+    "pandas",
+    "opencv-python",
+    "pycocotools",
+    "numba",
+    "python-rapidjson",
+]
+notebooks = [
+    "matplotlib",
+    "jupyter",
+    "notebook",
+    "ipywidgets",
+    "ipycanvas",
+    "ipympl",
+    "pycocotools",
+    "decord",
+    "opencv-python",
+    "einops",
+    "scikit-image",
+    "scikit-learn",
+]
+train = [
+    "hydra-core",
+    "submitit",
+    "tensorboard",
+    "zstandard",
+    "scipy",
+    "torchmetrics",
+    "fvcore",
+    "fairscale",
+    "scikit-image",
+    "scikit-learn",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/facebookresearch/sam3"
+"Bug Tracker" = "https://github.com/facebookresearch/sam3/issues"
+
+[tool.setuptools.packages.find]
+include = ["sam3*"]
+exclude = ["build*", "scripts*", "examples*"]
+
+[tool.setuptools.package-data]
+sam3 = ["assets/*.txt.gz"]
+
+[tool.setuptools.dynamic]
+version = {attr = "sam3.__version__"}
+
+[tool.black]
+line-length = 88
+target-version = ['py38', 'py39', 'py310', 'py311', 'py312']
+include = '\.pyi?$'
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+
+[tool.usort]
+first_party_detection = false
+
+[tool.ufmt]
+formatter = "ruff-api"
+
+[tool.mypy]
+python_version = "3.12"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+
+[[tool.mypy.overrides]]
+module = [
+    "timm.*",
+    "numpy.*",
+    "PIL.*",
+    "tqdm.*",
+    "ftfy.*",
+    "regex.*",
+    "iopath.*",
+]
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = "test_*.py"
+python_classes = "Test*"
+python_functions = "test_*"

third_party/GraspGen/sam3/realsense-sam.py

@@ -0,0 +1,1771 @@
+import argparse
+import json
+import multiprocessing as mp
+import os
+import queue
+import signal
+import subprocess
+import sys
+import time
+
+import cv2
+import numpy as np
+
+# ROS2 TF & 图像（可选：未安装 ROS2 时仅跳过 TF/相机）
+try:
+    import rclpy
+    from rclpy.node import Node
+    from geometry_msgs.msg import TransformStamped, PoseStamped
+    from tf2_ros import TransformBroadcaster
+    from sensor_msgs.msg import Image, CameraInfo, PointCloud2, PointField
+    from std_msgs.msg import Header
+    from visualization_msgs.msg import Marker, MarkerArray
+    from builtin_interfaces.msg import Duration as BuiltinDuration
+    from cv_bridge import CvBridge
+
+    _ROS_AVAILABLE = True
+except ImportError:
+    _ROS_AVAILABLE = False
+    rclpy = None
+    Node = None
+    TransformStamped = None
+    TransformBroadcaster = None
+    Image = None
+    CameraInfo = None
+    CvBridge = None
+import open3d as o3d
+import pyrealsense2 as rs
+import torch
+from PIL import Image as PILImage
+
+# ------------------- 机械臂相关配置（与 heihei.py 一致）-------------------
+ROBOT_TYPE = "piper"
+CAN_CHANNEL = "can0"
+TCP_OFFSET = [0.0, 0.0, 0.10, 0.0, 0.0, 0.0]  # TCP Z 轴 +14cm
+SPEED_PERCENT = 30
+MOTION_TIMEOUT = 15.0
+POSE_SAVE_FILE = "/home/agilex/.nanobot/workspace/skills/grab_skill/sam3/recorded_j6_pose.json"  # J6 法兰位姿保存路径（与 heihei 共用）
+GRIPPER_MAX_WIDTH = 0.1  # 夹爪最大开口 (m)
+GRIPPER_MIN_WIDTH = 0.0  # 夹爪最小开口 (m)
+GRIPPER_FORCE = 2.0  # 夹爪夹持力 (N)
+
+# 使用 RealSense ROS2 驱动时，深度图单位通常为毫米（uint16）
+DEPTH_SCALE_ROS = 0.001  # 每个深度单位对应的米数（mm -> m）
+
+# J6 到相机坐标系的变换 [x, y, z, qx, qy, qz, qw]（与 j6_pose_tf_node.py 一致）
+# 即 T_j6_to_camera，用于 T_result = T_j6 @ T_j6_to_camera（相机在基座系下）
+J6_TO_CAMERA = [
+    -0.06657143797304754,
+    -0.007181201910632633,
+    0.033259474804825814,
+    -0.1665998530,
+    0.1479507149,
+    -0.6490963521,
+    0.7273437981,
+]
+
+# ROS TF 坐标系名称
+TF_FRAME_BASE = "base_link"
+TF_FRAME_J6_FLANGE = "piper_j6_flange"
+TF_FRAME_CAMERA = "camera_link"
+TF_FRAME_GRASP_TARGET = "grasp_target"
+
+# RealSense 自身 TF：camera_link -> camera_color_optical_frame
+# 来源：ros2 run tf2_ros tf2_echo camera_link camera_color_optical_frame
+T_CAMLINK_TO_COLOR_OPTICAL = [
+    0.0,
+    0.015,
+    0.0,
+    0.5,
+    -0.5,
+    0.501,
+    -0.5,
+]
+
+# RealSense 光学坐标系 frame 名称（与 /camera/camera/aligned_depth_to_color/image_raw 一致）
+CAMERA_OPTICAL_FRAME = "camera_color_optical_frame"
+
+# RealSense ROS2 相机节点：程序内自动拉起/退出
+CAMERA_WS_PATH = "/home/agilex/ros_workspace/camera_ws"
+CAMERA_SETUP_SCRIPT = os.path.join(CAMERA_WS_PATH, "install", "setup.sh")
+CAMERA_LAUNCH_CMD = "ros2 launch realsense2_camera rs_align_depth_launch.py"
+CAMERA_LAUNCH_SHELL_CMD = (
+    f"source {CAMERA_SETUP_SCRIPT} && {CAMERA_LAUNCH_CMD}"
+)
+
+
+def make_pointcloud2(points_xyz, colors_rgb, frame_id, stamp):
+    """
+    将 (N,3) XYZ 和 (N,3) RGB 数组转换为 PointCloud2（XYZRGB），发布在给定坐标系下。
+    """
+    if points_xyz.size == 0:
+        return None
+    pts = np.asarray(points_xyz, dtype=np.float32)
+    cols = np.clip(np.asarray(colors_rgb, dtype=np.float32) * 255.0, 0, 255).astype(
+        np.uint8
+    )
+    if pts.shape[0] != cols.shape[0]:
+        n = min(pts.shape[0], cols.shape[0])
+        pts = pts[:n]
+        cols = cols[:n]
+
+    # 按 PCL/ROS 约定打包为 x,y,z,rgb（rgb 为 float32，内部存放 uint32 的 BGR）
+    r = cols[:, 0].astype(np.uint32)
+    g = cols[:, 1].astype(np.uint32)
+    b = cols[:, 2].astype(np.uint32)
+    rgb_uint32 = (r << 16) | (g << 8) | b
+    rgb_float = rgb_uint32.view(np.float32)
+
+    # 组装结构化数组：x,y,z,rgb
+    cloud_arr = np.zeros(
+        pts.shape[0],
+        dtype=[
+            ("x", np.float32),
+            ("y", np.float32),
+            ("z", np.float32),
+            ("rgb", np.float32),
+        ],
+    )
+    cloud_arr["x"] = pts[:, 0]
+    cloud_arr["y"] = pts[:, 1]
+    cloud_arr["z"] = pts[:, 2]
+    cloud_arr["rgb"] = rgb_float
+
+    msg = PointCloud2()
+    msg.header = Header()
+    msg.header.stamp = stamp
+    msg.header.frame_id = frame_id
+    msg.height = 1
+    msg.width = cloud_arr.shape[0]
+    msg.fields = [
+        PointField(name="x", offset=0, datatype=PointField.FLOAT32, count=1),
+        PointField(name="y", offset=4, datatype=PointField.FLOAT32, count=1),
+        PointField(name="z", offset=8, datatype=PointField.FLOAT32, count=1),
+        PointField(name="rgb", offset=12, datatype=PointField.FLOAT32, count=1),
+    ]
+    msg.is_bigendian = False
+    msg.point_step = 16  # 3*4 (xyz) + 4 (rgb)
+    msg.row_step = msg.point_step * cloud_arr.shape[0]
+    msg.is_dense = True
+    msg.data = cloud_arr.tobytes()
+    return msg
+
+
+def start_camera_launch():
+    """
+    在子进程中拉起 RealSense ROS2 节���：source camera_ws/setup.sh && ros2 launch ...
+    返回 subprocess.Popen 实例，退出时需调用 stop_camera_launch(proc)。
+    """
+    if not os.path.isfile(CAMERA_SETUP_SCRIPT):
+        print(f"[Camera] 未找到 setup 脚本: {CAMERA_SETUP_SCRIPT}，请检查路径")
+        return None
+    print("[Camera] 正在拉起 RealSense ROS2 节点...")
+    try:
+        proc = subprocess.Popen(
+            CAMERA_LAUNCH_SHELL_CMD,
+            shell=True,
+            executable="/bin/bash",
+            cwd=CAMERA_WS_PATH,
+            start_new_session=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+        )
+        print("[Camera] RealSense launch 已启动，等待数秒使节点就绪...")
+        time.sleep(5)
+        if proc.poll() is not None:
+            err = proc.stderr.read().decode("utf-8", errors="replace") if proc.stderr else ""
+            print(f"[Camera] launch 进程已异常退出: {err}")
+            return None
+        return proc
+    except Exception as e:
+        print(f"[Camera] 启动失败: {e}")
+        return None
+
+
+def stop_camera_launch(proc, timeout=10):
+    """终止由 start_camera_launch 拉起的进程（及其进程组）。"""
+    if proc is None:
+        return
+    try:
+        if proc.poll() is None:
+            pgid = os.getpgid(proc.pid)
+            os.killpg(pgid, signal.SIGTERM)
+            proc.wait(timeout=timeout)
+    except ProcessLookupError:
+        pass
+    except Exception as e:
+        print(f"[Camera] 关闭 launch 时出错: {e}")
+        try:
+            proc.kill()
+            proc.wait(timeout=3)
+        except Exception:
+            pass
+
+
+# 无保存文件时的 fallback：相机在基座系下的齐次矩阵（仅当未按 D 记录过时使用）
+T_BASE_CAM_FALLBACK = np.array(
+    [
+        [-0.043365, -0.977782, 0.205091, 0.196176],
+        [-0.989188, 0.013236, -0.146053, 0.238188],
+        [0.140093, -0.209207, -0.967784, 0.219417],
+        [0.0, 0.0, 0.0, 1.0],
+    ],
+    dtype=np.float32,
+)
+
+
+def euler_to_rotation_matrix(roll, pitch, yaw):
+    """欧拉角 Z-Y-X (rad) -> 3x3 旋转矩阵"""
+    cr, sr = np.cos(roll), np.sin(roll)
+    cp, sp = np.cos(pitch), np.sin(pitch)
+    cy, sy = np.cos(yaw), np.sin(yaw)
+    R = np.array(
+        [
+            [cy * cp, cy * sp * sr - sy * cr, cy * sp * cr + sy * sr],
+            [sy * cp, sy * sp * sr + cy * cr, sy * sp * cr - cy * sr],
+            [-sp, cp * sr, cp * cr],
+        ]
+    )
+    return R
+
+
+def rotation_matrix_to_euler(R):
+    """3x3 旋转矩阵 -> Z-Y-X 欧拉角 (roll, pitch, yaw) rad"""
+    sy = -R[2, 0]
+    pitch = np.arcsin(np.clip(sy, -1.0, 1.0))
+    cp = np.cos(pitch)
+    if np.abs(cp) > 1e-6:
+        yaw = np.arctan2(R[1, 0], R[0, 0])
+        roll = np.arctan2(R[2, 1], R[2, 2])
+    else:
+        yaw = 0.0
+        roll = np.arctan2(-R[0, 1], R[1, 1])
+    return roll, pitch, yaw
+
+
+def pose_to_homogeneous_matrix(pose):
+    """[x,y,z,roll,pitch,yaw] -> 4x4 齐次矩阵"""
+    x, y, z = pose[0], pose[1], pose[2]
+    roll, pitch, yaw = pose[3], pose[4], pose[5]
+    R = euler_to_rotation_matrix(roll, pitch, yaw)
+    T = np.eye(4, dtype=np.float32)
+    T[:3, :3] = R
+    T[:3, 3] = [x, y, z]
+    return T
+
+
+def homogeneous_to_pose(T):
+    """4x4 齐次矩阵 -> [x,y,z,roll,pitch,yaw] (m, rad)"""
+    x, y, z = T[0, 3], T[1, 3], T[2, 3]
+    R = T[:3, :3]
+    roll, pitch, yaw = rotation_matrix_to_euler(R)
+    return [float(x), float(y), float(z), float(roll), float(pitch), float(yaw)]
+
+
+def quat_pose_to_homogeneous_matrix(pose7):
+    """[x, y, z, qx, qy, qz, qw] -> 4x4 齐次矩阵"""
+    x, y, z = pose7[0], pose7[1], pose7[2]
+    qx, qy, qz, qw = pose7[3], pose7[4], pose7[5], pose7[6]
+    R = quaternion_to_rotation_matrix(qx, qy, qz, qw)
+    T = np.eye(4, dtype=np.float32)
+    T[:3, :3] = R
+    T[:3, 3] = [x, y, z]
+    return T
+
+
+def quaternion_to_rotation_matrix(qx, qy, qz, qw):
+    """四元数 (x, y, z, w) -> 3x3 旋转矩阵"""
+    return np.array(
+        [
+            [
+                1.0 - 2.0 * (qy * qy + qz * qz),
+                2.0 * (qx * qy - qz * qw),
+                2.0 * (qx * qz + qy * qw),
+            ],
+            [
+                2.0 * (qx * qy + qz * qw),
+                1.0 - 2.0 * (qx * qx + qz * qz),
+                2.0 * (qy * qz - qx * qw),
+            ],
+            [
+                2.0 * (qx * qz - qy * qw),
+                2.0 * (qy * qz + qx * qw),
+                1.0 - 2.0 * (qx * qx + qy * qy),
+            ],
+        ],
+        dtype=np.float32,
+    )
+
+
+def rotation_matrix_to_quaternion(R):
+    """3x3 旋转矩阵 -> 四元数 (qx, qy, qz, qw)"""
+    trace = R[0, 0] + R[1, 1] + R[2, 2]
+    if trace > 0:
+        s = 0.5 / np.sqrt(trace + 1.0)
+        qw = 0.25 / s
+        qx = (R[2, 1] - R[1, 2]) * s
+        qy = (R[0, 2] - R[2, 0]) * s
+        qz = (R[1, 0] - R[0, 1]) * s
+    elif R[0, 0] > R[1, 1] and R[0, 0] > R[2, 2]:
+        s = 2.0 * np.sqrt(1.0 + R[0, 0] - R[1, 1] - R[2, 2])
+        qw = (R[2, 1] - R[1, 2]) / s
+        qx = 0.25 * s
+        qy = (R[0, 1] + R[1, 0]) / s
+        qz = (R[0, 2] + R[2, 0]) / s
+    elif R[1, 1] > R[2, 2]:
+        s = 2.0 * np.sqrt(1.0 + R[1, 1] - R[0, 0] - R[2, 2])
+        qw = (R[0, 2] - R[2, 0]) / s
+        qx = (R[0, 1] + R[1, 0]) / s
+        qy = 0.25 * s
+        qz = (R[1, 2] + R[2, 1]) / s
+    else:
+        s = 2.0 * np.sqrt(1.0 + R[2, 2] - R[0, 0] - R[1, 1])
+        qw = (R[1, 0] - R[0, 1]) / s
+        qx = (R[0, 2] + R[2, 0]) / s
+        qy = (R[1, 2] + R[2, 1]) / s
+        qz = 0.25 * s
+    return (float(qx), float(qy), float(qz), float(qw))
+
+
+def load_T_result_from_saved_j6():
+    """
+    从 POSE_SAVE_FILE 加载 J6 法兰位姿，与 J6_TO_CAMERA 相乘得到 T_result（相机在基座系下）。
+    若文件不存在或解析失败则返回 None，调用方用 T_BASE_CAM_FALLBACK。
+    """
+    if not os.path.exists(POSE_SAVE_FILE):
+        return None
+    try:
+        with open(POSE_SAVE_FILE, "r", encoding="utf-8") as f:
+            recorded_j6_pose = json.load(f)
+        T_j6 = pose_to_homogeneous_matrix(recorded_j6_pose)
+        T_j6_to_camera = quat_pose_to_homogeneous_matrix(J6_TO_CAMERA)
+        T_result = np.matmul(T_j6, T_j6_to_camera).astype(np.float32)
+        return T_result
+    except Exception as e:
+        print(f"[T_result] 加载 J6 位姿失败: {e}，将使用 fallback 矩阵")
+        return None
+
+
+def init_robot_and_gripper():
+    """
+    初始化机械臂与夹爪（与 heihei 一致）。失败时返回 (None, None)，主程序可仅做视觉。
+    """
+    try:
+        from pyAgxArm import create_agx_arm_config, AgxArmFactory
+
+        cfg = create_agx_arm_config(
+            robot=ROBOT_TYPE,
+            comm="can",
+            channel=CAN_CHANNEL,
+            bitrate=1000000,
+            auto_connect=True,
+        )
+        robot = AgxArmFactory.create_arm(cfg)
+        end_effector = robot.init_effector(robot.OPTIONS.EFFECTOR.AGX_GRIPPER)
+        robot.connect(start_read_thread=True)
+        time.sleep(0.5)
+        if not robot.is_ok():
+            raise ConnectionError("机械臂通信异常")
+        if not end_effector.is_ok():
+            raise ConnectionError("夹爪通信异常")
+        robot.set_tcp_offset(TCP_OFFSET)
+        # 使能
+        for _ in range(1000):
+            if robot.enable(joint_index=255):
+                break
+            time.sleep(0.01)
+        else:
+            raise TimeoutError("关节使能超时")
+        robot.set_speed_percent(SPEED_PERCENT)
+        robot.set_motion_mode(robot.OPTIONS.MOTION_MODE.P)
+        print("[Robot] 机械臂与夹爪初始化完成")
+        return robot, end_effector
+    except Exception as e:
+        print(f"[Robot] 初始化失败（将仅做视觉，不控制机械臂）: {e}")
+        return None, None
+
+
+def compute_grasp_from_pca_aabb(pts_base, gripper_max_opening=0.1):
+    """
+    参考 demo.hpp / AABBGraspPlanner：3D PCA → 主轴系 AABB → 最短边作为夹持方向(Z) → 调整坐标系 →
+    Z 轴朝“远离原点”的方向（与 C++ 实现一致）。
+    输入点云应为滤波后、基座系下的点云；返回 (center, R_grasp) 或 None。
+    """
+    pts = np.asarray(pts_base, dtype=np.float64)
+    if pts.shape[0] < 4:
+        return None
+    # 1) 中心点（对应 pcl::compute3DCentroid）
+    pca_centroid = np.mean(pts, axis=0)
+    # 2) 协方差矩阵（PCL 归一化：除以 n-1）
+    centered = pts - pca_centroid
+    covariance = (centered.T @ centered) / max(centered.shape[0] - 1, 1)
+    # 3) 特征值、特征向量（对应 Eigen::SelfAdjointEigenSolver）
+    eigen_values, eigen_vectors = np.linalg.eigh(covariance)
+    # 4) 确保特征向量构成右手坐标系（与 demo 完全一致）
+    ev = eigen_vectors
+    ev = ev.copy()
+    ev[:, 2] = np.cross(ev[:, 0], ev[:, 1])
+    ev[:, 1] = np.cross(ev[:, 2], ev[:, 0])
+    ev[:, 0] = np.cross(ev[:, 1], ev[:, 2])
+    for i in range(3):
+        n = np.linalg.norm(ev[:, i])
+        if n > 1e-10:
+            ev[:, i] = ev[:, i] / n
+    # 5) 按特征值降序排列特征向量（demo: indices 使 eigenValuesPCA(indices[j]) > eigenValuesPCA(indices[i]) 则 swap）
+    indices = np.argsort(eigen_values)[::-1]
+    sorted_eigen_vectors = ev[:, indices].copy()
+    # 6) 确保右手系（行列式为正）
+    if np.linalg.det(sorted_eigen_vectors) < 0:
+        sorted_eigen_vectors[:, 2] = -sorted_eigen_vectors[:, 2]
+    # 7) 变换矩阵：tm 的 3x3 = R^T，平移 = -R^T @ centroid；local = R^T @ (p - centroid)
+    R = sorted_eigen_vectors
+    local_pts = (R.T @ (pts - pca_centroid).T).T
+    # 8) 变换后点云的 AABB（对应 getMinMax3D）
+    min_pt = np.min(local_pts, axis=0)
+    max_pt = np.max(local_pts, axis=0)
+    aabb_length_x = float(max_pt[0] - min_pt[0])
+    aabb_width_y = float(max_pt[1] - min_pt[1])
+    aabb_height_z = float(max_pt[2] - min_pt[2])
+    # 9) 最短边作为夹持方向
+    min_dimension = min(aabb_length_x, aabb_width_y, aabb_height_z)
+    if min_dimension > gripper_max_opening:
+        return None
+    if min_dimension == aabb_length_x:
+        grasp_axis = 0
+    elif min_dimension == aabb_width_y:
+        grasp_axis = 1
+    else:
+        grasp_axis = 2
+    # 10) AABB 中心转回世界系（tm_inv 的 3x3 = R，平移 = centroid）
+    aabb_center_local = (min_pt + max_pt) * 0.5
+    aabb_center_global = R @ aabb_center_local + pca_centroid
+    center = np.array(aabb_center_global, dtype=np.float32)
+    # 11) 抓取方向 = tm_inv 的 3x3 = R（列为主方向）
+    rotation_matrix = R.copy()
+    # 12) 根据夹持方向调整坐标系：机械爪夹持方向为 Z（与 demo 一致）
+    if grasp_axis == 0:
+        # 新 Z = 原 X（夹持），新 X = 原 Y，新 Y = 原 Z
+        adjusted = np.column_stack([
+            rotation_matrix[:, 1],
+            rotation_matrix[:, 2],
+            rotation_matrix[:, 0],
+        ])
+        rotation_matrix = adjusted
+    elif grasp_axis == 1:
+        # 新 Z = 原 Y（夹持），新 X = 原 Z，新 Y = 原 X
+        adjusted = np.column_stack([
+            rotation_matrix[:, 2],
+            rotation_matrix[:, 0],
+            rotation_matrix[:, 1],
+        ])
+        rotation_matrix = adjusted
+    # grasp_axis == 2 不调整
+    # 13) 确保 Z 轴“远离原点”方向（与 demo.hpp 一致）
+    z_axis = rotation_matrix[:, 2]
+    position_vector = center.astype(np.float64)
+    norm_pos = np.linalg.norm(position_vector)
+    if norm_pos > 1e-8:
+        dot_product = float(z_axis.dot(position_vector / norm_pos))
+        if dot_product < 0.0:
+            rotation_matrix[:, 2] = -rotation_matrix[:, 2]
+            rotation_matrix[:, 0] = -rotation_matrix[:, 0]
+    # 14) 正交化（demo 中 determinant 偏离 1 时用 QR 修正）
+    det = np.linalg.det(rotation_matrix)
+    if abs(det - 1.0) > 0.1:
+        Q, _ = np.linalg.qr(rotation_matrix)
+        rotation_matrix = Q.copy()
+        if np.linalg.det(rotation_matrix) < 0:
+            rotation_matrix[:, 2] = -rotation_matrix[:, 2]
+    R_grasp = np.array(rotation_matrix, dtype=np.float32)
+    return center, R_grasp
+
+
+def align_grasp_x_toward_base(R_grasp, T_cam_to_base):
+    """
+    调整抓取姿态旋转矩阵，使 x 轴朝向 base_link 一侧。
+    T_cam_to_base: 4x4 齐次矩阵，将点从 camera_color_optical_frame 变换到 base_link。
+    若当前 x 轴背向 base，则翻转 x、y 以保持右手系。
+    """
+    T_base_to_cam = np.linalg.inv(np.asarray(T_cam_to_base, dtype=np.float64))
+    base_origin_in_cam = T_base_to_cam[:3, 3]
+    n = np.linalg.norm(base_origin_in_cam)
+    if n < 1e-6:
+        return np.asarray(R_grasp, dtype=np.float32)
+    dir_to_base = base_origin_in_cam / n
+    R = np.asarray(R_grasp, dtype=np.float64).copy()
+    if np.dot(R[:, 0], dir_to_base) < 0.0:
+        R[:, 0] = -R[:, 0]
+        R[:, 1] = -R[:, 1]  # 保持右手系
+    return R.astype(np.float32)
+
+
+def save_pose_to_file(j6_pose):
+    """将 J6 法兰位姿保存到 POSE_SAVE_FILE"""
+    try:
+        with open(POSE_SAVE_FILE, "w", encoding="utf-8") as f:
+            json.dump(j6_pose, f, indent=4)
+        print(f"[Robot] J6 法兰位姿已保存: {POSE_SAVE_FILE}")
+    except Exception as e:
+        print(f"[Robot] 保存位姿失败: {e}")
+
+
+def safe_shutdown_robot(robot, end_effector):
+    """安全失能机械臂与夹爪"""
+    if robot is not None:
+        try:
+            robot.disable(joint_index=255)
+            print("[Robot] 机械臂已失能")
+        except Exception:
+            pass
+    if end_effector is not None:
+        try:
+            end_effector.disable_gripper()
+            print("[Robot] 夹爪已失能")
+        except Exception:
+            pass
+
+def sam_results_to_masklet_outputs(results, img_h, img_w):
+    """
+    将 SAM3 的结果格式转换为 visualization_utils.render_masklet_frame 所需格式。
+    results 需要包含:
+      - "scores": list[Tensor]
+      - "boxes":  list[Tensor]，XYXY 像素坐标
+      - "masks":  list[Tensor]，形状 [1, H, W]
+    """
+    outputs = {
+        "out_boxes_xywh": [],
+        "out_probs": [],
+        "out_obj_ids": [],
+        "out_binary_masks": [],
+    }
+
+    num_objs = len(results.get("scores", []))
+    for i in range(num_objs):
+        score = results["scores"][i].item()
+        box_xyxy = results["boxes"][i].cpu().numpy()
+        x1, y1, x2, y2 = box_xyxy
+
+        # 归一化 XYWH
+        x = x1 / img_w
+        y = y1 / img_h
+        w = (x2 - x1) / img_w
+        h = (y2 - y1) / img_h
+
+        mask_tensor = results["masks"][i].squeeze(0).cpu()
+        mask_np = mask_tensor.numpy()
+        # 如果是概率图，简单阈值为 0.5
+        if mask_np.dtype != np.bool_:
+            mask_np = mask_np > 0.5
+
+        outputs["out_boxes_xywh"].append([x, y, w, h])
+        outputs["out_probs"].append(score)
+        outputs["out_obj_ids"].append(i)
+        outputs["out_binary_masks"].append(mask_np.astype(np.uint8))
+
+    return outputs
+
+
+def sam_worker(
+    input_q: mp.Queue,
+    output_q: mp.Queue,
+    prompt_q: mp.Queue,
+    initial_prompt: str = "person",
+):
+    """
+    子进程：专门跑 SAM3 推理（在 GPU 上），避免与 RealSense 的 C++/CUDA 冲突。
+    """
+    import torch
+    from sam3 import build_sam3_image_model
+    from sam3.model.sam3_image_processor import Sam3Processor
+    from sam3.visualization_utils import render_masklet_frame
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    print(f"[SAM Worker] 使用设备: {device}")
+
+    checkpoint_path = (
+        "/home/agilex/.cache/modelscope/hub/models/facebook/sam3/sam3.pt"
+    )
+    print(f"[SAM Worker] 加载 SAM3 模型: {checkpoint_path}")
+    model = build_sam3_image_model(
+        device=device,
+        checkpoint_path=checkpoint_path,
+        load_from_HF=False,
+    )
+    processor = Sam3Processor(model, confidence_threshold=0.5)
+    print("[SAM Worker] 模型加载完成，开始等待图像帧...")
+
+    current_prompt = initial_prompt
+    print(f"[SAM Worker] 初始文本提示: '{current_prompt}'")
+
+    with torch.no_grad():
+        while True:
+            frame_rgb = input_q.get()
+            if frame_rgb is None:
+                print("[SAM Worker] 收到退出信号，结束进程。")
+                break
+
+            if not isinstance(frame_rgb, np.ndarray):
+                continue
+
+            # 无阻塞检查是否有新的 prompt
+            try:
+                while True:
+                    new_prompt = prompt_q.get_nowait()
+                    if isinstance(new_prompt, str) and new_prompt.strip():
+                        current_prompt = new_prompt.strip()
+                        print(f"[SAM Worker] 更新文本提示: '{current_prompt}'")
+            except queue.Empty:
+                pass
+
+            h, w = frame_rgb.shape[:2]
+            pil_image = PILImage.fromarray(frame_rgb)
+
+            try:
+                state = processor.set_image(pil_image)
+                processor.reset_all_prompts(state)
+                state = processor.set_text_prompt(state=state, prompt=current_prompt)
+
+                sam_outputs = sam_results_to_masklet_outputs(
+                    state, img_h=h, img_w=w
+                )
+                overlay_rgb = render_masklet_frame(
+                    frame_rgb, sam_outputs, frame_idx=None, alpha=0.5
+                )
+
+                # 为每个目标分别保留掩码，便于单独生成点云和 AABB/OBB
+                per_object_masks = []
+                for m in sam_outputs["out_binary_masks"]:
+                    if m.shape[0] != h or m.shape[1] != w:
+                        m = cv2.resize(
+                            m.astype(np.uint8),
+                            (w, h),
+                            interpolation=cv2.INTER_NEAREST,
+                        )
+                    per_object_masks.append(m.astype(np.uint8))
+
+                # 队列满就丢弃旧结果，只保留最新的
+                try:
+                    while True:
+                        output_q.get_nowait()
+                except queue.Empty:
+                    pass
+                output_q.put_nowait(
+                    {
+                        "overlay": overlay_rgb,
+                        "masks": per_object_masks,
+                        "ids": sam_outputs["out_obj_ids"],
+                    }
+                )
+            except Exception as e:
+                print(f"[SAM Worker] 推理异常: {e}")
+
+
+class RealSenseAlignAdvanced:
+    def __init__(
+        self,
+        text_prompt: str,
+        sam_input_q: mp.Queue,
+        sam_output_q: mp.Queue,
+        prompt_q: mp.Queue,
+        robot=None,
+        end_effector=None,
+        node=None,
+        tf_broadcaster=None,
+        auto_mode=False,
+    ):
+        # 机械臂（可选）：None 时仅视觉，不下发抓取
+        self.robot = robot
+        self.end_effector = end_effector
+        # ROS2 TF 发布（可选）
+        self._node = node
+        self._tf_broadcaster = tf_broadcaster
+        self._T_j6_to_camera = quat_pose_to_homogeneous_matrix(J6_TO_CAMERA)
+        # RealSense TF：camera_link -> camera_color_optical_frame 及其逆
+        self._T_camlink_to_optical = quat_pose_to_homogeneous_matrix(
+            T_CAMLINK_TO_COLOR_OPTICAL
+        )
+        self._T_optical_to_camlink = np.linalg.inv(self._T_camlink_to_optical)
+        # 相机在基座系下：优先用 J6×J6_TO_CAMERA，无文件则用 fallback
+        self.T_result = load_T_result_from_saved_j6()
+        if self.T_result is None:
+            self.T_result = T_BASE_CAM_FALLBACK.copy()
+            print("[T_result] 使用 fallback 矩阵，建议在 heihei 中按 D 记录位姿并保存")
+        else:
+            print("[T_result] 已从 J6 位姿文件加载并计算 T_result")
+        # 按 p 计算出的最佳抓取姿态（基座系 4x4），按 g 时下发
+        self.best_grasp_T = None
+        # 主臂/普通模式及记录的 J6 位姿（A/D/S/X 与 heihei 一致）
+        self.is_master_mode = False
+        self.recorded_j6_pose = None
+        if os.path.exists(POSE_SAVE_FILE):
+            try:
+                with open(POSE_SAVE_FILE, "r", encoding="utf-8") as f:
+                    self.recorded_j6_pose = json.load(f)
+            except Exception:
+                pass
+
+        # 深度裁剪参数（用于去背景）
+        self.depth_clipping_distance = 1.0  # 默认裁剪距离（米）
+        self.running = False
+        # 自动化模式（--auto）：状态机 self._auto_state，时间戳 self._auto_state_ts
+        self.auto_mode = bool(auto_mode)
+        self._auto_state = 0  # 0=等SAM就绪 1=X 2=q 3=p 4=delay2s 5=g 6=e 7=x 8=s 9=退出
+        self._auto_state_ts = 0.0
+        self._auto_p_retries = 0
+
+        # 点云与抓取可视化发布（基于 /camera/camera/aligned_depth_to_color/image_raw，坐标系为 camera_color_optical_frame）
+        if _ROS_AVAILABLE and self._node is not None:
+            self._pcd_pub = self._node.create_publisher(
+                PointCloud2, "sam3_grasp_cloud", 1
+            )
+            self._aabb_marker_pub = self._node.create_publisher(
+                Marker, "sam3_aabb_marker", 1
+            )
+            self._grasp_axes_pub = self._node.create_publisher(
+                Marker, "sam3_grasp_axes", 1
+            )
+            self._grasp_pose_pub = self._node.create_publisher(
+                PoseStamped, "sam3_grasp_pose", 1
+            )
+            self._marker_array_pub = self._node.create_publisher(
+                MarkerArray, "sam3_aabb_marker_array", 1
+            )
+        else:
+            self._pcd_pub = None
+            self._marker_array_pub = None
+
+        # OpenCV窗口配置
+        self.window_name = "RealSense + SAM3 Realtime"
+        cv2.namedWindow(self.window_name, cv2.WINDOW_NORMAL)
+        cv2.resizeWindow(self.window_name, 1280, 720)
+        # 创建滑块控制裁剪距离（0~6米，步长0.01）
+        cv2.createTrackbar(
+            "Depth Clip (m)", self.window_name, 100, 600, self.on_trackbar_change
+        )
+
+        # SAM3 推理相关（通过子进程通信）
+        self.text_prompt = text_prompt
+        self.sam_input_q = sam_input_q
+        self.sam_output_q = sam_output_q
+        self.prompt_q = prompt_q
+        self.last_overlay_bgr = None
+        # SAM3 掩码与 ID（按目标分别保存，便于单独点云/AABB 处理）
+        self.last_masks = None  # list[np.ndarray]
+        self.last_obj_ids = None  # list[int]
+
+        # 相机内参（首次帧时初始化，用于点云反投影）
+        self.fx = None
+        self.fy = None
+        self.cx = None
+        self.cy = None
+        # 帧计数器（仅用于调试打印，不影响功能）
+        self.frame_counter = 0
+
+        # ROS 相机订阅（使用 RealSense 对齐后的深度图与对应的相机内参）
+        self.bridge = CvBridge() if _ROS_AVAILABLE and self._node is not None else None
+        self._latest_color = None  # BGR8, np.ndarray[h,w,3]
+        self._latest_depth = None  # uint16, 对齐到彩色，np.ndarray[h,w]
+        self._have_cam_info = False
+
+        if _ROS_AVAILABLE and self._node is not None and self.bridge is not None:
+            # 颜色图
+            self._color_sub = self._node.create_subscription(
+                Image,
+                "/camera/camera/color/image_raw",
+                self._color_cb,
+                10,
+            )
+            # 已对齐到彩色的深度图
+            self._depth_sub = self._node.create_subscription(
+                Image,
+                "/camera/camera/aligned_depth_to_color/image_raw",
+                self._depth_cb,
+                10,
+            )
+            # 对齐深度图的相机内参（/camera/camera/aligned_depth_to_color/camera_info）
+            self._caminfo_sub = self._node.create_subscription(
+                CameraInfo,
+                "/camera/camera/aligned_depth_to_color/camera_info",
+                self._caminfo_cb,
+                10,
+            )
+
+    def _color_cb(self, msg: Image):
+        if self.bridge is None:
+            return
+        try:
+            # RealSense ROS 默认编码为 rgb8/bgr8，这里统一转成 BGR，便于 OpenCV 使用
+            cv_image = self.bridge.imgmsg_to_cv2(msg, desired_encoding="bgr8")
+            self._latest_color = cv_image
+        except Exception as e:
+            print(f"[ROS Camera] 颜色图转换失败: {e}")
+
+    def _depth_cb(self, msg: Image):
+        if self.bridge is None:
+            return
+        try:
+            # 深度图通常为 16UC1（单位 mm），保留为 uint16，在主循环中乘以 DEPTH_SCALE_ROS 得到米
+            depth = self.bridge.imgmsg_to_cv2(msg, desired_encoding="passthrough")
+            self._latest_depth = depth
+        except Exception as e:
+            print(f"[ROS Camera] 深度图转换失败: {e}")
+
+    def _caminfo_cb(self, msg: CameraInfo):
+        # 只在首次收到时初始化内参
+        if self._have_cam_info:
+            return
+        # msg.k 是长度为 9 的数组，不能直接在 if 中作为布尔判定
+        if len(msg.k) == 9:
+            self.fx = float(msg.k[0])
+            self.fy = float(msg.k[4])
+            self.cx = float(msg.k[2])
+            self.cy = float(msg.k[5])
+            self._have_cam_info = True
+            print(
+                f"[Intrinsics] fx={self.fx:.2f}, fy={self.fy:.2f}, cx={self.cx:.2f}, cy={self.cy:.2f} (from ROS CameraInfo)"
+            )
+
+    def _publish_tf(self):
+        """发布参与坐标变换的 ROS TF：base_link -> piper_j6_flange -> camera，以及 base_link -> grasp_target（若有）."""
+        if not _ROS_AVAILABLE or self._node is None or self._tf_broadcaster is None:
+            return
+        stamp = self._node.get_clock().now().to_msg()
+        # 当前 J6 位姿：有机械臂则实时读取，否则用记录的位姿
+        j6_pose = None
+        if self.robot is not None and not self.is_master_mode:
+            fp = self.robot.get_flange_pose()
+            if fp is not None and len(fp.msg) >= 6:
+                j6_pose = list(fp.msg)
+        if j6_pose is None and self.recorded_j6_pose is not None:
+            j6_pose = self.recorded_j6_pose
+        if j6_pose is not None:
+            t_j6 = TransformStamped()
+            t_j6.header.stamp = stamp
+            t_j6.header.frame_id = TF_FRAME_BASE
+            t_j6.child_frame_id = TF_FRAME_J6_FLANGE
+            t_j6.transform.translation.x = float(j6_pose[0])
+            t_j6.transform.translation.y = float(j6_pose[1])
+            t_j6.transform.translation.z = float(j6_pose[2])
+            R = euler_to_rotation_matrix(j6_pose[3], j6_pose[4], j6_pose[5])
+            qx, qy, qz, qw = rotation_matrix_to_quaternion(R)
+            t_j6.transform.rotation.x = qx
+            t_j6.transform.rotation.y = qy
+            t_j6.transform.rotation.z = qz
+            t_j6.transform.rotation.w = qw
+            self._tf_broadcaster.sendTransform(t_j6)
+        # 固定：piper_j6_flange -> camera_link
+        # 已标定外参为：piper_j6_flange -> camera_color_optical_frame（J6_TO_CAMERA）
+        # RealSense 自身发布：camera_link -> camera_color_optical_frame（T_CAMLINK_TO_COLOR_OPTICAL）
+        # 这里发布的是：piper_j6_flange -> camera_link = (piper_j6_flange -> optical) * (optical -> camera_link)
+        Tc = self._T_j6_to_camera @ self._T_optical_to_camlink
+        tc = TransformStamped()
+        tc.header.stamp = stamp
+        tc.header.frame_id = TF_FRAME_J6_FLANGE
+        tc.child_frame_id = TF_FRAME_CAMERA
+        tc.transform.translation.x = float(Tc[0, 3])
+        tc.transform.translation.y = float(Tc[1, 3])
+        tc.transform.translation.z = float(Tc[2, 3])
+        qx, qy, qz, qw = rotation_matrix_to_quaternion(Tc[:3, :3])
+        tc.transform.rotation.x = qx
+        tc.transform.rotation.y = qy
+        tc.transform.rotation.z = qz
+        tc.transform.rotation.w = qw
+        self._tf_broadcaster.sendTransform(tc)
+        # 若有最佳抓取姿态：base_link -> grasp_target
+        if self.best_grasp_T is not None:
+            tg = TransformStamped()
+            tg.header.stamp = stamp
+            tg.header.frame_id = TF_FRAME_BASE
+            tg.child_frame_id = TF_FRAME_GRASP_TARGET
+            tg.transform.translation.x = float(self.best_grasp_T[0, 3])
+            tg.transform.translation.y = float(self.best_grasp_T[1, 3])
+            tg.transform.translation.z = float(self.best_grasp_T[2, 3])
+            qx, qy, qz, qw = rotation_matrix_to_quaternion(self.best_grasp_T[:3, :3])
+            tg.transform.rotation.x = qx
+            tg.transform.rotation.y = qy
+            tg.transform.rotation.z = qz
+            tg.transform.rotation.w = qw
+            self._tf_broadcaster.sendTransform(tg)
+
+    def _publish_aabb_marker(self, min_pt, max_pt, R_obb, center_obb, frame_id):
+        """在 RViz 中可视化 AABB/OBB 盒（用 CUBE marker 表示）。"""
+        if not _ROS_AVAILABLE or self._node is None or self._aabb_marker_pub is None:
+            return
+        stamp = self._node.get_clock().now().to_msg()
+        marker = Marker()
+        marker.header.stamp = stamp
+        marker.header.frame_id = frame_id
+        marker.ns = "sam3_aabb"
+        marker.id = 0
+        marker.type = Marker.CUBE
+        marker.action = Marker.ADD
+
+        marker.pose.position.x = float(center_obb[0])
+        marker.pose.position.y = float(center_obb[1])
+        marker.pose.position.z = float(center_obb[2])
+        qx, qy, qz, qw = rotation_matrix_to_quaternion(R_obb)
+        marker.pose.orientation.x = qx
+        marker.pose.orientation.y = qy
+        marker.pose.orientation.z = qz
+        marker.pose.orientation.w = qw
+
+        marker.scale.x = float(max_pt[0] - min_pt[0])
+        marker.scale.y = float(max_pt[1] - min_pt[1])
+        marker.scale.z = float(max_pt[2] - min_pt[2])
+        marker.color.r = 1.0
+        marker.color.g = 0.0
+        marker.color.b = 0.0
+        marker.color.a = 0.4
+        marker.lifetime = BuiltinDuration(sec=0, nanosec=0)  # 0 = 常驻不自动删除
+        self._aabb_marker_pub.publish(marker)
+
+    def _make_aabb_marker(self, min_pt, max_pt, R_obb, center_obb, frame_id, marker_id=0):
+        """构造 AABB CUBE Marker（用于加入 MarkerArray），不发布。"""
+        if not _ROS_AVAILABLE or self._node is None:
+            return None
+        stamp = self._node.get_clock().now().to_msg()
+        marker = Marker()
+        marker.header.stamp = stamp
+        marker.header.frame_id = frame_id
+        marker.ns = "sam3_aabb"
+        marker.id = int(marker_id)
+        marker.type = Marker.CUBE
+        marker.action = Marker.ADD
+        marker.pose.position.x = float(center_obb[0])
+        marker.pose.position.y = float(center_obb[1])
+        marker.pose.position.z = float(center_obb[2])
+        qx, qy, qz, qw = rotation_matrix_to_quaternion(R_obb)
+        marker.pose.orientation.x = qx
+        marker.pose.orientation.y = qy
+        marker.pose.orientation.z = qz
+        marker.pose.orientation.w = qw
+        marker.scale.x = float(max_pt[0] - min_pt[0])
+        marker.scale.y = float(max_pt[1] - min_pt[1])
+        marker.scale.z = float(max_pt[2] - min_pt[2])
+        marker.color.r = 1.0
+        marker.color.g = 0.0
+        marker.color.b = 0.0
+        marker.color.a = 0.4
+        marker.lifetime = BuiltinDuration(sec=0, nanosec=0)
+        return marker
+
+    def _publish_grasp_pose_markers(self, center, R_grasp, frame_id):
+        """发布抓取姿态：PoseStamped + 轴线 Marker，供 RViz 可视化。"""
+        if not _ROS_AVAILABLE or self._node is None:
+            return
+        stamp = self._node.get_clock().now().to_msg()
+
+        # PoseStamped
+        if self._grasp_pose_pub is not None:
+            pose_msg = PoseStamped()
+            pose_msg.header.stamp = stamp
+            pose_msg.header.frame_id = frame_id
+            pose_msg.pose.position.x = float(center[0])
+            pose_msg.pose.position.y = float(center[1])
+            pose_msg.pose.position.z = float(center[2])
+            qx, qy, qz, qw = rotation_matrix_to_quaternion(R_grasp)
+            pose_msg.pose.orientation.x = qx
+            pose_msg.pose.orientation.y = qy
+            pose_msg.pose.orientation.z = qz
+            pose_msg.pose.orientation.w = qw
+            self._grasp_pose_pub.publish(pose_msg)
+
+        # 轴线 Marker（LINE_LIST）
+        if self._grasp_axes_pub is not None:
+            marker = Marker()
+            marker.header.stamp = stamp
+            marker.header.frame_id = frame_id
+            marker.ns = "sam3_grasp_axes"
+            marker.id = 0
+            marker.type = Marker.LINE_LIST
+            marker.action = Marker.ADD
+
+            marker.pose.position.x = float(center[0])
+            marker.pose.position.y = float(center[1])
+            marker.pose.position.z = float(center[2])
+            qx, qy, qz, qw = rotation_matrix_to_quaternion(R_grasp)
+            marker.pose.orientation.x = qx
+            marker.pose.orientation.y = qy
+            marker.pose.orientation.z = qz
+            marker.pose.orientation.w = qw
+
+            marker.scale.x = 0.005  # 线宽
+            axis_len = 0.1
+
+            # 定义局部坐标下的三条轴
+            from geometry_msgs.msg import Point as GeoPoint  # local alias
+
+            def p(x, y, z):
+                pt = GeoPoint()
+                pt.x = float(x)
+                pt.y = float(y)
+                pt.z = float(z)
+                return pt
+
+            x_start, x_end = p(0, 0, 0), p(axis_len, 0, 0)
+            y_start, y_end = p(0, 0, 0), p(0, axis_len, 0)
+            z_start, z_end = p(0, 0, 0), p(0, 0, axis_len)
+
+            marker.points = [x_start, x_end, y_start, y_end, z_start, z_end]
+
+            from std_msgs.msg import ColorRGBA
+
+            xr = ColorRGBA(r=1.0, g=0.0, b=0.0, a=1.0)
+            yr = ColorRGBA(r=0.0, g=1.0, b=0.0, a=1.0)
+            zr = ColorRGBA(r=0.0, g=0.0, b=1.0, a=1.0)
+            marker.colors = [xr, xr, yr, yr, zr, zr]
+            marker.lifetime = BuiltinDuration(sec=0, nanosec=0)  # 常驻
+            self._grasp_axes_pub.publish(marker)
+
+    def _make_grasp_axes_marker(self, center, R_grasp, frame_id, marker_id=0):
+        """构造抓取轴线 LINE_LIST Marker（用于加入 MarkerArray），不发布。"""
+        if not _ROS_AVAILABLE or self._node is None:
+            return None
+        from geometry_msgs.msg import Point as GeoPoint
+        from std_msgs.msg import ColorRGBA
+        stamp = self._node.get_clock().now().to_msg()
+        marker = Marker()
+        marker.header.stamp = stamp
+        marker.header.frame_id = frame_id
+        marker.ns = "sam3_grasp_axes"
+        marker.id = int(marker_id)
+        marker.type = Marker.LINE_LIST
+        marker.action = Marker.ADD
+        marker.pose.position.x = float(center[0])
+        marker.pose.position.y = float(center[1])
+        marker.pose.position.z = float(center[2])
+        qx, qy, qz, qw = rotation_matrix_to_quaternion(R_grasp)
+        marker.pose.orientation.x = qx
+        marker.pose.orientation.y = qy
+        marker.pose.orientation.z = qz
+        marker.pose.orientation.w = qw
+        marker.scale.x = 0.005
+        axis_len = 0.1
+        def p(x, y, z):
+            pt = GeoPoint()
+            pt.x = float(x)
+            pt.y = float(y)
+            pt.z = float(z)
+            return pt
+        marker.points = [p(0, 0, 0), p(axis_len, 0, 0), p(0, 0, 0), p(0, axis_len, 0), p(0, 0, 0), p(0, 0, axis_len)]
+        marker.colors = [
+            ColorRGBA(r=1.0, g=0.0, b=0.0, a=1.0), ColorRGBA(r=1.0, g=0.0, b=0.0, a=1.0),
+            ColorRGBA(r=0.0, g=1.0, b=0.0, a=1.0), ColorRGBA(r=0.0, g=1.0, b=0.0, a=1.0),
+            ColorRGBA(r=0.0, g=0.0, b=1.0, a=1.0), ColorRGBA(r=0.0, g=0.0, b=1.0, a=1.0),
+        ]
+        marker.lifetime = BuiltinDuration(sec=0, nanosec=0)
+        return marker
+
+    def remove_background(self, color_image, depth_image_m, clipping_dist):
+        """基于深度距离移除背景，输入为 numpy 数组形式的彩色图和以米为单位的深度图。"""
+        if color_image is None or depth_image_m is None:
+            return None, None
+
+        original_color_image = color_image.copy()
+        bg_removed_color_image = color_image.copy()
+
+        pixels_distance = depth_image_m
+        background_mask = (pixels_distance <= 0) | (pixels_distance > clipping_dist)
+        bg_removed_color_image[background_mask] = [0x99, 0x99, 0x99]
+
+        return bg_removed_color_image, original_color_image
+
+    def on_trackbar_change(self, value):
+        """滑块回调函数，转换为米（value/100）"""
+        self.depth_clipping_distance = value / 100.0
+
+    def _enable_robot_joints(self):
+        """使能所有关节（带超时）"""
+        if self.robot is None:
+            return False
+        start_t = time.monotonic()
+        while time.monotonic() - start_t < 10.0:
+            if self.robot.enable(joint_index=255):
+                return True
+            time.sleep(0.01)
+        return False
+
+    def _switch_to_master_mode(self):
+        """A：切换到主臂零力拖动模式"""
+        if self.robot is None:
+            print("[Robot] 未连接机械臂")
+            return
+        if self.is_master_mode:
+            print("[Robot] 已处于主臂模式")
+            return
+        self.robot.disable(joint_index=255)
+        time.sleep(0.2)
+        self.robot.set_master_mode()
+        time.sleep(1)
+        self.is_master_mode = True
+        print("[Robot] 已切换到主臂模式（零力拖动）")
+
+    def _switch_to_normal_mode_and_record(self):
+        """D：切换到普通模式并记录当前位姿，更新 T_result 与 recorded_j6_pose"""
+        if self.robot is None:
+            print("[Robot] 未连接机械臂")
+            return
+        if self.is_master_mode:
+            self.robot.reset()
+            time.sleep(0.5)
+            self.robot.set_slave_mode()
+            time.sleep(0.5)
+            if not self._enable_robot_joints():
+                print("[Robot] 使能失败")
+                return
+            self.robot.set_speed_percent(SPEED_PERCENT)
+            self.robot.set_motion_mode(self.robot.OPTIONS.MOTION_MODE.P)
+            self.is_master_mode = False
+            print("[Robot] 已切换到普通模式")
+        my_flange_pose_msg = self.robot.get_flange_pose()
+        print("my_flange_pose_msg:", my_flange_pose_msg)
+        self.recorded_j6_pose = my_flange_pose_msg.msg
+        save_pose_to_file(self.recorded_j6_pose)
+        print("[Robot] 位姿已记录并保存，J6:", [round(p, 4) for p in self.recorded_j6_pose])
+        T_j6 = pose_to_homogeneous_matrix(self.recorded_j6_pose)
+        T_j6_to_camera = quat_pose_to_homogeneous_matrix(J6_TO_CAMERA)
+        self.T_result = np.matmul(T_j6, T_j6_to_camera).astype(np.float32)
+        print("[Robot] T_result 已更新（相机在基座系下）")
+
+    def _move_to_home(self):
+        """S：机械臂回零"""
+        if self.robot is None:
+            print("[Robot] 未连接机械臂")
+            return
+        if self.is_master_mode:
+            print("[Robot] 主臂模式下无法回零，请先按 D 切换普通模式")
+            return
+        print("[Robot] 回零中...")
+        self.robot.move_j([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
+        start_t = time.monotonic()
+        while time.monotonic() - start_t < MOTION_TIMEOUT:
+            st = self.robot.get_arm_status()
+            if st and st.msg.motion_status == 0:
+                print("[Robot] 回零完成")
+                return
+            time.sleep(0.1)
+        print("[Robot] 回零超时")
+
+    def _restore_recorded_pose(self):
+        """X：复现记录的 J6 法兰位姿"""
+        if self.robot is None:
+            print("[Robot] 未连接机械臂")
+            return
+        if self.is_master_mode:
+            print("[Robot] 主臂模式下无法复现，请先按 D 切换普通模式")
+            return
+        if self.recorded_j6_pose is None:
+            print("[Robot] 未记录位姿，请先按 D 记录")
+            return
+        print("[Robot] 复现 J6 位姿...")
+        self.robot.move_p(self.recorded_j6_pose)
+        start_t = time.monotonic()
+        while time.monotonic() - start_t < MOTION_TIMEOUT:
+            st = self.robot.get_arm_status()
+            if st and st.msg.motion_status == 0:
+                print("[Robot] 位姿复现完成")
+                return
+            time.sleep(0.1)
+        print("[Robot] 复现超时")
+
+    def _gripper_max(self):
+        """Q：夹爪开到最大"""
+        if self.end_effector is None:
+            print("[Robot] 未连接夹爪")
+            return
+        try:
+            self.end_effector.move_gripper(width=GRIPPER_MAX_WIDTH, force=GRIPPER_FORCE)
+            time.sleep(1.0)
+            print(f"[Robot] 夹爪已开到最大 ({GRIPPER_MAX_WIDTH*100}cm)")
+        except Exception as e:
+            print(f"[Robot] 夹爪控制失败: {e}")
+
+    def _gripper_min(self):
+        """E：夹爪闭合到最小"""
+        if self.end_effector is None:
+            print("[Robot] 未连接夹爪")
+            return
+        try:
+            self.end_effector.move_gripper(width=GRIPPER_MIN_WIDTH, force=GRIPPER_FORCE)
+            time.sleep(1.0)
+            print("[Robot] 夹爪已闭合")
+        except Exception as e:
+            print(f"[Robot] 夹爪控制失败: {e}")
+
+    def _compute_grasp_from_current_frame(self, original_color_image):
+        """
+        基于当前帧（original_color_image + self._latest_depth + self.last_masks）计算点云与抓取姿态。
+        设置 self.best_grasp_T，发布 AABB/抓取 Marker；返回 (是否检测到有效目标, all_pts, all_cols)。
+        """
+        if (
+            self._latest_depth is None
+            or self.last_masks is None
+            or self.last_obj_ids is None
+            or self.fx is None
+            or self.fy is None
+        ):
+            return False, [], []
+        depth_raw = self._latest_depth.copy()
+        h_d, w_d = depth_raw.shape
+        depth_m = depth_raw.astype(np.float32) * float(DEPTH_SCALE_ROS)
+        color_rgb = cv2.cvtColor(original_color_image, cv2.COLOR_BGR2RGB)
+        best_grasp_score = -1.0
+        best_grasp_T_cam = None
+        all_pts = []
+        all_cols = []
+        aabb_markers = []
+        grasp_markers = []
+        for idx, mask_arr in enumerate(self.last_masks):
+            if idx >= len(self.last_obj_ids):
+                break
+            mask = mask_arr
+            if mask.shape != depth_raw.shape:
+                mask = cv2.resize(
+                    mask.astype(np.uint8),
+                    (w_d, h_d),
+                    interpolation=cv2.INTER_NEAREST,
+                )
+            mask = mask.astype(bool)
+            valid = (depth_m > 0.0) & mask
+            ys, xs = np.where(valid)
+            if ys.size == 0:
+                continue
+            z_cam = depth_m[ys, xs]
+            x_cam = (
+                (xs.astype(np.float32) - float(self.cx)) * z_cam / float(self.fx)
+            )
+            y_cam = (
+                (ys.astype(np.float32) - float(self.cy)) * z_cam / float(self.fy)
+            )
+            pts_cam = np.stack([x_cam, y_cam, z_cam], axis=1)
+            cols = color_rgb[ys, xs].astype(np.float32) / 255.0
+            pcd_raw = o3d.geometry.PointCloud()
+            pcd_raw.points = o3d.utility.Vector3dVector(pts_cam)
+            pcd_raw.colors = o3d.utility.Vector3dVector(cols)
+            pcd_down = pcd_raw.voxel_down_sample(voxel_size=0.005)
+            if len(pcd_down.points) > 0:
+                pcd_denoised, _ = pcd_down.remove_statistical_outlier(
+                    nb_neighbors=20, std_ratio=2.0
+                )
+            else:
+                pcd_denoised = pcd_raw
+            pcd_show = pcd_denoised if len(pcd_denoised.points) > 0 else pcd_raw
+            all_pts.append(np.asarray(pcd_show.points, dtype=np.float32))
+            all_cols.append(np.asarray(pcd_show.colors, dtype=np.float32))
+            obb = pcd_show.get_oriented_bounding_box()
+            center_obb = obb.center
+            R_obb = obb.R
+            pts_for_grasp = np.asarray(pcd_show.points, dtype=np.float64)
+            result = compute_grasp_from_pca_aabb(
+                pts_for_grasp, gripper_max_opening=float(GRIPPER_MAX_WIDTH)
+            )
+            if result is None:
+                continue
+            center, R_grasp = result
+            R_grasp = align_grasp_x_toward_base(R_grasp, self.T_result)
+            T_grasp_cam = np.eye(4, dtype=np.float32)
+            T_grasp_cam[:3, :3] = R_grasp
+            T_grasp_cam[:3, 3] = center
+            dist = np.linalg.norm(center)
+            score = 1.0 / (1.0 + dist)
+            if score > best_grasp_score:
+                best_grasp_score = score
+                best_grasp_T_cam = T_grasp_cam
+            min_b = np.asarray(obb.get_min_bound(), dtype=np.float64)
+            max_b = np.asarray(obb.get_max_bound(), dtype=np.float64)
+            try:
+                self._publish_aabb_marker(
+                    min_b, max_b, R_obb, center_obb, CAMERA_OPTICAL_FRAME
+                )
+                self._publish_grasp_pose_markers(
+                    center, R_grasp, CAMERA_OPTICAL_FRAME
+                )
+                if _ROS_AVAILABLE and getattr(self, "_marker_array_pub", None):
+                    m_aabb = self._make_aabb_marker(
+                        min_b, max_b, R_obb, center_obb,
+                        CAMERA_OPTICAL_FRAME, len(aabb_markers)
+                    )
+                    m_grasp = self._make_grasp_axes_marker(
+                        center, R_grasp, CAMERA_OPTICAL_FRAME,
+                        len(aabb_markers) + len(grasp_markers)
+                    )
+                    if m_aabb is not None:
+                        aabb_markers.append(m_aabb)
+                    if m_grasp is not None:
+                        grasp_markers.append(m_grasp)
+            except Exception:
+                pass
+        if _ROS_AVAILABLE and getattr(self, "_marker_array_pub", None) and (aabb_markers or grasp_markers):
+            arr = MarkerArray()
+            arr.markers = aabb_markers + grasp_markers
+            self._marker_array_pub.publish(arr)
+        if best_grasp_T_cam is not None:
+            T_grasp_cam_h = np.eye(4, dtype=np.float32)
+            T_grasp_cam_h[:3, :3] = best_grasp_T_cam[:3, :3]
+            T_grasp_cam_h[:3, 3] = best_grasp_T_cam[:3, 3]
+            T_grasp_base = (self.T_result @ T_grasp_cam_h).astype(np.float32)
+            self.best_grasp_T = T_grasp_base
+            print(
+                "[GRASP] 选中的最佳抓取姿态（基座坐标系下 4x4 齐次矩阵）:\n",
+                self.best_grasp_T,
+            )
+        else:
+            self.best_grasp_T = None
+        return self.best_grasp_T is not None, all_pts, all_cols
+
+    def _do_grasp_move(self):
+        """执行 g 功能：下发当前最佳抓取姿态并等待机械臂到达。"""
+        if self.robot is None:
+            print("[GRASP] 未连接机械臂，无法下发抓取姿态")
+            return
+        if self.best_grasp_T is None:
+            print("[GRASP] 无抓取姿态，请先执行 p 计算")
+            return
+        T_tcp = self.best_grasp_T
+        T_tcp_to_flange = np.eye(4, dtype=np.float32)
+        T_tcp_to_flange[2, 3] = -float(TCP_OFFSET[2])
+        T_flange = (T_tcp @ T_tcp_to_flange).astype(np.float32)
+        pose_flange = homogeneous_to_pose(T_flange)
+        print("[GRASP] 下发抓取姿态（法兰位姿）:", [round(p, 4) for p in pose_flange])
+        try:
+            self.robot.move_p(pose_flange)
+            start_t = time.monotonic()
+            while True:
+                arm_status = self.robot.get_arm_status()
+                if arm_status and arm_status.msg.motion_status == 0:
+                    print("[GRASP] 机械臂已到达目标位姿")
+                    break
+                if time.monotonic() - start_t > MOTION_TIMEOUT:
+                    print("[GRASP] 运动超时")
+                    break
+                time.sleep(0.1)
+        except Exception as e:
+            print(f"[GRASP] 下发失败: {e}")
+
+    def run(self):
+        """主运行函数：RealSense 采集 + SAM3 实时推理"""
+        try:
+            self.running = True
+
+            with torch.no_grad():
+                while self.running:
+                    self.frame_counter += 1
+                    if cv2.getWindowProperty(self.window_name, cv2.WND_PROP_VISIBLE) < 1:
+                        break
+                    # 有机械臂且非主臂模式时，用当前 J6 位姿更新 T_result（相机在基座系下）
+                    if self.robot is not None and not self.is_master_mode:
+                        fp = self.robot.get_flange_pose()
+                        if fp is not None and len(fp.msg) >= 6:
+                            T_j6 = pose_to_homogeneous_matrix(fp.msg)
+                            self.T_result = (T_j6 @ self._T_j6_to_camera).astype(np.float32)
+                    if _ROS_AVAILABLE and self._node is not None:
+                        rclpy.spin_once(self._node, timeout_sec=0)
+                    # 有机械臂且非主臂模式时，用当前 J6 位姿更新 T_result（相机在基座系下）
+                    if self.robot is not None and not self.is_master_mode:
+                        fp = self.robot.get_flange_pose()
+                        if fp is not None and len(fp.msg) >= 6:
+                            T_j6 = pose_to_homogeneous_matrix(fp.msg)
+                            self.T_result = (T_j6 @ self._T_j6_to_camera).astype(np.float32)
+                    self._publish_tf()
+
+                    # 等待 ROS 相机话题（颜色图 + 对齐深度图）准备就绪
+                    if self._latest_color is None or self._latest_depth is None:
+                        continue
+                    color_image = self._latest_color.copy()
+                    depth_raw = self._latest_depth.copy()
+
+                    # 相机内参应从 CameraInfo 话题获取，若尚未获取则暂不处理
+                    if (
+                        self.fx is None
+                        or self.fy is None
+                        or self.cx is None
+                        or self.cy is None
+                    ):
+                        continue
+
+                    # depth_raw: uint16, 单位 mm -> 转为 m
+                    depth_m = depth_raw.astype(np.float32) * float(DEPTH_SCALE_ROS)
+
+                    color_image_bg_removed, original_color_image = self.remove_background(
+                        color_image,
+                        depth_m,
+                        self.depth_clipping_distance,
+                    )
+
+                    # 可视化深度伪彩色图
+                    depth_norm = depth_m / max(self.depth_clipping_distance, 1e-3)
+                    depth_norm = np.clip(depth_norm, 0.0, 1.0)
+                    depth_colormap = cv2.applyColorMap(
+                        (depth_norm * 255.0).astype(np.uint8), cv2.COLORMAP_JET
+                    )
+
+                    h, w = color_image_bg_removed.shape[:2]
+                    pip_w, pip_h = int(w / 5), int(h / 5)
+                    margin = int(max(w, h) / 25)
+
+                    # ===== SAM3 实时推理（通过子进程）=====
+                    rgb_for_sam = cv2.cvtColor(original_color_image, cv2.COLOR_BGR2RGB)
+
+                    # 往子进程发送当前帧（队列满则跳过，避免阻塞）
+                    if not self.sam_input_q.full():
+                        try:
+                            self.sam_input_q.put_nowait(rgb_for_sam)
+                        except queue.Full:
+                            pass
+
+                    # 尝试从子进程获取最新的分割结果与掩码（如无新结果则继续使用上一帧）
+                    try:
+                        while True:
+                            data = self.sam_output_q.get_nowait()
+                            self.last_overlay_bgr = cv2.cvtColor(
+                                data["overlay"], cv2.COLOR_RGB2BGR
+                            )
+                            self.last_masks = data.get("masks", None)
+                            self.last_obj_ids = data.get("ids", None)
+                    except queue.Empty:
+                        pass
+
+                    # ===== 组合深度/RGB 画中画 =====
+                    # 主画面：去背景后的彩色图
+                    final_display_image = color_image_bg_removed.copy()
+
+                    # 深度图画中画（右上角）
+                    depth_pip = cv2.resize(depth_colormap, (pip_w, pip_h))
+                    depth_pip_x = w - pip_w - margin
+                    depth_pip_y = margin
+                    final_display_image[
+                        depth_pip_y : depth_pip_y + pip_h,
+                        depth_pip_x : depth_pip_x + pip_w,
+                    ] = depth_pip
+
+                    # 原始 RGB 画中画（右下角）
+                    rgb_pip = cv2.resize(original_color_image, (pip_w, pip_h))
+                    rgb_pip_x = w - pip_w - margin
+                    rgb_pip_y = h - pip_h - margin
+                    final_display_image[
+                        rgb_pip_y : rgb_pip_y + pip_h,
+                        rgb_pip_x : rgb_pip_x + pip_w,
+                    ] = rgb_pip
+
+                    # SAM3 分割结果画中画（左上角），如果已有结果
+                    if self.last_overlay_bgr is not None:
+                        sam_pip = cv2.resize(self.last_overlay_bgr, (pip_w, pip_h))
+                        sam_pip_x = margin
+                        sam_pip_y = margin
+                        final_display_image[
+                            sam_pip_y : sam_pip_y + pip_h,
+                            sam_pip_x : sam_pip_x + pip_w,
+                        ] = sam_pip
+
+                    # 文字提示
+                    cv2.putText(
+                        final_display_image,
+                        f"Depth Clip: {self.depth_clipping_distance:.2f}m",
+                        (10, 30),
+                        cv2.FONT_HERSHEY_SIMPLEX,
+                        1,
+                        (0, 255, 0),
+                        2,
+                    )
+                    cv2.putText(
+                        final_display_image,
+                        f"SAM3 Text Prompt: '{self.text_prompt}'",
+                        (10, 65),
+                        cv2.FONT_HERSHEY_SIMPLEX,
+                        0.7,
+                        (0, 255, 255),
+                        2,
+                    )
+                    cv2.putText(
+                        final_display_image,
+                        "Depth",
+                        (depth_pip_x + 5, depth_pip_y + 20),
+                        cv2.FONT_HERSHEY_SIMPLEX,
+                        0.5,
+                        (255, 255, 255),
+                        1,
+                    )
+                    cv2.putText(
+                        final_display_image,
+                        "RGB",
+                        (rgb_pip_x + 5, rgb_pip_y + 20),
+                        cv2.FONT_HERSHEY_SIMPLEX,
+                        0.5,
+                        (255, 255, 255),
+                        1,
+                    )
+                    if self.last_overlay_bgr is not None:
+                        cv2.putText(
+                            final_display_image,
+                            "SAM3",
+                            (margin + 5, margin + 20),
+                            cv2.FONT_HERSHEY_SIMPLEX,
+                            0.5,
+                            (255, 255, 255),
+                            1,
+                        )
+
+                    cv2.imshow(self.window_name, final_display_image)
+
+                    # ---------- 自动化模式（--auto）状态机 ----------
+                    if self.auto_mode:
+                        now = time.monotonic()
+                        sam_ready = (
+                            self.last_masks is not None
+                            and self.last_obj_ids is not None
+                            and self.fx is not None
+                            and self._latest_depth is not None
+                        )
+                        if self._auto_state == 0:
+                            if sam_ready:
+                                print("[Auto] SAM3 已就绪，执行 X（复现位姿）")
+                                self._restore_recorded_pose()
+                                self._auto_state_ts = now
+                                self._auto_state = 1
+                        elif self._auto_state == 1:
+                            if now - self._auto_state_ts >= 2.0:
+                                print("[Auto] 执行 q（夹爪开）")
+                                self._gripper_max()
+                                self._auto_state_ts = now
+                                self._auto_state = 2
+                        elif self._auto_state == 2:
+                            if now - self._auto_state_ts >= 1.0:
+                                self._auto_p_retries = 0
+                                self._auto_state = 3
+                        elif self._auto_state == 3:
+                            found, all_pts, all_cols = self._compute_grasp_from_current_frame(
+                                original_color_image
+                            )
+                            if found:
+                                if (
+                                    self._pcd_pub is not None
+                                    and len(all_pts) > 0
+                                    and len(all_cols) > 0
+                                ):
+                                    pts_cat = np.concatenate(all_pts, axis=0)
+                                    cols_cat = np.concatenate(all_cols, axis=0)
+                                    stamp = self._node.get_clock().now().to_msg()
+                                    msg = make_pointcloud2(
+                                        pts_cat, cols_cat, CAMERA_OPTICAL_FRAME, stamp
+                                    )
+                                    if msg is not None:
+                                        self._pcd_pub.publish(msg)
+                                print("[Auto] p 检测到有效目标，延迟 2s 后执行 g")
+                                self._auto_state_ts = now
+                                self._auto_state = 4
+                            else:
+                                self._auto_p_retries += 1
+                                if self._auto_p_retries >= 10:
+                                    print("[Auto] p 连续 10 次无有效目标，关闭程序")
+                                    self.running = False
+                                    break
+                        elif self._auto_state == 4:
+                            if now - self._auto_state_ts >= 2.0:
+                                print("[Auto] 执行 g（下发抓取）")
+                                self._do_grasp_move()
+                                self._auto_state_ts = now
+                                self._auto_state = 5
+                        elif self._auto_state == 5:
+                            if now - self._auto_state_ts >= 2.0:
+                                print("[Auto] 执行 e（夹爪合）")
+                                self._gripper_min()
+                                self._auto_state_ts = now
+                                self._auto_state = 6
+                        elif self._auto_state == 6:
+                            if now - self._auto_state_ts >= 1.0:
+                                print("[Auto] 执行 x（复现位姿）")
+                                self._restore_recorded_pose()
+                                self._auto_state_ts = now
+                                self._auto_state = 7
+                        elif self._auto_state == 7:
+                            if now - self._auto_state_ts >= 2.0:
+                                print("[Auto] 执行 s（回零）")
+                                self._move_to_home()
+                                self._auto_state_ts = now
+                                self._auto_state = 8
+                        elif self._auto_state == 8:
+                            if now - self._auto_state_ts >= 2.0:
+                                print("[Auto] 流程结束，退出程序")
+                                self.running = False
+                                break
+                    key = cv2.waitKey(1)
+                    if key & 0xFF == 27:  # ESC 退出
+                        break
+                    key_lower = (key & 0xFF) | 0x20 if key >= 0 else -1  # 小写便于不区分大小写
+                    if key_lower == ord("a"):
+                        self._switch_to_master_mode()
+                    elif key_lower == ord("d"):
+                        self._switch_to_normal_mode_and_record()
+                    elif key_lower == ord("s"):
+                        self._move_to_home()
+                    elif key_lower == ord("x"):
+                        self._restore_recorded_pose()
+                    elif key_lower == ord("q"):
+                        self._gripper_max()
+                    elif key_lower == ord("e"):
+                        self._gripper_min()
+                    # 按 'p' 键：基于当前帧计算点云 + AABB + 抓取姿态，并通过 ROS (RViz) 可视化
+                    if (
+                        key & 0xFF == ord("p")
+                        and self.last_masks is not None
+                        and self.last_obj_ids is not None
+                        and self.fx is not None
+                        and self.fy is not None
+                    ):
+                        if self._latest_depth is None:
+                            print("[PCD] 当前无有效深度帧，无法生成点云")
+                            continue
+                        found, all_pts, all_cols = self._compute_grasp_from_current_frame(
+                            original_color_image
+                        )
+                        if (
+                            self._pcd_pub is not None
+                            and len(all_pts) > 0
+                            and len(all_cols) > 0
+                        ):
+                            pts_cat = np.concatenate(all_pts, axis=0)
+                            cols_cat = np.concatenate(all_cols, axis=0)
+                            stamp = self._node.get_clock().now().to_msg()
+                            msg = make_pointcloud2(
+                                pts_cat, cols_cat, CAMERA_OPTICAL_FRAME, stamp
+                            )
+                            if msg is not None:
+                                self._pcd_pub.publish(msg)
+                    # 按 't' 键：在终端输入新的文本提示词
+                    if key & 0xFF == ord("t"):
+                        try:
+                            new_prompt = input(
+                                "\n请输入新的 SAM3 文本提示（回车确认，留空则忽略）："
+                            ).strip()
+                        except EOFError:
+                            new_prompt = ""
+                        if new_prompt:
+                            self.text_prompt = new_prompt
+                            # 将新提示传递给 SAM 子进程
+                            try:
+                                self.prompt_q.put_nowait(new_prompt)
+                            except queue.Full:
+                                # 丢弃旧的，只保留最新
+                                try:
+                                    while True:
+                                        self.prompt_q.get_nowait()
+                                except queue.Empty:
+                                    pass
+                                self.prompt_q.put_nowait(new_prompt)
+                            print(f"[Main] 已更新文本提示: '{self.text_prompt}'")
+
+                    # 按 'g' 键：下发当前选中的最佳抓取姿态，控制机械臂 TCP 到达
+                    if key & 0xFF == ord("g"):
+                        self._do_grasp_move()
+
+        except Exception as e:
+            print(f"Error: {e}")
+            import traceback
+
+            traceback.print_exc()
+        finally:
+            self.stop()
+
+    def stop(self):
+        """停止并释放资源"""
+        self.running = False
+        try:
+            if hasattr(self, "pipeline") and self.pipeline is not None:
+                self.pipeline.stop()
+        except Exception:
+            pass
+        cv2.destroyAllWindows()
+        print("RealSense pipeline stopped, resources released")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="RealSense + SAM3 实时分割（SAM 在子进程 GPU 上运行），可选机械臂控制"
+    )
+    parser.add_argument(
+        "--prompt",
+        type=str,
+        default="person",
+        help="SAM3 文本提示，例如 'person', 'hand', 'chair' 等",
+    )
+    parser.add_argument(
+        "--auto",
+        action="store_true",
+        help="自动化运行：X→q→p(最多10次)→g→e→x→s 后退出",
+    )
+    parser.add_argument(
+        "--no-camera-launch",
+        action="store_true",
+        help="不自动拉起 RealSense ROS 节点（已手动启动时使用）",
+    )
+    args = parser.parse_args()
+
+    # RealSense ROS2 节点：程序内拉起，退出时关闭（可用 --no-camera-launch 跳过）
+    camera_proc_ref = [None]  # 用列表以便 signal 回调和 finally 共享
+
+    def _camera_exit_handler(signum, frame):
+        stop_camera_launch(camera_proc_ref[0])
+        camera_proc_ref[0] = None
+        sys.exit(128 + (signum if signum < 128 else 0))
+
+    if _ROS_AVAILABLE and not args.no_camera_launch:
+        camera_proc_ref[0] = start_camera_launch()
+        if camera_proc_ref[0] is not None:
+            signal.signal(signal.SIGINT, _camera_exit_handler)
+            signal.signal(signal.SIGTERM, _camera_exit_handler)
+
+    node = None
+    if _ROS_AVAILABLE:
+        rclpy.init(args=None)
+        node = Node("realsense_sam")
+        tf_broadcaster = TransformBroadcaster(node)
+    else:
+        tf_broadcaster = None
+        print("[TF] 未检测到 ROS2，将不发布 TF")
+
+    mp.set_start_method("spawn", force=True)
+    sam_input_q: mp.Queue = mp.Queue(maxsize=2)
+    sam_output_q: mp.Queue = mp.Queue(maxsize=2)
+    prompt_q: mp.Queue = mp.Queue(maxsize=4)
+
+    sam_proc = mp.Process(
+        target=sam_worker,
+        args=(sam_input_q, sam_output_q, prompt_q, args.prompt),
+        daemon=True,
+    )
+    sam_proc.start()
+
+    robot, end_effector = init_robot_and_gripper()
+
+    try:
+        rs_align = RealSenseAlignAdvanced(
+            text_prompt=args.prompt,
+            sam_input_q=sam_input_q,
+            sam_output_q=sam_output_q,
+            prompt_q=prompt_q,
+            robot=robot,
+            end_effector=end_effector,
+            node=node,
+            tf_broadcaster=tf_broadcaster,
+            auto_mode=args.auto,
+        )
+        if args.auto:
+            print("[Auto] 自动化流程已启用：等待 SAM3 就绪后执行 X→q→p(最多10次)→g→e→x→s→退出")
+        else:
+            print(
+                "按键: A=主臂零力  D=普通模式+记录位姿  S=回零  X=复现位姿  Q=夹爪开  E=夹爪合  "
+                "p=点云/抓取  t=改提示词  g=下发抓取  Esc=退出"
+            )
+        rs_align.run()
+    finally:
+        stop_camera_launch(camera_proc_ref[0])
+        camera_proc_ref[0] = None
+        safe_shutdown_robot(robot, end_effector)
+        if node is not None:
+            node.destroy_node()
+        if _ROS_AVAILABLE:
+            rclpy.shutdown()
+        try:
+            sam_input_q.put_nowait(None)
+        except queue.Full:
+            pass
+        sam_proc.join(timeout=5.0)

third_party/GraspGen/sam3/sam3/__init__.py

@@ -0,0 +1,9 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe
+
+from .model_builder import build_sam3_image_model
+
+__version__ = "0.1.0"
+
+__all__ = ["build_sam3_image_model"]

third_party/GraspGen/sam3/sam3/eval/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe

third_party/GraspGen/sam3/sam3/eval/cgf1_eval.py

@@ -0,0 +1,705 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe
+
+import contextlib
+import copy
+import json
+import os
+import time
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import List, Union
+
+import numpy as np
+import pycocotools.mask as maskUtils
+from pycocotools.coco import COCO
+from pycocotools.cocoeval import COCOeval
+from scipy.optimize import linear_sum_assignment
+from tqdm import tqdm
+
+
+@dataclass
+class Metric:
+    name: str
+
+    # whether the metric is computed at the image level or the box level
+    image_level: bool
+
+    # iou threshold (None is used for image level metrics or to indicate averaging over all thresholds in [0.5:0.95])
+    iou_threshold: Union[float, None]
+
+
+CGF1_METRICS = [
+    Metric(name="cgF1", image_level=False, iou_threshold=None),
+    Metric(name="precision", image_level=False, iou_threshold=None),
+    Metric(name="recall", image_level=False, iou_threshold=None),
+    Metric(name="F1", image_level=False, iou_threshold=None),
+    Metric(name="positive_macro_F1", image_level=False, iou_threshold=None),
+    Metric(name="positive_micro_F1", image_level=False, iou_threshold=None),
+    Metric(name="positive_micro_precision", image_level=False, iou_threshold=None),
+    Metric(name="IL_precision", image_level=True, iou_threshold=None),
+    Metric(name="IL_recall", image_level=True, iou_threshold=None),
+    Metric(name="IL_F1", image_level=True, iou_threshold=None),
+    Metric(name="IL_FPR", image_level=True, iou_threshold=None),
+    Metric(name="IL_MCC", image_level=True, iou_threshold=None),
+    Metric(name="cgF1", image_level=False, iou_threshold=0.5),
+    Metric(name="precision", image_level=False, iou_threshold=0.5),
+    Metric(name="recall", image_level=False, iou_threshold=0.5),
+    Metric(name="F1", image_level=False, iou_threshold=0.5),
+    Metric(name="positive_macro_F1", image_level=False, iou_threshold=0.5),
+    Metric(name="positive_micro_F1", image_level=False, iou_threshold=0.5),
+    Metric(name="positive_micro_precision", image_level=False, iou_threshold=0.5),
+    Metric(name="cgF1", image_level=False, iou_threshold=0.75),
+    Metric(name="precision", image_level=False, iou_threshold=0.75),
+    Metric(name="recall", image_level=False, iou_threshold=0.75),
+    Metric(name="F1", image_level=False, iou_threshold=0.75),
+    Metric(name="positive_macro_F1", image_level=False, iou_threshold=0.75),
+    Metric(name="positive_micro_F1", image_level=False, iou_threshold=0.75),
+    Metric(name="positive_micro_precision", image_level=False, iou_threshold=0.75),
+]
+
+
+class COCOCustom(COCO):
+    """COCO class from pycocotools with tiny modifications for speed"""
+
+    def createIndex(self):
+        # create index
+        print("creating index...")
+        anns, cats, imgs = {}, {}, {}
+        imgToAnns, catToImgs = defaultdict(list), defaultdict(list)
+        if "annotations" in self.dataset:
+            for ann in self.dataset["annotations"]:
+                imgToAnns[ann["image_id"]].append(ann)
+                anns[ann["id"]] = ann
+
+        if "images" in self.dataset:
+            # MODIFICATION: do not reload imgs if they are already there
+            if self.imgs:
+                imgs = self.imgs
+            else:
+                for img in self.dataset["images"]:
+                    imgs[img["id"]] = img
+            # END MODIFICATION
+
+        if "categories" in self.dataset:
+            for cat in self.dataset["categories"]:
+                cats[cat["id"]] = cat
+
+        if "annotations" in self.dataset and "categories" in self.dataset:
+            for ann in self.dataset["annotations"]:
+                catToImgs[ann["category_id"]].append(ann["image_id"])
+
+        print("index created!")
+
+        # create class members
+        self.anns = anns
+        self.imgToAnns = imgToAnns
+        self.catToImgs = catToImgs
+        self.imgs = imgs
+        self.cats = cats
+
+    def loadRes(self, resFile):
+        """
+        Load result file and return a result api object.
+        :param   resFile (str)     : file name of result file
+        :return: res (obj)         : result api object
+        """
+        res = COCOCustom()
+        res.dataset["info"] = copy.deepcopy(self.dataset.get("info", {}))
+        # MODIFICATION: no copy
+        # res.dataset['images'] = [img for img in self.dataset['images']]
+        res.dataset["images"] = self.dataset["images"]
+        # END MODIFICATION
+
+        print("Loading and preparing results...")
+        tic = time.time()
+        if type(resFile) == str:
+            with open(resFile) as f:
+                anns = json.load(f)
+        elif type(resFile) == np.ndarray:
+            anns = self.loadNumpyAnnotations(resFile)
+        else:
+            anns = resFile
+        assert type(anns) == list, "results in not an array of objects"
+        annsImgIds = [ann["image_id"] for ann in anns]
+        # MODIFICATION: faster and cached subset check
+        if not hasattr(self, "img_id_set"):
+            self.img_id_set = set(self.getImgIds())
+        assert set(annsImgIds).issubset(self.img_id_set), (
+            "Results do not correspond to current coco set"
+        )
+        # END MODIFICATION
+        if "caption" in anns[0]:
+            imgIds = set([img["id"] for img in res.dataset["images"]]) & set(
+                [ann["image_id"] for ann in anns]
+            )
+            res.dataset["images"] = [
+                img for img in res.dataset["images"] if img["id"] in imgIds
+            ]
+            for id, ann in enumerate(anns):
+                ann["id"] = id + 1
+        elif "bbox" in anns[0] and not anns[0]["bbox"] == []:
+            res.dataset["categories"] = copy.deepcopy(self.dataset["categories"])
+            for id, ann in enumerate(anns):
+                bb = ann["bbox"]
+                x1, x2, y1, y2 = [bb[0], bb[0] + bb[2], bb[1], bb[1] + bb[3]]
+                if not "segmentation" in ann:
+                    ann["segmentation"] = [[x1, y1, x1, y2, x2, y2, x2, y1]]
+                ann["area"] = bb[2] * bb[3]
+                ann["id"] = id + 1
+                ann["iscrowd"] = 0
+        elif "segmentation" in anns[0]:
+            res.dataset["categories"] = copy.deepcopy(self.dataset["categories"])
+            for id, ann in enumerate(anns):
+                # now only support compressed RLE format as segmentation results
+                ann["area"] = maskUtils.area(ann["segmentation"])
+                if not "bbox" in ann:
+                    ann["bbox"] = maskUtils.toBbox(ann["segmentation"])
+                ann["id"] = id + 1
+                ann["iscrowd"] = 0
+        elif "keypoints" in anns[0]:
+            res.dataset["categories"] = copy.deepcopy(self.dataset["categories"])
+            for id, ann in enumerate(anns):
+                s = ann["keypoints"]
+                x = s[0::3]
+                y = s[1::3]
+                x0, x1, y0, y1 = np.min(x), np.max(x), np.min(y), np.max(y)
+                ann["area"] = (x1 - x0) * (y1 - y0)
+                ann["id"] = id + 1
+                ann["bbox"] = [x0, y0, x1 - x0, y1 - y0]
+        print("DONE (t={:0.2f}s)".format(time.time() - tic))
+
+        res.dataset["annotations"] = anns
+        # MODIFICATION: inherit images
+        res.imgs = self.imgs
+        # END MODIFICATION
+        res.createIndex()
+        return res
+
+
+class CGF1Eval(COCOeval):
+    """
+    This evaluator is based upon COCO evaluation, but evaluates the model in a more realistic setting
+    for downstream applications.
+    See SAM3 paper for the details on the CGF1 metric.
+
+    Do not use this evaluator directly. Prefer the CGF1Evaluator wrapper.
+
+    Notes:
+     - This evaluator does not support per-category evaluation (in the way defined by pyCocotools)
+     - In open vocabulary settings, we have different noun-phrases for each image. What we call an "image_id" here is actually an (image, noun-phrase) pair. So in every "image_id" there is only one category, implied by the noun-phrase. Thus we can ignore the usual coco "category" field of the predictions
+    """
+
+    def __init__(
+        self,
+        coco_gt=None,
+        coco_dt=None,
+        iouType="segm",
+        threshold=0.5,
+    ):
+        """
+        Args:
+            coco_gt (COCO): ground truth COCO API
+            coco_dt (COCO): detections COCO API
+            iou_type (str): type of IoU to evaluate
+            threshold (float): threshold for predictions
+        """
+        super().__init__(coco_gt, coco_dt, iouType)
+        self.threshold = threshold
+
+        self.params.useCats = False
+        self.params.areaRng = [[0**2, 1e5**2]]
+        self.params.areaRngLbl = ["all"]
+        self.params.maxDets = [1000000]
+
+    def computeIoU(self, imgId, catId):
+        # Same as the original COCOeval.computeIoU, but without sorting
+        p = self.params
+        if p.useCats:
+            gt = self._gts[imgId, catId]
+            dt = self._dts[imgId, catId]
+        else:
+            gt = [_ for cId in p.catIds for _ in self._gts[imgId, cId]]
+            dt = [_ for cId in p.catIds for _ in self._dts[imgId, cId]]
+        if len(gt) == 0 and len(dt) == 0:
+            return []
+
+        if p.iouType == "segm":
+            g = [g["segmentation"] for g in gt]
+            d = [d["segmentation"] for d in dt]
+        elif p.iouType == "bbox":
+            g = [g["bbox"] for g in gt]
+            d = [d["bbox"] for d in dt]
+        else:
+            raise Exception("unknown iouType for iou computation")
+
+        # compute iou between each dt and gt region
+        iscrowd = [int(o["iscrowd"]) for o in gt]
+        ious = maskUtils.iou(d, g, iscrowd)
+        return ious
+
+    def evaluateImg(self, imgId, catId, aRng, maxDet):
+        """
+        perform evaluation for single category and image
+        :return: dict (single image results)
+        """
+        p = self.params
+        assert not p.useCats, "This evaluator does not support per-category evaluation."
+        assert catId == -1
+        all_gts = [_ for cId in p.catIds for _ in self._gts[imgId, cId]]
+        keep_gt = np.array([not g["ignore"] for g in all_gts], dtype=bool)
+        gt = [g for g in all_gts if not g["ignore"]]
+        all_dts = [_ for cId in p.catIds for _ in self._dts[imgId, cId]]
+        keep_dt = np.array([d["score"] >= self.threshold for d in all_dts], dtype=bool)
+        dt = [d for d in all_dts if d["score"] >= self.threshold]
+        if len(gt) == 0 and len(dt) == 0:
+            # This is a "true negative" case, where there are no GTs and no predictions
+            # The box-level metrics are ill-defined, so we don't add them to this dict
+            return {
+                "image_id": imgId,
+                "IL_TP": 0,
+                "IL_TN": 1,
+                "IL_FP": 0,
+                "IL_FN": 0,
+                "num_dt": len(dt),
+            }
+
+        if len(gt) > 0 and len(dt) == 0:
+            # This is a "false negative" case, where there are GTs but no predictions
+            return {
+                "image_id": imgId,
+                "IL_TP": 0,
+                "IL_TN": 0,
+                "IL_FP": 0,
+                "IL_FN": 1,
+                "TPs": np.zeros((len(p.iouThrs),), dtype=np.int64),
+                "FPs": np.zeros((len(p.iouThrs),), dtype=np.int64),
+                "FNs": np.ones((len(p.iouThrs),), dtype=np.int64) * len(gt),
+                "local_F1s": np.zeros((len(p.iouThrs),), dtype=np.int64),
+                "local_positive_F1s": np.zeros((len(p.iouThrs),), dtype=np.int64),
+                "num_dt": len(dt),
+            }
+
+        # Load pre-computed ious
+        ious = self.ious[(imgId, catId)]
+
+        # compute matching
+        if len(ious) == 0:
+            ious = np.zeros((len(dt), len(gt)))
+        else:
+            ious = ious[keep_dt, :][:, keep_gt]
+        assert ious.shape == (len(dt), len(gt))
+
+        matched_dt, matched_gt = linear_sum_assignment(-ious)
+
+        match_scores = ious[matched_dt, matched_gt]
+
+        TPs, FPs, FNs = [], [], []
+        IL_perfect = []
+        for thresh in p.iouThrs:
+            TP = (match_scores >= thresh).sum()
+            FP = len(dt) - TP
+            FN = len(gt) - TP
+            assert FP >= 0 and FN >= 0, (
+                f"FP: {FP}, FN: {FN}, TP: {TP}, match_scores: {match_scores}, len(dt): {len(dt)}, len(gt): {len(gt)}, ious: {ious}"
+            )
+            TPs.append(TP)
+            FPs.append(FP)
+            FNs.append(FN)
+
+            if FP == FN and FP == 0:
+                IL_perfect.append(1)
+            else:
+                IL_perfect.append(0)
+
+        TPs = np.array(TPs, dtype=np.int64)
+        FPs = np.array(FPs, dtype=np.int64)
+        FNs = np.array(FNs, dtype=np.int64)
+        IL_perfect = np.array(IL_perfect, dtype=np.int64)
+
+        # compute precision recall and F1
+        precision = TPs / (TPs + FPs + 1e-4)
+        assert np.all(precision <= 1)
+        recall = TPs / (TPs + FNs + 1e-4)
+        assert np.all(recall <= 1)
+        F1 = 2 * precision * recall / (precision + recall + 1e-4)
+
+        result = {
+            "image_id": imgId,
+            "TPs": TPs,
+            "FPs": FPs,
+            "FNs": FNs,
+            "local_F1s": F1,
+            "IL_TP": (len(gt) > 0) and (len(dt) > 0),
+            "IL_FP": (len(gt) == 0) and (len(dt) > 0),
+            "IL_TN": (len(gt) == 0) and (len(dt) == 0),
+            "IL_FN": (len(gt) > 0) and (len(dt) == 0),
+            "num_dt": len(dt),
+        }
+        if len(gt) > 0 and len(dt) > 0:
+            result["local_positive_F1s"] = F1
+        return result
+
+    def accumulate(self, p=None):
+        """
+        Accumulate per image evaluation results and store the result in self.eval
+        :param p: input params for evaluation
+        :return: None
+        """
+        if self.evalImgs is None or len(self.evalImgs) == 0:
+            print("Please run evaluate() first")
+        # allows input customized parameters
+        if p is None:
+            p = self.params
+
+        setImgIds = set(p.imgIds)
+
+        # TPs, FPs, FNs
+        TPs = np.zeros((len(p.iouThrs),), dtype=np.int64)
+        FPs = np.zeros((len(p.iouThrs),), dtype=np.int64)
+        pmFPs = np.zeros((len(p.iouThrs),), dtype=np.int64)
+        FNs = np.zeros((len(p.iouThrs),), dtype=np.int64)
+        local_F1s = np.zeros((len(p.iouThrs),), dtype=np.float64)
+
+        # Image level metrics
+        IL_TPs = 0
+        IL_FPs = 0
+        IL_TNs = 0
+        IL_FNs = 0
+
+        valid_img_count = 0
+        valid_F1_count = 0
+        evaledImgIds = set()
+        for res in self.evalImgs:
+            if res["image_id"] not in setImgIds:
+                continue
+            evaledImgIds.add(res["image_id"])
+            IL_TPs += res["IL_TP"]
+            IL_FPs += res["IL_FP"]
+            IL_TNs += res["IL_TN"]
+            IL_FNs += res["IL_FN"]
+
+            if "TPs" not in res:
+                continue
+
+            TPs += res["TPs"]
+            FPs += res["FPs"]
+            FNs += res["FNs"]
+            valid_img_count += 1
+
+            if "local_positive_F1s" in res:
+                local_F1s += res["local_positive_F1s"]
+                pmFPs += res["FPs"]
+                if res["num_dt"] > 0:
+                    valid_F1_count += 1
+
+        assert len(setImgIds - evaledImgIds) == 0, (
+            f"{len(setImgIds - evaledImgIds)} images not evaluated. "
+            f"Here are the IDs of the first 3: {list(setImgIds - evaledImgIds)[:3]}"
+        )
+
+        # compute precision recall and F1
+        precision = TPs / (TPs + FPs + 1e-4)
+        positive_micro_precision = TPs / (TPs + pmFPs + 1e-4)
+        assert np.all(precision <= 1)
+        recall = TPs / (TPs + FNs + 1e-4)
+        assert np.all(recall <= 1)
+        F1 = 2 * precision * recall / (precision + recall + 1e-4)
+        positive_micro_F1 = (
+            2
+            * positive_micro_precision
+            * recall
+            / (positive_micro_precision + recall + 1e-4)
+        )
+
+        IL_rec = IL_TPs / (IL_TPs + IL_FNs + 1e-6)
+        IL_prec = IL_TPs / (IL_TPs + IL_FPs + 1e-6)
+        IL_F1 = 2 * IL_prec * IL_rec / (IL_prec + IL_rec + 1e-6)
+        IL_FPR = IL_FPs / (IL_FPs + IL_TNs + 1e-6)
+        IL_MCC = float(IL_TPs * IL_TNs - IL_FPs * IL_FNs) / (
+            (
+                float(IL_TPs + IL_FPs)
+                * float(IL_TPs + IL_FNs)
+                * float(IL_TNs + IL_FPs)
+                * float(IL_TNs + IL_FNs)
+            )
+            ** 0.5
+            + 1e-6
+        )
+
+        self.eval = {
+            "params": p,
+            "TPs": TPs,
+            "FPs": FPs,
+            "positive_micro_FPs": pmFPs,
+            "FNs": FNs,
+            "precision": precision,
+            "positive_micro_precision": positive_micro_precision,
+            "recall": recall,
+            "F1": F1,
+            "positive_micro_F1": positive_micro_F1,
+            "positive_macro_F1": local_F1s / valid_F1_count,
+            "IL_recall": IL_rec,
+            "IL_precision": IL_prec,
+            "IL_F1": IL_F1,
+            "IL_FPR": IL_FPR,
+            "IL_MCC": IL_MCC,
+        }
+        self.eval["cgF1"] = self.eval["positive_micro_F1"] * self.eval["IL_MCC"]
+
+    def summarize(self):
+        """
+        Compute and display summary metrics for evaluation results.
+        """
+        if not self.eval:
+            raise Exception("Please run accumulate() first")
+
+        def _summarize(iouThr=None, metric=""):
+            p = self.params
+            iStr = " {:<18} @[ IoU={:<9}] = {:0.3f}"
+            titleStr = "Average " + metric
+            iouStr = (
+                "{:0.2f}:{:0.2f}".format(p.iouThrs[0], p.iouThrs[-1])
+                if iouThr is None
+                else "{:0.2f}".format(iouThr)
+            )
+
+            s = self.eval[metric]
+            # IoU
+            if iouThr is not None:
+                t = np.where(iouThr == p.iouThrs)[0]
+                s = s[t]
+
+            if len(s[s > -1]) == 0:
+                mean_s = -1
+            else:
+                mean_s = np.mean(s[s > -1])
+            print(iStr.format(titleStr, iouStr, mean_s))
+            return mean_s
+
+        def _summarize_single(metric=""):
+            titleStr = "Average " + metric
+            iStr = " {:<35} = {:0.3f}"
+            s = self.eval[metric]
+            print(iStr.format(titleStr, s))
+            return s
+
+        def _summarizeDets():
+            stats = []
+
+            for metric in CGF1_METRICS:
+                if metric.image_level:
+                    stats.append(_summarize_single(metric=metric.name))
+                else:
+                    stats.append(
+                        _summarize(iouThr=metric.iou_threshold, metric=metric.name)
+                    )
+            return np.asarray(stats)
+
+        summarize = _summarizeDets
+        self.stats = summarize()
+
+
+def _evaluate(self):
+    """
+    Run per image evaluation on given images and store results (a list of dict) in self.evalImgs
+    """
+    p = self.params
+    # add backward compatibility if useSegm is specified in params
+    p.imgIds = list(np.unique(p.imgIds))
+    p.useCats = False
+    p.maxDets = sorted(p.maxDets)
+    self.params = p
+
+    self._prepare()
+    # loop through images, area range, max detection number
+    catIds = [-1]
+
+    if p.iouType == "segm" or p.iouType == "bbox":
+        computeIoU = self.computeIoU
+    else:
+        raise RuntimeError(f"Unsupported iou {p.iouType}")
+    self.ious = {
+        (imgId, catId): computeIoU(imgId, catId)
+        for imgId in p.imgIds
+        for catId in catIds
+    }
+
+    maxDet = p.maxDets[-1]
+    evalImgs = [
+        self.evaluateImg(imgId, catId, areaRng, maxDet)
+        for catId in catIds
+        for areaRng in p.areaRng
+        for imgId in p.imgIds
+    ]
+    # this is NOT in the pycocotools code, but could be done outside
+    evalImgs = np.asarray(evalImgs).reshape(len(catIds), len(p.areaRng), len(p.imgIds))
+    return p.imgIds, evalImgs
+
+
+class CGF1Evaluator:
+    """
+    Wrapper class for cgF1 evaluation.
+    This supports the oracle setting (when several ground-truths are available per image)
+    """
+
+    def __init__(
+        self,
+        gt_path: Union[str, List[str]],
+        iou_type="segm",
+        verbose=False,
+    ):
+        """
+        Args:
+            gt_path (str or list of str): path(s) to ground truth COCO json file(s)
+            iou_type (str): type of IoU to evaluate
+            threshold (float): threshold for predictions
+        """
+        self.gt_paths = gt_path if isinstance(gt_path, list) else [gt_path]
+        self.iou_type = iou_type
+
+        self.coco_gts = [COCOCustom(gt) for gt in self.gt_paths]
+
+        self.verbose = verbose
+
+        self.coco_evals = []
+        for i, coco_gt in enumerate(self.coco_gts):
+            self.coco_evals.append(
+                CGF1Eval(
+                    coco_gt=coco_gt,
+                    iouType=iou_type,
+                )
+            )
+            self.coco_evals[i].useCats = False
+
+        exclude_img_ids = set()
+        # exclude_img_ids are the ids that are not exhaustively annotated in any of the other gts
+        for coco_gt in self.coco_gts[1:]:
+            exclude_img_ids = exclude_img_ids.union(
+                {
+                    img["id"]
+                    for img in coco_gt.dataset["images"]
+                    if not img["is_instance_exhaustive"]
+                }
+            )
+        # we only eval on instance exhaustive queries
+        self.eval_img_ids = [
+            img["id"]
+            for img in self.coco_gts[0].dataset["images"]
+            if (img["is_instance_exhaustive"] and img["id"] not in exclude_img_ids)
+        ]
+
+    def evaluate(self, pred_file: str):
+        """
+        Evaluate the detections using cgF1 metric.
+
+        Args:
+            pred_file: path to the predictions COCO json file
+
+        """
+        assert len(self.coco_gts) > 0, "No ground truth provided for evaluation."
+        assert len(self.coco_gts) == len(self.coco_evals), (
+            "Mismatch in number of ground truths and evaluators."
+        )
+
+        if self.verbose:
+            print(f"Loading predictions from {pred_file}")
+
+        with open(pred_file, "r") as f:
+            preds = json.load(f)
+
+        if self.verbose:
+            print(f"Loaded {len(preds)} predictions")
+
+        img2preds = defaultdict(list)
+        for pred in preds:
+            img2preds[pred["image_id"]].append(pred)
+
+        all_eval_imgs = []
+        for img_id in tqdm(self.eval_img_ids, disable=not self.verbose):
+            results = img2preds[img_id]
+            all_scorings = []
+            for cur_coco_gt, coco_eval in zip(self.coco_gts, self.coco_evals):
+                # suppress pycocotools prints
+                with open(os.devnull, "w") as devnull:
+                    with contextlib.redirect_stdout(devnull):
+                        coco_dt = (
+                            cur_coco_gt.loadRes(results) if results else COCOCustom()
+                        )
+
+                coco_eval.cocoDt = coco_dt
+                coco_eval.params.imgIds = [img_id]
+                coco_eval.params.useCats = False
+                img_ids, eval_imgs = _evaluate(coco_eval)
+                all_scorings.append(eval_imgs)
+            selected = self._select_best_scoring(all_scorings)
+            all_eval_imgs.append(selected)
+
+        # After this point, we have selected the best scoring per image among several ground truths
+        # we can now accumulate and summarize, using only the first coco_eval
+
+        self.coco_evals[0].evalImgs = list(
+            np.concatenate(all_eval_imgs, axis=2).flatten()
+        )
+        self.coco_evals[0].params.imgIds = self.eval_img_ids
+        self.coco_evals[0]._paramsEval = copy.deepcopy(self.coco_evals[0].params)
+
+        if self.verbose:
+            print(f"Accumulating results")
+        self.coco_evals[0].accumulate()
+        print("cgF1 metric, IoU type={}".format(self.iou_type))
+        self.coco_evals[0].summarize()
+        print()
+
+        out = {}
+        for i, value in enumerate(self.coco_evals[0].stats):
+            name = CGF1_METRICS[i].name
+            if CGF1_METRICS[i].iou_threshold is not None:
+                name = f"{name}@{CGF1_METRICS[i].iou_threshold}"
+            out[f"cgF1_eval_{self.iou_type}_{name}"] = float(value)
+
+        return out
+
+    @staticmethod
+    def _select_best_scoring(scorings):
+        # This function is used for "oracle" type evaluation.
+        # It accepts the evaluation results with respect to several ground truths, and picks the best
+        if len(scorings) == 1:
+            return scorings[0]
+
+        assert scorings[0].ndim == 3, (
+            f"Expecting results in [numCats, numAreas, numImgs] format, got {scorings[0].shape}"
+        )
+        assert scorings[0].shape[0] == 1, (
+            f"Expecting a single category, got {scorings[0].shape[0]}"
+        )
+
+        for scoring in scorings:
+            assert scoring.shape == scorings[0].shape, (
+                f"Shape mismatch: {scoring.shape}, {scorings[0].shape}"
+            )
+
+        selected_imgs = []
+        for img_id in range(scorings[0].shape[-1]):
+            best = scorings[0][:, :, img_id]
+
+            for scoring in scorings[1:]:
+                current = scoring[:, :, img_id]
+                if "local_F1s" in best[0, 0] and "local_F1s" in current[0, 0]:
+                    # we were able to compute a F1 score for this particular image in both evaluations
+                    # best["local_F1s"] contains the results at various IoU thresholds. We simply take the average for comparision
+                    best_score = best[0, 0]["local_F1s"].mean()
+                    current_score = current[0, 0]["local_F1s"].mean()
+                    if current_score > best_score:
+                        best = current
+
+                else:
+                    # If we're here, it means that in that in some evaluation we were not able to get a valid local F1
+                    # This happens when both the predictions and targets are empty. In that case, we can assume it's a perfect prediction
+                    if "local_F1s" not in current[0, 0]:
+                        best = current
+            selected_imgs.append(best)
+        result = np.stack(selected_imgs, axis=-1)
+        assert result.shape == scorings[0].shape
+        return result

third_party/GraspGen/sam3/sam3/eval/coco_eval.py

@@ -0,0 +1,914 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe
+
+"""
+COCO evaluator that works in distributed mode.
+
+Mostly copy-paste from https://github.com/pytorch/vision/blob/edfd5a7/references/detection/coco_eval.py
+The difference is that there is less copy-pasting from pycocotools
+in the end of the file, as python3 can suppress prints with contextlib
+"""
+
+import contextlib
+import copy
+import json
+import logging
+import os
+import pickle
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, List, Optional
+
+import numpy as np
+import pycocotools.mask as mask_utils
+import torch
+from iopath.common.file_io import g_pathmgr
+from pycocotools.coco import COCO
+from pycocotools.cocoeval import COCOeval
+from sam3.train.masks_ops import rle_encode
+from sam3.train.utils.distributed import (
+    all_gather,
+    gather_to_rank_0_via_filesys,
+    get_rank,
+    is_main_process,
+)
+
+RARITY_BUCKETS = {0: "frequent", 1: "common", 2: "medium", 3: "rare"}
+
+
+class CocoEvaluator:
+    def __init__(
+        self,
+        coco_gt,
+        iou_types: List[str],
+        useCats: bool,
+        dump_dir: Optional[str],
+        postprocessor,
+        average_by_rarity=False,
+        metrics_dump_dir: Optional[str] = None,
+        gather_pred_via_filesys=False,
+        use_normalized_areas=True,
+        maxdets=[1, 10, 100],
+        exhaustive_only=False,
+        all_exhaustive_only=True,
+    ):
+        """Online coco evaluator. It will evaluate images as they are generated by the model, then accumulate/summarize at the end
+
+        Args:
+           - coco_gt: COCO api object containing the gt
+           - iou_types: can be either "bbox" or "segm"
+           - useCats: If true, categories will be used for evaluation
+           - dump_dir: if non null, then the predictions will be dumped in that directory
+           - postprocessor: Module to convert the model's output into the coco format
+           - average_by_rarity: if true then we expect the images information in the gt dataset
+                 to have a "rarity" field. Then the AP will be computed on all rarity buckets
+                 individually, then averaged
+           - gather_pred_via_filesys: if true, we use the filesystem for collective gathers
+           - use_normalized_areas: if true, the areas of the objects in the GT are assumed to be
+                 normalized by the area of the image. In that case, the size buckets are adjusted
+           - maxdets: maximal number of detections to be evaluated on each image.
+           - exhaustive_only: If true, we restrict eval only to exhaustive annotations
+           - all_exhaustive_only: If true, datapoints are restricted only to those with all exhaustive annotations
+
+        """
+        # coco_gt = copy.deepcopy(coco_gt)
+        self.coco_gts = [coco_gt] if not isinstance(coco_gt, list) else coco_gt
+        assert len(maxdets) == 3, f"expecting 3 detection threshold, got {len(maxdets)}"
+
+        self.use_normalized_areas = use_normalized_areas
+        self.iou_types = iou_types
+        self.useCats = useCats
+        self.maxdets = maxdets
+        self.dump = None
+        self.dump_dir = dump_dir
+        if self.dump_dir is not None:
+            self.dump = []
+            if is_main_process():
+                if not os.path.exists(self.dump_dir):
+                    os.makedirs(self.dump_dir, exist_ok=True)
+                    logging.info(f"Create the folder: {dump_dir}")
+
+        self.initialized = False
+
+        # Whether to gather predictions through filesystem (instead of torch
+        # collective ops; requiring a shared filesystem across all ranks)
+        self.gather_pred_via_filesys = gather_pred_via_filesys
+        self.use_self_evaluate = True  # CPP version is disabled
+        self.postprocessor = postprocessor
+        self.average_by_rarity = average_by_rarity
+        self.exhaustive_only = exhaustive_only
+        self.all_exhaustive_only = all_exhaustive_only
+        self.metrics_dump_dir = metrics_dump_dir
+        if self.metrics_dump_dir is not None:
+            if is_main_process():
+                if not os.path.exists(self.metrics_dump_dir):
+                    os.makedirs(self.metrics_dump_dir, exist_ok=True)
+                    logging.info(f"Create the folder: {metrics_dump_dir}")
+
+    def _lazy_init(self, coco_cls=COCO):
+        if self.initialized:
+            return
+
+        self.initialized = True
+
+        self.coco_gts = [
+            coco_cls(g_pathmgr.get_local_path(gt)) if isinstance(gt, str) else gt
+            for gt in self.coco_gts
+        ]
+
+        self.reset()
+
+        self.eval_img_ids = None
+
+        if self.exhaustive_only:
+            exclude_img_ids = set()
+            # exclude_img_ids are the ids that are not exhaustively annotated in any of the other gts
+            if self.all_exhaustive_only:
+                for coco_gt in self.coco_gts[1:]:
+                    exclude_img_ids = exclude_img_ids.union(
+                        {
+                            img["id"]
+                            for img in coco_gt.dataset["images"]
+                            if not img["is_instance_exhaustive"]
+                        }
+                    )
+            # we only eval on instance exhaustive queries
+            self.eval_img_ids = [
+                img["id"]
+                for img in self.coco_gts[0].dataset["images"]
+                if (img["is_instance_exhaustive"] and img["id"] not in exclude_img_ids)
+            ]
+
+        self.rarity_buckets = None
+        if self.average_by_rarity:
+            self.rarity_buckets = defaultdict(list)
+            eval_img_ids_set = (
+                set(self.eval_img_ids) if self.eval_img_ids is not None else None
+            )
+            for img in self.coco_gts[0].dataset["images"]:
+                if self.eval_img_ids is not None and img["id"] not in eval_img_ids_set:
+                    continue
+                self.rarity_buckets[img["rarity"]].append(img["id"])
+            print("Rarity buckets sizes:")
+            for k, v in self.rarity_buckets.items():
+                print(f"{k}: {len(v)}")
+
+    def set_sync_device(self, device: torch.device) -> Any:
+        self._sync_device = device
+
+    def _evaluate(self, *args, **kwargs):
+        return evaluate(*args, **kwargs)
+
+    def _loadRes(self, *args, **kwargs):
+        return loadRes(*args, **kwargs)
+
+    def update(self, *args, **kwargs):
+        self._lazy_init()
+        predictions = self.postprocessor.process_results(*args, **kwargs)
+
+        img_ids = list(np.unique(list(predictions.keys())))
+        self.img_ids.extend(img_ids)
+
+        for iou_type in self.iou_types:
+            results = self.prepare(predictions, iou_type)
+            self._dump(results)
+
+            assert len(self.coco_gts) == len(self.coco_evals)
+            all_scorings = []
+            for cur_coco_gt, cur_coco_eval in zip(self.coco_gts, self.coco_evals):
+                # suppress pycocotools prints
+                with open(os.devnull, "w") as devnull:
+                    with contextlib.redirect_stdout(devnull):
+                        coco_dt = (
+                            self._loadRes(cur_coco_gt, results) if results else COCO()
+                        )
+
+                coco_eval = cur_coco_eval[iou_type]
+
+                coco_eval.cocoDt = coco_dt
+                coco_eval.params.imgIds = list(img_ids)
+                coco_eval.params.useCats = self.useCats
+                coco_eval.params.maxDets = self.maxdets
+                img_ids, eval_imgs = self._evaluate(coco_eval, self.use_self_evaluate)
+                all_scorings.append(eval_imgs)
+
+            selected = self.select_best_scoring(all_scorings)
+            self.eval_imgs[iou_type].append(selected)
+
+    def select_best_scoring(self, scorings):
+        # This function is used for "oracle" type evaluation.
+        # It accepts the evaluation results with respect to several ground truths, and picks the best
+        if len(scorings) == 1:
+            return scorings[0]
+
+        # Currently we don't support Oracle Phrase AP.
+        # To implement it, we likely need to modify the cpp code since the eval_image type is opaque
+        raise RuntimeError("Not implemented")
+
+    def _dump(self, results):
+        if self.dump is not None:
+            dumped_results = copy.deepcopy(results)
+            for r in dumped_results:
+                if "bbox" not in self.iou_types and "bbox" in r:
+                    del r["bbox"]
+                elif "bbox" in r:
+                    r["bbox"] = [round(coord, 5) for coord in r["bbox"]]
+                r["score"] = round(r["score"], 5)
+            self.dump.extend(dumped_results)
+
+    def synchronize_between_processes(self):
+        self._lazy_init()
+        logging.info("Coco evaluator: Synchronizing between processes")
+        for iou_type in self.iou_types:
+            if len(self.eval_imgs[iou_type]) > 0:
+                self.eval_imgs[iou_type] = np.concatenate(self.eval_imgs[iou_type], 2)
+            else:
+                num_areas = len(self.coco_evals[0][iou_type].params.areaRng)
+                # assuming 1 class
+                assert not self.useCats
+                self.eval_imgs[iou_type] = np.empty((1, num_areas, 0))
+            create_common_coco_eval(
+                self.coco_evals[0][iou_type],
+                self.img_ids,
+                self.eval_imgs[iou_type],
+                use_self_evaluate=self.use_self_evaluate,
+                gather_pred_via_filesys=self.gather_pred_via_filesys,
+                metrics_dump_dir=self.metrics_dump_dir,
+            )
+        if self.dump is not None:
+            dumped_file = Path(self.dump_dir) / f"coco_predictions_{get_rank()}.json"
+            logging.info(f"COCO evaluator: Dumping local predictions to {dumped_file}")
+            with g_pathmgr.open(str(dumped_file), "w") as f:
+                json.dump(self.dump, f)
+
+            # if self.gather_pred_via_filesys:
+            #     dump = gather_to_rank_0_via_filesys(self.dump)
+            # else:
+            #     dump = all_gather(self.dump, force_cpu=True)
+            # self.dump = sum(dump, [])
+
+    def accumulate(self, imgIds=None):
+        self._lazy_init()
+        logging.info(
+            f"Coco evaluator: Accumulating on {len(imgIds) if imgIds is not None else 'all'} images"
+        )
+        if not is_main_process():
+            return
+
+        if imgIds is None:
+            for coco_eval in self.coco_evals[0].values():
+                accumulate(coco_eval, use_self_eval=self.use_self_evaluate)
+
+        if imgIds is not None:
+            imgIds = set(imgIds)
+            for coco_eval in self.coco_evals[0].values():
+                p = coco_eval.params
+                id_mask = np.array([(i in imgIds) for i in p.imgIds], dtype=bool)
+                old_img_ids = p.imgIds
+                coco_eval.params.imgIds = np.asarray(p.imgIds)[id_mask]
+                old_img_evals = coco_eval.evalImgs
+                catIds = p.catIds if p.useCats else [-1]
+                coco_eval.evalImgs = list(
+                    np.asarray(coco_eval.evalImgs)
+                    .reshape(len(catIds), len(p.areaRng), len(old_img_ids))[
+                        ..., id_mask
+                    ]
+                    .flatten()
+                )
+                accumulate(coco_eval, use_self_eval=self.use_self_evaluate)
+                coco_eval.evalImgs = old_img_evals
+                coco_eval.params.imgIds = old_img_ids
+
+    def summarize(self):
+        self._lazy_init()
+        logging.info("Coco evaluator: Summarizing")
+        if not is_main_process():
+            return {}
+
+        outs = {}
+        if self.rarity_buckets is None:
+            self.accumulate(self.eval_img_ids)
+            for iou_type, coco_eval in self.coco_evals[0].items():
+                print("IoU metric: {}".format(iou_type))
+                summarize(coco_eval)
+
+            if "bbox" in self.coco_evals[0]:
+                for key, value in zip(*self.coco_evals[0]["bbox"].stats):
+                    outs[f"coco_eval_bbox_{key}"] = value
+            if "segm" in self.coco_evals[0]:
+                for key, value in zip(*self.coco_evals[0]["segm"].stats):
+                    outs[f"coco_eval_masks_{key}"] = value
+        else:
+            total_stats = {}
+            all_keys = {}
+            for bucket, img_list in self.rarity_buckets.items():
+                self.accumulate(imgIds=img_list)
+                bucket_name = RARITY_BUCKETS[bucket]
+                for iou_type, coco_eval in self.coco_evals[0].items():
+                    print(f"IoU metric: {iou_type}. Rarity bucket: {bucket_name}")
+                    summarize(coco_eval)
+
+                if "bbox" in self.coco_evals[0]:
+                    if "bbox" not in total_stats:
+                        total_stats["bbox"] = np.zeros_like(
+                            self.coco_evals[0]["bbox"].stats[1]
+                        )
+                        all_keys["bbox"] = self.coco_evals[0]["bbox"].stats[0]
+                    total_stats["bbox"] += self.coco_evals[0]["bbox"].stats[1]
+                    for key, value in zip(*self.coco_evals[0]["bbox"].stats):
+                        outs[f"coco_eval_bbox_{bucket_name}_{key}"] = value
+                if "segm" in self.coco_evals[0]:
+                    if "segm" not in total_stats:
+                        total_stats["segm"] = np.zeros_like(
+                            self.coco_evals[0]["segm"].stats[1]
+                        )
+                        all_keys["segm"] = self.coco_evals[0]["segm"].stats[0]
+                    total_stats["segm"] += self.coco_evals[0]["segm"].stats[1]
+                    for key, value in zip(*self.coco_evals[0]["segm"].stats):
+                        outs[f"coco_eval_masks_{bucket_name}_{key}"] = value
+
+            if "bbox" in total_stats:
+                total_stats["bbox"] /= len(self.rarity_buckets)
+                for key, value in zip(all_keys["bbox"], total_stats["bbox"]):
+                    outs[f"coco_eval_bbox_{key}"] = value
+            if "segm" in total_stats:
+                total_stats["segm"] /= len(self.rarity_buckets)
+                for key, value in zip(all_keys["segm"], total_stats["segm"]):
+                    outs[f"coco_eval_masks_{key}"] = value
+
+        # if self.dump is not None:
+        #     assert self.dump_dir is not None
+        #     logging.info("Coco evaluator: Dumping the global result file to disk")
+        #     with g_pathmgr.open(str(Path(self.dump_dir) / "coco_eval.json"), "w") as f:
+        #         json.dump(self.dump, f)
+        return outs
+
+    def compute_synced(self):
+        self._lazy_init()
+        self.synchronize_between_processes()
+        return self.summarize()
+
+    def compute(self):
+        self._lazy_init()
+        return {"": 0.0}
+
+    def reset(self, cocoeval_cls=COCOeval):
+        self.coco_evals = [{} for _ in range(len(self.coco_gts))]
+        for i, coco_gt in enumerate(self.coco_gts):
+            for iou_type in self.iou_types:
+                self.coco_evals[i][iou_type] = cocoeval_cls(coco_gt, iouType=iou_type)
+                self.coco_evals[i][iou_type].params.useCats = self.useCats
+                self.coco_evals[i][iou_type].params.maxDets = self.maxdets
+                if self.use_normalized_areas:
+                    self.coco_evals[i][iou_type].params.areaRng = [
+                        [0, 1e5],
+                        [0, 0.001],
+                        [0.001, 0.01],
+                        [0.01, 0.1],
+                        [0.1, 0.5],
+                        [0.5, 0.95],
+                        [0.95, 1e5],
+                    ]
+                    self.coco_evals[i][iou_type].params.areaRngLbl = [
+                        "all",
+                        "tiny",
+                        "small",
+                        "medium",
+                        "large",
+                        "huge",
+                        "whole_image",
+                    ]
+
+        self.img_ids = []
+        self.eval_imgs = {k: [] for k in self.iou_types}
+        if self.dump is not None:
+            self.dump = []
+
+    def write(self, stats):
+        self._lazy_init()
+        """Write the results in the stats dict"""
+        if "bbox" in self.coco_evals[0]:
+            stats["coco_eval_bbox"] = self.coco_evals[0]["bbox"].stats.tolist()
+        if "segm" in self.coco_evals[0]:
+            stats["coco_eval_masks"] = self.coco_evals[0]["segm"].stats.tolist()
+        return stats
+
+    def prepare(self, predictions, iou_type):
+        self._lazy_init()
+        if iou_type == "bbox":
+            return self.prepare_for_coco_detection(predictions)
+        elif iou_type == "segm":
+            return self.prepare_for_coco_segmentation(predictions)
+        elif iou_type == "keypoints":
+            return self.prepare_for_coco_keypoint(predictions)
+        else:
+            raise ValueError("Unknown iou type {}".format(iou_type))
+
+    def prepare_for_coco_detection(self, predictions):
+        self._lazy_init()
+        coco_results = []
+        for original_id, prediction in predictions.items():
+            if len(prediction) == 0:
+                continue
+
+            boxes = prediction["boxes"]
+            boxes = convert_to_xywh(boxes).tolist()
+            scores = prediction["scores"].tolist()
+            labels = prediction["labels"].tolist()
+
+            coco_results.extend(
+                [
+                    {
+                        "image_id": original_id,
+                        "category_id": labels[k],
+                        "bbox": box,
+                        "score": scores[k],
+                    }
+                    for k, box in enumerate(boxes)
+                ]
+            )
+        return coco_results
+
+    @torch.no_grad()
+    def prepare_for_coco_segmentation(self, predictions):
+        self._lazy_init()
+        coco_results = []
+        for original_id, prediction in predictions.items():
+            if len(prediction) == 0:
+                continue
+
+            scores = prediction["scores"].tolist()
+            labels = prediction["labels"].tolist()
+            boundaries, dilated_boundaries = None, None
+            if "boundaries" in prediction:
+                boundaries = prediction["boundaries"]
+                dilated_boundaries = prediction["dilated_boundaries"]
+                assert dilated_boundaries is not None
+                assert len(scores) == len(boundaries)
+
+            if "masks_rle" in prediction:
+                rles = prediction["masks_rle"]
+                areas = []
+                for rle in rles:
+                    cur_area = mask_utils.area(rle)
+                    h, w = rle["size"]
+                    areas.append(cur_area / (h * w))
+            else:
+                masks = prediction["masks"]
+
+                masks = masks > 0.5
+                h, w = masks.shape[-2:]
+
+                areas = masks.flatten(1).sum(1) / (h * w)
+                areas = areas.tolist()
+
+                rles = rle_encode(masks.squeeze(1))
+
+                # memory clean
+                del masks
+                del prediction["masks"]
+
+            assert len(areas) == len(rles) == len(scores)
+            for k, rle in enumerate(rles):
+                payload = {
+                    "image_id": original_id,
+                    "category_id": labels[k],
+                    "segmentation": rle,
+                    "score": scores[k],
+                    "area": areas[k],
+                }
+                if boundaries is not None:
+                    payload["boundary"] = boundaries[k]
+                    payload["dilated_boundary"] = dilated_boundaries[k]
+
+                coco_results.append(payload)
+
+        return coco_results
+
+    def prepare_for_coco_keypoint(self, predictions):
+        self._lazy_init()
+        coco_results = []
+        for original_id, prediction in predictions.items():
+            if len(prediction) == 0:
+                continue
+
+            boxes = prediction["boxes"]
+            boxes = convert_to_xywh(boxes).tolist()
+            scores = prediction["scores"].tolist()
+            labels = prediction["labels"].tolist()
+            keypoints = prediction["keypoints"]
+            keypoints = keypoints.flatten(start_dim=1).tolist()
+
+            coco_results.extend(
+                [
+                    {
+                        "image_id": original_id,
+                        "category_id": labels[k],
+                        "keypoints": keypoint,
+                        "score": scores[k],
+                    }
+                    for k, keypoint in enumerate(keypoints)
+                ]
+            )
+        return coco_results
+
+
+def convert_to_xywh(boxes):
+    xmin, ymin, xmax, ymax = boxes.unbind(-1)
+    return torch.stack((xmin, ymin, xmax - xmin, ymax - ymin), dim=-1)
+
+
+def merge(img_ids, eval_imgs, gather_pred_via_filesys=False):
+    if gather_pred_via_filesys:
+        # only gather the predictions to rank 0 (other ranks will receive empty
+        # lists for `all_img_ids` and `all_eval_imgs`, which should be OK as
+        # merging and evaluation are only done on rank 0)
+        all_img_ids = gather_to_rank_0_via_filesys(img_ids)
+        all_eval_imgs = gather_to_rank_0_via_filesys(eval_imgs)
+    else:
+        all_img_ids = all_gather(img_ids, force_cpu=True)
+        all_eval_imgs = all_gather(eval_imgs, force_cpu=True)
+    if not is_main_process():
+        return None, None
+
+    merged_img_ids = []
+    for p in all_img_ids:
+        merged_img_ids.extend(p)
+
+    merged_eval_imgs = []
+    for p in all_eval_imgs:
+        merged_eval_imgs.append(p)
+
+    merged_img_ids = np.array(merged_img_ids)
+    merged_eval_imgs = np.concatenate(merged_eval_imgs, 2)
+
+    # keep only unique (and in sorted order) images
+    merged_img_ids, idx = np.unique(merged_img_ids, return_index=True)
+    merged_eval_imgs = merged_eval_imgs[..., idx]
+
+    return merged_img_ids, merged_eval_imgs
+
+
+def create_common_coco_eval(
+    coco_eval,
+    img_ids,
+    eval_imgs,
+    use_self_evaluate,
+    gather_pred_via_filesys=False,
+    metrics_dump_dir=None,
+):
+    img_ids, eval_imgs = merge(img_ids, eval_imgs, gather_pred_via_filesys)
+    if not is_main_process():
+        return
+    if metrics_dump_dir is not None:
+        dumped_file = (
+            Path(metrics_dump_dir) / f"coco_eval_img_metrics_{get_rank()}.json"
+        )
+        logging.info(f"COCO evaluator: Dumping local predictions to {dumped_file}")
+        with g_pathmgr.open(str(dumped_file), "w") as f:
+            json.dump(eval_imgs.squeeze(), f, default=lambda x: x.tolist())
+    img_ids = list(img_ids)
+
+    # If some images were not predicted, we need to create dummy detections for them
+    missing_img_ids = set(coco_eval.cocoGt.getImgIds()) - set(img_ids)
+    if len(missing_img_ids) > 0:
+        print(f"WARNING: {len(missing_img_ids)} images were not predicted!")
+        coco_eval.cocoDt = COCO()
+        coco_eval.params.imgIds = list(missing_img_ids)
+        new_img_ids, new_eval_imgs = evaluate(coco_eval, use_self_evaluate)
+        img_ids.extend(new_img_ids)
+        eval_imgs = np.concatenate((eval_imgs, new_eval_imgs), axis=2)
+
+    eval_imgs = list(eval_imgs.flatten())
+    assert len(img_ids) == len(coco_eval.cocoGt.getImgIds())
+
+    coco_eval.evalImgs = eval_imgs
+    coco_eval.params.imgIds = img_ids
+    coco_eval._paramsEval = copy.deepcopy(coco_eval.params)
+
+
+#################################################################
+# From pycocotools, just removed the prints and fixed
+# a Python3 bug about unicode not defined
+#################################################################
+
+
+# Copy of COCO prepare, but doesn't convert anntoRLE
+def segmentation_prepare(self):
+    """
+    Prepare ._gts and ._dts for evaluation based on params
+    :return: None
+    """
+    p = self.params
+    if p.useCats:
+        gts = self.cocoGt.loadAnns(
+            self.cocoGt.getAnnIds(imgIds=p.imgIds, catIds=p.catIds)
+        )
+        dts = self.cocoDt.loadAnns(
+            self.cocoDt.getAnnIds(imgIds=p.imgIds, catIds=p.catIds)
+        )
+    else:
+        gts = self.cocoGt.loadAnns(self.cocoGt.getAnnIds(imgIds=p.imgIds))
+        dts = self.cocoDt.loadAnns(self.cocoDt.getAnnIds(imgIds=p.imgIds))
+
+    for gt in gts:
+        gt["ignore"] = gt["ignore"] if "ignore" in gt else 0
+        gt["ignore"] = "iscrowd" in gt and gt["iscrowd"]
+        if p.iouType == "keypoints":
+            gt["ignore"] = (gt["num_keypoints"] == 0) or gt["ignore"]
+    self._gts = defaultdict(list)  # gt for evaluation
+    self._dts = defaultdict(list)  # dt for evaluation
+    for gt in gts:
+        self._gts[gt["image_id"], gt["category_id"]].append(gt)
+    for dt in dts:
+        self._dts[dt["image_id"], dt["category_id"]].append(dt)
+    self.evalImgs = defaultdict(list)  # per-image per-category evaluation results
+    self.eval = {}  # accumulated evaluation results
+
+
+def evaluate(self, use_self_evaluate):
+    """
+    Run per image evaluation on given images and store results (a list of dict) in self.evalImgs
+    :return: None
+    """
+    # tic = time.time()
+    # print('Running per image evaluation...', use_self_evaluate)
+    p = self.params
+    # add backward compatibility if useSegm is specified in params
+    if p.useSegm is not None:
+        p.iouType = "segm" if p.useSegm == 1 else "bbox"
+        print(
+            "useSegm (deprecated) is not None. Running {} evaluation".format(p.iouType)
+        )
+    # print('Evaluate annotation type *{}*'.format(p.iouType))
+    p.imgIds = list(np.unique(p.imgIds))
+    if p.useCats:
+        p.catIds = list(np.unique(p.catIds))
+    p.maxDets = sorted(p.maxDets)
+    self.params = p
+
+    self._prepare()
+    # loop through images, area range, max detection number
+    catIds = p.catIds if p.useCats else [-1]
+
+    if p.iouType == "segm" or p.iouType == "bbox":
+        computeIoU = self.computeIoU
+    elif p.iouType == "keypoints":
+        computeIoU = self.computeOks
+    self.ious = {
+        (imgId, catId): computeIoU(imgId, catId)
+        for imgId in p.imgIds
+        for catId in catIds
+    }
+
+    maxDet = p.maxDets[-1]
+    if use_self_evaluate:
+        evalImgs = [
+            self.evaluateImg(imgId, catId, areaRng, maxDet)
+            for catId in catIds
+            for areaRng in p.areaRng
+            for imgId in p.imgIds
+        ]
+        # this is NOT in the pycocotools code, but could be done outside
+        evalImgs = np.asarray(evalImgs).reshape(
+            len(catIds), len(p.areaRng), len(p.imgIds)
+        )
+        return p.imgIds, evalImgs
+
+    # <<<< Beginning of code differences with original COCO API
+    # def convert_instances_to_cpp(instances, is_det=False):
+    #     # Convert annotations for a list of instances in an image to a format that's fast
+    #     # to access in C++
+    #     instances_cpp = []
+    #     for instance in instances:
+    #         instance_cpp = _CPP.InstanceAnnotation(
+    #             int(instance["id"]),
+    #             instance["score"] if is_det else instance.get("score", 0.0),
+    #             instance["area"],
+    #             bool(instance.get("iscrowd", 0)),
+    #             bool(instance.get("ignore", 0)),
+    #         )
+    #         instances_cpp.append(instance_cpp)
+    #     return instances_cpp
+
+    # # Convert GT annotations, detections, and IOUs to a format that's fast to access in C++
+    # ground_truth_instances = [
+    #     [convert_instances_to_cpp(self._gts[imgId, catId]) for catId in p.catIds]
+    #     for imgId in p.imgIds
+    # ]
+    # detected_instances = [
+    #     [
+    #         convert_instances_to_cpp(self._dts[imgId, catId], is_det=True)
+    #         for catId in p.catIds
+    #     ]
+    #     for imgId in p.imgIds
+    # ]
+    # ious = [[self.ious[imgId, catId] for catId in catIds] for imgId in p.imgIds]
+
+    # if not p.useCats:
+    #     # For each image, flatten per-category lists into a single list
+    #     ground_truth_instances = [
+    #         [[o for c in i for o in c]] for i in ground_truth_instances
+    #     ]
+    #     detected_instances = [[[o for c in i for o in c]] for i in detected_instances]
+
+    # # Call C++ implementation of self.evaluateImgs()
+    # _evalImgs_cpp = _CPP.COCOevalEvaluateImages(
+    #     p.areaRng, maxDet, p.iouThrs, ious, ground_truth_instances, detected_instances
+    # )
+
+    # self._paramsEval = copy.deepcopy(self.params)
+    # evalImgs = np.asarray(_evalImgs_cpp).reshape(
+    #     len(catIds), len(p.areaRng), len(p.imgIds)
+    # )
+    # return p.imgIds, evalImgs
+
+
+#################################################################
+# end of straight copy from pycocotools, just removing the prints
+#################################################################
+
+
+#################################################################
+# From pycocotools, but disabled mask->box conversion which is
+# pointless
+#################################################################
+def loadRes(self, resFile):
+    """
+    Load result file and return a result api object.
+    :param   resFile (str)     : file name of result file
+    :return: res (obj)         : result api object
+    """
+    res = COCO()
+    res.dataset["images"] = [img for img in self.dataset["images"]]
+
+    if type(resFile) == str:
+        anns = json.load(open(resFile))
+    elif type(resFile) == np.ndarray:
+        anns = self.loadNumpyAnnotations(resFile)
+    else:
+        anns = resFile
+    assert type(anns) == list, "results in not an array of objects"
+    annsImgIds = [ann["image_id"] for ann in anns]
+    assert set(annsImgIds) == (set(annsImgIds) & set(self.getImgIds())), (
+        "Results do not correspond to current coco set"
+    )
+    if "caption" in anns[0]:
+        imgIds = set([img["id"] for img in res.dataset["images"]]) & set(
+            [ann["image_id"] for ann in anns]
+        )
+        res.dataset["images"] = [
+            img for img in res.dataset["images"] if img["id"] in imgIds
+        ]
+        for id, ann in enumerate(anns):
+            ann["id"] = id + 1
+    elif "bbox" in anns[0] and not anns[0]["bbox"] == []:
+        res.dataset["categories"] = copy.deepcopy(self.dataset["categories"])
+        for id, ann in enumerate(anns):
+            bb = ann["bbox"]
+            x1, x2, y1, y2 = [bb[0], bb[0] + bb[2], bb[1], bb[1] + bb[3]]
+            if "segmentation" not in ann:
+                ann["segmentation"] = [[x1, y1, x1, y2, x2, y2, x2, y1]]
+            ann["area"] = bb[2] * bb[3]
+            ann["id"] = id + 1
+            ann["iscrowd"] = 0
+    elif "segmentation" in anns[0]:
+        res.dataset["categories"] = copy.deepcopy(self.dataset["categories"])
+        for id, ann in enumerate(anns):
+            # now only support compressed RLE format as segmentation results
+            # ann["area"] = mask_util.area(ann["segmentation"])
+            # The following lines are disabled because they are pointless
+            #  if not 'bbox' in ann:
+            #     ann['bbox'] = maskUtils.toBbox(ann['segmentation'])
+            ann["id"] = id + 1
+            ann["iscrowd"] = 0
+    elif "keypoints" in anns[0]:
+        res.dataset["categories"] = copy.deepcopy(self.dataset["categories"])
+        for id, ann in enumerate(anns):
+            s = ann["keypoints"]
+            x = s[0::3]
+            y = s[1::3]
+            x0, x1, y0, y1 = np.min(x), np.max(x), np.min(y), np.max(y)
+            ann["area"] = (x1 - x0) * (y1 - y0)
+            ann["id"] = id + 1
+            ann["bbox"] = [x0, y0, x1 - x0, y1 - y0]
+
+    res.dataset["annotations"] = anns
+    res.createIndex()
+    return res
+
+
+#################################################################
+# end of straight copy from pycocotools
+#################################################################
+
+
+#################################################################
+# From pycocotools, but added handling of custom area rngs, and returns stat keys
+#################################################################
+def summarize(self):
+    """
+    Compute and display summary metrics for evaluation results.
+    Note this functin can *only* be applied on the default parameter setting
+    """
+
+    def _summarize(ap=1, iouThr=None, areaRng="all", maxDets=100):
+        p = self.params
+        iStr = " {:<18} {} @[ IoU={:<9} | area={:>6s} | maxDets={:>3d} ] = {:0.3f}"
+        titleStr = "Average Precision" if ap == 1 else "Average Recall"
+        typeStr = "(AP)" if ap == 1 else "(AR)"
+        iouStr = (
+            "{:0.2f}:{:0.2f}".format(p.iouThrs[0], p.iouThrs[-1])
+            if iouThr is None
+            else "{:0.2f}".format(iouThr)
+        )
+
+        aind = [i for i, aRng in enumerate(p.areaRngLbl) if aRng == areaRng]
+        mind = [i for i, mDet in enumerate(p.maxDets) if mDet == maxDets]
+        if ap == 1:
+            # dimension of precision: [TxRxKxAxM]
+            s = self.eval["precision"]
+            # IoU
+            if iouThr is not None:
+                t = np.where(iouThr == p.iouThrs)[0]
+                s = s[t]
+            s = s[:, :, :, aind, mind]
+        else:
+            # dimension of recall: [TxKxAxM]
+            s = self.eval["recall"]
+            if iouThr is not None:
+                t = np.where(iouThr == p.iouThrs)[0]
+                s = s[t]
+            s = s[:, :, aind, mind]
+        if len(s[s > -1]) == 0:
+            mean_s = -1
+        else:
+            mean_s = np.mean(s[s > -1])
+        print(iStr.format(titleStr, typeStr, iouStr, areaRng, maxDets, mean_s))
+        return mean_s
+
+    def _summarizeDets():
+        nb_results = 6 + (len(self.params.areaRng) - 1) * 2
+        assert len(self.params.areaRng) == len(self.params.areaRngLbl)
+        stats = np.zeros((nb_results,))
+        keys = ["AP", "AP_50", "AP_75"]
+        stats[0] = _summarize(1, maxDets=self.params.maxDets[2])
+        stats[1] = _summarize(1, iouThr=0.5, maxDets=self.params.maxDets[2])
+        stats[2] = _summarize(1, iouThr=0.75, maxDets=self.params.maxDets[2])
+        cur_id = 3
+        for area in self.params.areaRngLbl[1:]:
+            stats[cur_id] = _summarize(1, areaRng=area, maxDets=self.params.maxDets[2])
+            cur_id += 1
+            keys.append(f"AP_{area}")
+        stats[cur_id] = _summarize(0, maxDets=self.params.maxDets[0])
+        cur_id += 1
+        stats[cur_id] = _summarize(0, maxDets=self.params.maxDets[1])
+        cur_id += 1
+        stats[cur_id] = _summarize(0, maxDets=self.params.maxDets[2])
+        cur_id += 1
+        keys += ["AR", "AR_50", "AR_75"]
+
+        for area in self.params.areaRngLbl[1:]:
+            stats[cur_id] = _summarize(0, areaRng=area, maxDets=self.params.maxDets[2])
+            cur_id += 1
+            keys.append(f"AR_{area}")
+        assert len(stats) == len(keys)
+        return keys, stats
+
+    if not self.eval:
+        raise Exception("Please run accumulate() first")
+    self.stats = _summarizeDets()
+
+
+#################################################################
+# end of straight copy from pycocotools
+#################################################################
+
+
+#################################################################
+# From https://github.com/facebookresearch/detectron2/blob/main/detectron2/evaluation/fast_eval_api.py
+# with slight adjustments
+#################################################################
+def accumulate(self, use_self_eval=False):
+    """
+    Accumulate per image evaluation results and store the result in self.eval.  Does not
+    support changing parameter settings from those used by self.evaluate()
+    """
+    if use_self_eval:
+        self.accumulate()
+        return
+    # CPP code is disabled
+    # self.eval = _CPP.COCOevalAccumulate(self.params, self.evalImgs)
+
+    # # recall is num_iou_thresholds X num_categories X num_area_ranges X num_max_detections
+    # self.eval["recall"] = np.array(self.eval["recall"]).reshape(
+    #     self.eval["counts"][:1] + self.eval["counts"][2:]
+    # )
+
+    # # precision and scores are num_iou_thresholds X num_recall_thresholds X num_categories X
+    # # num_area_ranges X num_max_detections
+    # self.eval["precision"] = np.array(self.eval["precision"]).reshape(
+    #     self.eval["counts"]
+    # )
+    # self.eval["scores"] = np.array(self.eval["scores"]).reshape(self.eval["counts"])

third_party/GraspGen/sam3/sam3/eval/coco_eval_offline.py

@@ -0,0 +1,183 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe
+
+"""
+This evaluator is meant for regular COCO mAP evaluation, for example on the COCO val set.
+
+For Category mAP, we need the model to make predictions for all the categories on every single image.
+In general, since the number of classes can be big, and the API model makes predictions individually for each pair (image, class),
+we may need to split the inference process for a given image in several chunks.
+"""
+
+import logging
+from collections import defaultdict
+
+import torch
+from pycocotools.coco import COCO
+from pycocotools.cocoeval import COCOeval
+from sam3.train.utils.distributed import is_main_process
+
+try:
+    from tidecv import datasets, TIDE
+
+    HAS_TIDE = True
+except ImportError:
+    HAS_TIDE = False
+    print("WARNING: TIDE not installed. Detailed analysis will not be available.")
+
+
+# the COCO detection metrics (https://github.com/cocodataset/cocoapi/blob/8c9bcc3cf640524c4c20a9c40e89cb6a2f2fa0e9/PythonAPI/pycocotools/cocoeval.py#L460-L471)
+COCO_METRICS = [
+    "AP",
+    "AP_50",
+    "AP_75",
+    "AP_small",
+    "AP_medium",
+    "AP_large",
+    "AR_maxDets@1",
+    "AR_maxDets@10",
+    "AR_maxDets@100",
+    "AR_small",
+    "AR_medium",
+    "AR_large",
+]
+
+
+def convert_to_xywh(boxes):
+    """Convert bounding boxes from xyxy format to xywh format."""
+    xmin, ymin, xmax, ymax = boxes.unbind(-1)
+    return torch.stack((xmin, ymin, xmax - xmin, ymax - ymin), dim=-1)
+
+
+class HeapElement:
+    """Utility class to make a heap with a custom comparator"""
+
+    def __init__(self, val):
+        self.val = val
+
+    def __lt__(self, other):
+        return self.val["score"] < other.val["score"]
+
+
+class COCOevalCustom(COCOeval):
+    """
+    This is a slightly modified version of the original COCO API with added support for positive split evaluation.
+    """
+
+    def __init__(
+        self, cocoGt=None, cocoDt=None, iouType="segm", dt_only_positive=False
+    ):
+        super().__init__(cocoGt, cocoDt, iouType)
+        self.dt_only_positive = dt_only_positive
+
+    def _prepare(self):
+        """
+        Prepare ._gts and ._dts for evaluation based on params
+        :return: None
+        """
+
+        def _toMask(anns, coco):
+            # modify ann['segmentation'] by reference
+            for ann in anns:
+                rle = coco.annToRLE(ann)
+                ann["segmentation"] = rle
+
+        p = self.params
+        if p.useCats:
+            gts = self.cocoGt.loadAnns(
+                self.cocoGt.getAnnIds(imgIds=p.imgIds, catIds=p.catIds)
+            )
+            dts = self.cocoDt.loadAnns(
+                self.cocoDt.getAnnIds(imgIds=p.imgIds, catIds=p.catIds)
+            )
+        else:
+            gts = self.cocoGt.loadAnns(self.cocoGt.getAnnIds(imgIds=p.imgIds))
+            dts = self.cocoDt.loadAnns(self.cocoDt.getAnnIds(imgIds=p.imgIds))
+
+        # convert ground truth to mask if iouType == 'segm'
+        if p.iouType == "segm":
+            _toMask(gts, self.cocoGt)
+            _toMask(dts, self.cocoDt)
+        # set ignore flag
+        for gt in gts:
+            gt["ignore"] = gt["ignore"] if "ignore" in gt else 0
+            gt["ignore"] = "iscrowd" in gt and gt["iscrowd"]
+            if p.iouType == "keypoints":
+                gt["ignore"] = (gt["num_keypoints"] == 0) or gt["ignore"]
+        self._gts = defaultdict(list)  # gt for evaluation
+        self._dts = defaultdict(list)  # dt for evaluation
+
+        _gts_cat_ids = defaultdict(set)  # gt for evaluation on positive split
+        for gt in gts:
+            self._gts[gt["image_id"], gt["category_id"]].append(gt)
+            _gts_cat_ids[gt["image_id"]].add(gt["category_id"])
+
+        #### BEGIN MODIFICATION ####
+        for dt in dts:
+            if (
+                self.dt_only_positive
+                and dt["category_id"] not in _gts_cat_ids[dt["image_id"]]
+            ):
+                continue
+            self._dts[dt["image_id"], dt["category_id"]].append(dt)
+        #### END MODIFICATION ####
+        self.evalImgs = defaultdict(list)  # per-image per-category evaluation results
+        self.eval = {}  # accumulated evaluation results
+
+
+class CocoEvaluatorOfflineWithPredFileEvaluators:
+    def __init__(
+        self,
+        gt_path,
+        tide: bool = True,
+        iou_type: str = "bbox",
+        positive_split=False,
+    ):
+        self.gt_path = gt_path
+        self.tide_enabled = HAS_TIDE and tide
+        self.positive_split = positive_split
+        self.iou_type = iou_type
+
+    def evaluate(self, dumped_file):
+        if not is_main_process():
+            return {}
+
+        logging.info("OfflineCoco evaluator: Loading groundtruth")
+        self.gt = COCO(self.gt_path)
+
+        # Creating the result file
+        logging.info("Coco evaluator: Creating the result file")
+        cocoDt = self.gt.loadRes(str(dumped_file))
+
+        # Run the evaluation
+        logging.info("Coco evaluator: Running evaluation")
+        coco_eval = COCOevalCustom(
+            self.gt, cocoDt, iouType=self.iou_type, dt_only_positive=self.positive_split
+        )
+        coco_eval.evaluate()
+        coco_eval.accumulate()
+        coco_eval.summarize()
+
+        outs = {}
+        for i, value in enumerate(coco_eval.stats):
+            outs[f"coco_eval_{self.iou_type}_{COCO_METRICS[i]}"] = value
+
+        if self.tide_enabled:
+            logging.info("Coco evaluator: Loading TIDE")
+            self.tide_gt = datasets.COCO(self.gt_path)
+            self.tide = TIDE(mode="mask" if self.iou_type == "segm" else "bbox")
+
+            # Run TIDE
+            logging.info("Coco evaluator: Running TIDE")
+            self.tide.evaluate(
+                self.tide_gt, datasets.COCOResult(str(dumped_file)), name="coco_eval"
+            )
+            self.tide.summarize()
+            for k, v in self.tide.get_main_errors()["coco_eval"].items():
+                outs[f"coco_eval_{self.iou_type}_TIDE_{k}"] = v
+
+            for k, v in self.tide.get_special_errors()["coco_eval"].items():
+                outs[f"coco_eval_{self.iou_type}_TIDE_{k}"] = v
+
+        return outs

third_party/GraspGen/sam3/sam3/eval/conversion_util.py

@@ -0,0 +1,213 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe
+import json
+import os
+from collections import defaultdict
+
+from tqdm import tqdm
+
+
+def convert_ytbvis_to_cocovid_gt(ann_json, save_path=None):
+    """Convert YouTube VIS dataset to COCO-style video instance segmentation format.
+
+    Args:
+        ann_json (str): Path to YouTube VIS annotation JSON file
+        save_path (str): path to save converted COCO-style JSON
+    """
+    # Initialize COCO structure
+    VIS = {
+        "info": {},
+        "images": [],
+        "videos": [],
+        "tracks": [],
+        "annotations": [],
+        "categories": [],
+        "licenses": [],
+    }
+
+    # Load original annotations
+    official_anns = json.load(open(ann_json))
+    VIS["categories"] = official_anns["categories"]  # Direct copy categories
+
+    # Initialize counters
+    records = dict(img_id=1, ann_id=1)
+
+    # Create video-to-annotations mapping
+    vid_to_anns = defaultdict(list)
+    for ann in official_anns["annotations"]:
+        vid_to_anns[ann["video_id"]].append(ann)
+
+    # Create tracks directly
+    VIS["tracks"] = [
+        {
+            "id": ann["id"],
+            "category_id": ann["category_id"],
+            "video_id": ann["video_id"],
+        }
+        for ann in official_anns["annotations"]
+    ]
+
+    # Process videos
+    for video_info in tqdm(official_anns["videos"]):
+        # Create video entry
+        video = {
+            "id": video_info["id"],
+            "name": os.path.dirname(video_info["file_names"][0]),
+            "width": video_info["width"],
+            "height": video_info["height"],
+            "length": video_info["length"],
+            "neg_category_ids": [],
+            "not_exhaustive_category_ids": [],
+        }
+        VIS["videos"].append(video)
+
+        # Process frames
+        num_frames = len(video_info["file_names"])
+        for frame_idx in range(num_frames):
+            # Create image entry
+            image = {
+                "id": records["img_id"],
+                "video_id": video_info["id"],
+                "file_name": video_info["file_names"][frame_idx],
+                "width": video_info["width"],
+                "height": video_info["height"],
+                "frame_index": frame_idx,
+                "frame_id": frame_idx,
+            }
+            VIS["images"].append(image)
+
+            # Process annotations for this frame
+            if video_info["id"] in vid_to_anns:
+                for ann in vid_to_anns[video_info["id"]]:
+                    bbox = ann["bboxes"][frame_idx]
+                    if bbox is None:
+                        continue
+
+                    # Create annotation entry
+                    annotation = {
+                        "id": records["ann_id"],
+                        "video_id": video_info["id"],
+                        "image_id": records["img_id"],
+                        "track_id": ann["id"],
+                        "category_id": ann["category_id"],
+                        "bbox": bbox,
+                        "area": ann["areas"][frame_idx],
+                        "segmentation": ann["segmentations"][frame_idx],
+                        "iscrowd": ann["iscrowd"],
+                    }
+                    VIS["annotations"].append(annotation)
+                    records["ann_id"] += 1
+
+            records["img_id"] += 1
+
+    # Print summary
+    print(f"Converted {len(VIS['videos'])} videos")
+    print(f"Converted {len(VIS['images'])} images")
+    print(f"Created {len(VIS['tracks'])} tracks")
+    print(f"Created {len(VIS['annotations'])} annotations")
+
+    if save_path is None:
+        return VIS
+
+    # Save output
+    save_dir = os.path.dirname(save_path)
+    os.makedirs(save_dir, exist_ok=True)
+    json.dump(VIS, open(save_path, "w"))
+
+    return VIS
+
+
+def convert_ytbvis_to_cocovid_pred(
+    youtubevis_pred_path: str, converted_dataset_path: str, output_path: str
+) -> None:
+    """
+    Convert YouTubeVIS predictions to COCO format with video_id preservation
+
+    Args:
+        youtubevis_pred_path: Path to YouTubeVIS prediction JSON
+        converted_dataset_path: Path to converted COCO dataset JSON
+        output_path: Path to save COCO format predictions
+    """
+
+    # Load YouTubeVIS predictions
+    with open(youtubevis_pred_path) as f:
+        ytv_predictions = json.load(f)
+
+    # Load converted dataset for image ID mapping
+    with open(converted_dataset_path) as f:
+        coco_dataset = json.load(f)
+
+    # Create (video_id, frame_idx) -> image_id mapping
+    image_id_map = {
+        (img["video_id"], img["frame_index"]): img["id"]
+        for img in coco_dataset["images"]
+    }
+
+    coco_annotations = []
+    track_id_counter = 1  # Unique track ID generator
+
+    for pred in tqdm(ytv_predictions):
+        video_id = pred["video_id"]
+        category_id = pred["category_id"]
+        bboxes = pred["bboxes"]
+        segmentations = pred.get("segmentations", [])  # Get segmentations if available
+        areas = pred.get("areas", [])  # Get areas if available
+        score = pred["score"]
+
+        # Assign unique track ID for this prediction
+        track_id = track_id_counter
+        track_id_counter += 1
+
+        # Ensure segmentations and areas have the same length as bboxes
+        if len(segmentations) == 0:
+            segmentations = [None] * len(bboxes)
+        if len(areas) == 0:
+            areas = [None] * len(bboxes)
+
+        for frame_idx, (bbox, segmentation, area_from_pred) in enumerate(
+            zip(bboxes, segmentations, areas)
+        ):
+            # Skip frames with missing objects (None or zero bbox)
+            if bbox is None or all(x == 0 for x in bbox):
+                continue
+
+            # Get corresponding image ID from mapping
+            image_id = image_id_map.get((video_id, frame_idx))
+            if image_id is None:
+                raise RuntimeError(
+                    f"prediction {video_id=}, {frame_idx=} does not match any images in the converted COCO format"
+                )
+
+            # Extract bbox coordinates
+            x, y, w, h = bbox
+
+            # Calculate area - use area from prediction if available, otherwise from bbox
+            if area_from_pred is not None and area_from_pred > 0:
+                area = area_from_pred
+            else:
+                area = w * h
+
+            # Create COCO annotation with video_id
+            coco_annotation = {
+                "image_id": int(image_id),
+                "video_id": video_id,  # Added video_id field
+                "track_id": track_id,
+                "category_id": category_id,
+                "bbox": [float(x), float(y), float(w), float(h)],
+                "area": float(area),
+                "iscrowd": 0,
+                "score": float(score),
+            }
+
+            # Add segmentation if available
+            if segmentation is not None:
+                coco_annotation["segmentation"] = segmentation
+
+            coco_annotations.append(coco_annotation)
+
+    # Save output
+    with open(output_path, "w") as f:
+        json.dump(coco_annotations, f)
+
+    print(f"Converted {len(coco_annotations)} predictions to COCO format with video_id")

third_party/GraspGen/sam3/sam3/eval/demo_eval.py

@@ -0,0 +1,658 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe
+
+"""
+This evaluator is based upon COCO evaluation, but evaluates the model in a "demo" setting.
+This means that the model's predictions are thresholded and evaluated as "hard" predictions.
+"""
+
+import logging
+from typing import Optional
+
+import numpy as np
+import pycocotools.mask as maskUtils
+from pycocotools.cocoeval import COCOeval
+from sam3.eval.coco_eval import CocoEvaluator
+from sam3.train.masks_ops import compute_F_measure
+from sam3.train.utils.distributed import is_main_process
+from scipy.optimize import linear_sum_assignment
+
+
+class DemoEval(COCOeval):
+    """
+    This evaluator is based upon COCO evaluation, but evaluates the model in a "demo" setting.
+    This means that the model's predictions are thresholded and evaluated as "hard" predictions.
+    """
+
+    def __init__(
+        self,
+        coco_gt=None,
+        coco_dt=None,
+        iouType="bbox",
+        threshold=0.5,
+        compute_JnF=False,
+    ):
+        """
+        Args:
+            coco_gt (COCO): ground truth COCO API
+            coco_dt (COCO): detections COCO API
+            iou_type (str): type of IoU to evaluate
+            threshold (float): threshold for predictions
+        """
+        super().__init__(coco_gt, coco_dt, iouType)
+        self.threshold = threshold
+
+        self.params.useCats = False
+        self.params.areaRng = [[0**2, 1e5**2]]
+        self.params.areaRngLbl = ["all"]
+        self.params.maxDets = [100000]
+        self.compute_JnF = compute_JnF
+
+    def computeIoU(self, imgId, catId):
+        # Same as the original COCOeval.computeIoU, but without sorting
+        p = self.params
+        if p.useCats:
+            gt = self._gts[imgId, catId]
+            dt = self._dts[imgId, catId]
+        else:
+            gt = [_ for cId in p.catIds for _ in self._gts[imgId, cId]]
+            dt = [_ for cId in p.catIds for _ in self._dts[imgId, cId]]
+        if len(gt) == 0 and len(dt) == 0:
+            return []
+
+        if p.iouType == "segm":
+            g = [g["segmentation"] for g in gt]
+            d = [d["segmentation"] for d in dt]
+        elif p.iouType == "bbox":
+            g = [g["bbox"] for g in gt]
+            d = [d["bbox"] for d in dt]
+        else:
+            raise Exception("unknown iouType for iou computation")
+
+        # compute iou between each dt and gt region
+        iscrowd = [int(o["iscrowd"]) for o in gt]
+        ious = maskUtils.iou(d, g, iscrowd)
+        return ious
+
+    def evaluateImg(self, imgId, catId, aRng, maxDet):
+        """
+        perform evaluation for single category and image
+        :return: dict (single image results)
+        """
+        p = self.params
+        assert not p.useCats, "This evaluator does not support per-category evaluation."
+        assert catId == -1
+        all_gts = [_ for cId in p.catIds for _ in self._gts[imgId, cId]]
+        keep_gt = np.array([not g["ignore"] for g in all_gts], dtype=bool)
+        gt = [g for g in all_gts if not g["ignore"]]
+        all_dts = [_ for cId in p.catIds for _ in self._dts[imgId, cId]]
+        keep_dt = np.array([d["score"] >= self.threshold for d in all_dts], dtype=bool)
+        dt = [d for d in all_dts if d["score"] >= self.threshold]
+        if len(gt) == 0 and len(dt) == 0:
+            # This is a "true negative" case, where there are no GTs and no predictions
+            # The box-level metrics are ill-defined, so we don't add them to this dict
+            return {
+                "image_id": imgId,
+                "IL_TP": 0,
+                "IL_TN": 1,
+                "IL_FP": 0,
+                "IL_FN": 0,
+                "IL_perfect_neg": np.ones((len(p.iouThrs),), dtype=np.int64),
+                "num_dt": len(dt),
+            }
+
+        if len(gt) > 0 and len(dt) == 0:
+            # This is a "false negative" case, where there are GTs but no predictions
+            return {
+                "image_id": imgId,
+                "IL_TP": 0,
+                "IL_TN": 0,
+                "IL_FP": 0,
+                "IL_FN": 1,
+                "TPs": np.zeros((len(p.iouThrs),), dtype=np.int64),
+                "FPs": np.zeros((len(p.iouThrs),), dtype=np.int64),
+                "FNs": np.ones((len(p.iouThrs),), dtype=np.int64) * len(gt),
+                "local_F1s": np.zeros((len(p.iouThrs),), dtype=np.int64),
+                "local_positive_F1s": np.zeros((len(p.iouThrs),), dtype=np.int64),
+                "IL_perfect_pos": np.zeros((len(p.iouThrs),), dtype=np.int64),
+                "num_dt": len(dt),
+            }
+
+        # Load pre-computed ious
+        ious = self.ious[(imgId, catId)]
+
+        # compute matching
+        if len(ious) == 0:
+            ious = np.zeros((len(dt), len(gt)))
+        else:
+            ious = ious[keep_dt, :][:, keep_gt]
+        assert ious.shape == (len(dt), len(gt))
+
+        matched_dt, matched_gt = linear_sum_assignment(-ious)
+
+        match_scores = ious[matched_dt, matched_gt]
+
+        if self.compute_JnF and len(match_scores) > 0:
+            j_score = match_scores.mean()
+            f_measure = 0
+            for dt_id, gt_id in zip(matched_dt, matched_gt):
+                f_measure += compute_F_measure(
+                    gt_boundary_rle=gt[gt_id]["boundary"],
+                    gt_dilated_boundary_rle=gt[gt_id]["dilated_boundary"],
+                    dt_boundary_rle=dt[dt_id]["boundary"],
+                    dt_dilated_boundary_rle=dt[dt_id]["dilated_boundary"],
+                )
+            f_measure /= len(match_scores) + 1e-9
+            JnF = (j_score + f_measure) * 0.5
+        else:
+            j_score = f_measure = JnF = -1
+
+        TPs, FPs, FNs = [], [], []
+        IL_perfect = []
+        for thresh in p.iouThrs:
+            TP = (match_scores >= thresh).sum()
+            FP = len(dt) - TP
+            FN = len(gt) - TP
+            assert FP >= 0 and FN >= 0, (
+                f"FP: {FP}, FN: {FN}, TP: {TP}, match_scores: {match_scores}, len(dt): {len(dt)}, len(gt): {len(gt)}, ious: {ious}"
+            )
+            TPs.append(TP)
+            FPs.append(FP)
+            FNs.append(FN)
+
+            if FP == FN and FP == 0:
+                IL_perfect.append(1)
+            else:
+                IL_perfect.append(0)
+
+        TPs = np.array(TPs, dtype=np.int64)
+        FPs = np.array(FPs, dtype=np.int64)
+        FNs = np.array(FNs, dtype=np.int64)
+        IL_perfect = np.array(IL_perfect, dtype=np.int64)
+
+        # compute precision recall and F1
+        precision = TPs / (TPs + FPs + 1e-4)
+        assert np.all(precision <= 1)
+        recall = TPs / (TPs + FNs + 1e-4)
+        assert np.all(recall <= 1)
+        F1 = 2 * precision * recall / (precision + recall + 1e-4)
+
+        result = {
+            "image_id": imgId,
+            "TPs": TPs,
+            "FPs": FPs,
+            "FNs": FNs,
+            "local_F1s": F1,
+            "IL_TP": (len(gt) > 0) and (len(dt) > 0),
+            "IL_FP": (len(gt) == 0) and (len(dt) > 0),
+            "IL_TN": (len(gt) == 0) and (len(dt) == 0),
+            "IL_FN": (len(gt) > 0) and (len(dt) == 0),
+            ("IL_perfect_pos" if len(gt) > 0 else "IL_perfect_neg"): IL_perfect,
+            "F": f_measure,
+            "J": j_score,
+            "J&F": JnF,
+            "num_dt": len(dt),
+        }
+        if len(gt) > 0 and len(dt) > 0:
+            result["local_positive_F1s"] = F1
+        return result
+
+    def accumulate(self, p=None):
+        """
+        Accumulate per image evaluation results and store the result in self.eval
+        :param p: input params for evaluation
+        :return: None
+        """
+        if not self.evalImgs:
+            print("Please run evaluate() first")
+        # allows input customized parameters
+        if p is None:
+            p = self.params
+
+        setImgIds = set(p.imgIds)
+
+        # TPs, FPs, FNs
+        TPs = np.zeros((len(p.iouThrs),), dtype=np.int64)
+        FPs = np.zeros((len(p.iouThrs),), dtype=np.int64)
+        pmFPs = np.zeros((len(p.iouThrs),), dtype=np.int64)
+        FNs = np.zeros((len(p.iouThrs),), dtype=np.int64)
+        local_F1s = np.zeros((len(p.iouThrs),), dtype=np.float64)
+
+        # Image level metrics
+        IL_TPs = 0
+        IL_FPs = 0
+        IL_TNs = 0
+        IL_FNs = 0
+        IL_perfects_neg = np.zeros((len(p.iouThrs),), dtype=np.int64)
+        IL_perfects_pos = np.zeros((len(p.iouThrs),), dtype=np.int64)
+
+        # JnF metric
+        total_J = 0
+        total_F = 0
+        total_JnF = 0
+
+        valid_img_count = 0
+        total_pos_count = 0
+        total_neg_count = 0
+        valid_J_count = 0
+        valid_F1_count = 0
+        valid_F1_count_w0dt = 0
+        for res in self.evalImgs:
+            if res["image_id"] not in setImgIds:
+                continue
+            IL_TPs += res["IL_TP"]
+            IL_FPs += res["IL_FP"]
+            IL_TNs += res["IL_TN"]
+            IL_FNs += res["IL_FN"]
+            if "IL_perfect_neg" in res:
+                IL_perfects_neg += res["IL_perfect_neg"]
+                total_neg_count += 1
+            else:
+                assert "IL_perfect_pos" in res
+                IL_perfects_pos += res["IL_perfect_pos"]
+                total_pos_count += 1
+
+            if "TPs" not in res:
+                continue
+
+            TPs += res["TPs"]
+            FPs += res["FPs"]
+            FNs += res["FNs"]
+            valid_img_count += 1
+
+            if "local_positive_F1s" in res:
+                local_F1s += res["local_positive_F1s"]
+                pmFPs += res["FPs"]
+                valid_F1_count_w0dt += 1
+                if res["num_dt"] > 0:
+                    valid_F1_count += 1
+
+            if "J" in res and res["J"] > -1e-9:
+                total_J += res["J"]
+                total_F += res["F"]
+                total_JnF += res["J&F"]
+                valid_J_count += 1
+
+        # compute precision recall and F1
+        precision = TPs / (TPs + FPs + 1e-4)
+        positive_micro_precision = TPs / (TPs + pmFPs + 1e-4)
+        assert np.all(precision <= 1)
+        recall = TPs / (TPs + FNs + 1e-4)
+        assert np.all(recall <= 1)
+        F1 = 2 * precision * recall / (precision + recall + 1e-4)
+        positive_micro_F1 = (
+            2
+            * positive_micro_precision
+            * recall
+            / (positive_micro_precision + recall + 1e-4)
+        )
+
+        IL_rec = IL_TPs / (IL_TPs + IL_FNs + 1e-6)
+        IL_prec = IL_TPs / (IL_TPs + IL_FPs + 1e-6)
+        IL_F1 = 2 * IL_prec * IL_rec / (IL_prec + IL_rec + 1e-6)
+        IL_FPR = IL_FPs / (IL_FPs + IL_TNs + 1e-6)
+        IL_MCC = float(IL_TPs * IL_TNs - IL_FPs * IL_FNs) / (
+            (
+                float(IL_TPs + IL_FPs)
+                * float(IL_TPs + IL_FNs)
+                * float(IL_TNs + IL_FPs)
+                * float(IL_TNs + IL_FNs)
+            )
+            ** 0.5
+            + 1e-6
+        )
+        IL_perfect_pos = IL_perfects_pos / (total_pos_count + 1e-9)
+        IL_perfect_neg = IL_perfects_neg / (total_neg_count + 1e-9)
+
+        total_J = total_J / (valid_J_count + 1e-9)
+        total_F = total_F / (valid_J_count + 1e-9)
+        total_JnF = total_JnF / (valid_J_count + 1e-9)
+
+        self.eval = {
+            "params": p,
+            "TPs": TPs,
+            "FPs": FPs,
+            "positive_micro_FPs": pmFPs,
+            "FNs": FNs,
+            "precision": precision,
+            "positive_micro_precision": positive_micro_precision,
+            "recall": recall,
+            "F1": F1,
+            "positive_micro_F1": positive_micro_F1,
+            "positive_macro_F1": local_F1s / valid_F1_count,
+            "positive_w0dt_macro_F1": local_F1s / valid_F1_count_w0dt,
+            "IL_recall": IL_rec,
+            "IL_precision": IL_prec,
+            "IL_F1": IL_F1,
+            "IL_FPR": IL_FPR,
+            "IL_MCC": IL_MCC,
+            "IL_perfect_pos": IL_perfect_pos,
+            "IL_perfect_neg": IL_perfect_neg,
+            "J": total_J,
+            "F": total_F,
+            "J&F": total_JnF,
+        }
+        self.eval["CGF1"] = self.eval["positive_macro_F1"] * self.eval["IL_MCC"]
+        self.eval["CGF1_w0dt"] = (
+            self.eval["positive_w0dt_macro_F1"] * self.eval["IL_MCC"]
+        )
+        self.eval["CGF1_micro"] = self.eval["positive_micro_F1"] * self.eval["IL_MCC"]
+
+    def summarize(self):
+        """
+        Compute and display summary metrics for evaluation results.
+        Note this functin can *only* be applied on the default parameter setting
+        """
+        if not self.eval:
+            raise Exception("Please run accumulate() first")
+
+        def _summarize(iouThr=None, metric=""):
+            p = self.params
+            iStr = " {:<18} @[ IoU={:<9}] = {:0.3f}"
+            titleStr = "Average " + metric
+            iouStr = (
+                "{:0.2f}:{:0.2f}".format(p.iouThrs[0], p.iouThrs[-1])
+                if iouThr is None
+                else "{:0.2f}".format(iouThr)
+            )
+
+            s = self.eval[metric]
+            # IoU
+            if iouThr is not None:
+                t = np.where(iouThr == p.iouThrs)[0]
+                s = s[t]
+
+            if len(s[s > -1]) == 0:
+                mean_s = -1
+            else:
+                mean_s = np.mean(s[s > -1])
+            print(iStr.format(titleStr, iouStr, mean_s))
+            return mean_s
+
+        def _summarize_single(metric=""):
+            titleStr = "Average " + metric
+            iStr = " {:<35} = {:0.3f}"
+            s = self.eval[metric]
+            print(iStr.format(titleStr, s))
+            return s
+
+        def _summarizeDets():
+            # note: the index of these metrics are also used in video Demo F1 evaluation
+            # when adding new metrics, please update the index in video Demo F1 evaluation
+            # in "evaluate" method of the "VideoDemoF1Evaluator" class
+            stats = np.zeros((len(DEMO_METRICS),))
+            stats[0] = _summarize(metric="CGF1")
+            stats[1] = _summarize(metric="precision")
+            stats[2] = _summarize(metric="recall")
+            stats[3] = _summarize(metric="F1")
+            stats[4] = _summarize(metric="positive_macro_F1")
+            stats[5] = _summarize_single(metric="IL_precision")
+            stats[6] = _summarize_single(metric="IL_recall")
+            stats[7] = _summarize_single(metric="IL_F1")
+            stats[8] = _summarize_single(metric="IL_FPR")
+            stats[9] = _summarize_single(metric="IL_MCC")
+            stats[10] = _summarize(metric="IL_perfect_pos")
+            stats[11] = _summarize(metric="IL_perfect_neg")
+            stats[12] = _summarize(iouThr=0.5, metric="CGF1")
+            stats[13] = _summarize(iouThr=0.5, metric="precision")
+            stats[14] = _summarize(iouThr=0.5, metric="recall")
+            stats[15] = _summarize(iouThr=0.5, metric="F1")
+            stats[16] = _summarize(iouThr=0.5, metric="positive_macro_F1")
+            stats[17] = _summarize(iouThr=0.5, metric="IL_perfect_pos")
+            stats[18] = _summarize(iouThr=0.5, metric="IL_perfect_neg")
+            stats[19] = _summarize(iouThr=0.75, metric="CGF1")
+            stats[20] = _summarize(iouThr=0.75, metric="precision")
+            stats[21] = _summarize(iouThr=0.75, metric="recall")
+            stats[22] = _summarize(iouThr=0.75, metric="F1")
+            stats[23] = _summarize(iouThr=0.75, metric="positive_macro_F1")
+            stats[24] = _summarize(iouThr=0.75, metric="IL_perfect_pos")
+            stats[25] = _summarize(iouThr=0.75, metric="IL_perfect_neg")
+            stats[26] = _summarize_single(metric="J")
+            stats[27] = _summarize_single(metric="F")
+            stats[28] = _summarize_single(metric="J&F")
+            stats[29] = _summarize(metric="CGF1_micro")
+            stats[30] = _summarize(metric="positive_micro_precision")
+            stats[31] = _summarize(metric="positive_micro_F1")
+            stats[32] = _summarize(iouThr=0.5, metric="CGF1_micro")
+            stats[33] = _summarize(iouThr=0.5, metric="positive_micro_precision")
+            stats[34] = _summarize(iouThr=0.5, metric="positive_micro_F1")
+            stats[35] = _summarize(iouThr=0.75, metric="CGF1_micro")
+            stats[36] = _summarize(iouThr=0.75, metric="positive_micro_precision")
+            stats[37] = _summarize(iouThr=0.75, metric="positive_micro_F1")
+            stats[38] = _summarize(metric="CGF1_w0dt")
+            stats[39] = _summarize(metric="positive_w0dt_macro_F1")
+            stats[40] = _summarize(iouThr=0.5, metric="CGF1_w0dt")
+            stats[41] = _summarize(iouThr=0.5, metric="positive_w0dt_macro_F1")
+            stats[42] = _summarize(iouThr=0.75, metric="CGF1_w0dt")
+            stats[43] = _summarize(iouThr=0.75, metric="positive_w0dt_macro_F1")
+            return stats
+
+        summarize = _summarizeDets
+        self.stats = summarize()
+
+
+DEMO_METRICS = [
+    "CGF1",
+    "Precision",
+    "Recall",
+    "F1",
+    "Macro_F1",
+    "IL_Precision",
+    "IL_Recall",
+    "IL_F1",
+    "IL_FPR",
+    "IL_MCC",
+    "IL_perfect_pos",
+    "IL_perfect_neg",
+    "CGF1@0.5",
+    "Precision@0.5",
+    "Recall@0.5",
+    "F1@0.5",
+    "Macro_F1@0.5",
+    "IL_perfect_pos@0.5",
+    "IL_perfect_neg@0.5",
+    "CGF1@0.75",
+    "Precision@0.75",
+    "Recall@0.75",
+    "F1@0.75",
+    "Macro_F1@0.75",
+    "IL_perfect_pos@0.75",
+    "IL_perfect_neg@0.75",
+    "J",
+    "F",
+    "J&F",
+    "CGF1_micro",
+    "positive_micro_Precision",
+    "positive_micro_F1",
+    "CGF1_micro@0.5",
+    "positive_micro_Precision@0.5",
+    "positive_micro_F1@0.5",
+    "CGF1_micro@0.75",
+    "positive_micro_Precision@0.75",
+    "positive_micro_F1@0.75",
+    "CGF1_w0dt",
+    "positive_w0dt_macro_F1",
+    "CGF1_w0dt@0.5",
+    "positive_w0dt_macro_F1@0.5",
+    "CGF1_w0dt@0.75",
+    "positive_w0dt_macro_F1@0.75",
+]
+
+
+class DemoEvaluator(CocoEvaluator):
+    def __init__(
+        self,
+        coco_gt,
+        iou_types,
+        dump_dir: Optional[str],
+        postprocessor,
+        threshold=0.5,
+        average_by_rarity=False,
+        gather_pred_via_filesys=False,
+        exhaustive_only=False,
+        all_exhaustive_only=True,
+        compute_JnF=False,
+        metrics_dump_dir: Optional[str] = None,
+    ):
+        self.iou_types = iou_types
+        self.threshold = threshold
+        super().__init__(
+            coco_gt=coco_gt,
+            iou_types=iou_types,
+            useCats=False,
+            dump_dir=dump_dir,
+            postprocessor=postprocessor,
+            # average_by_rarity=average_by_rarity,
+            gather_pred_via_filesys=gather_pred_via_filesys,
+            exhaustive_only=exhaustive_only,
+            all_exhaustive_only=all_exhaustive_only,
+            metrics_dump_dir=metrics_dump_dir,
+        )
+
+        self.use_self_evaluate = True
+        self.compute_JnF = compute_JnF
+
+    def _lazy_init(self):
+        if self.initialized:
+            return
+        super()._lazy_init()
+        self.use_self_evaluate = True
+        self.reset()
+
+    def select_best_scoring(self, scorings):
+        # This function is used for "oracle" type evaluation.
+        # It accepts the evaluation results with respect to several ground truths, and picks the best
+        if len(scorings) == 1:
+            return scorings[0]
+
+        assert scorings[0].ndim == 3, (
+            f"Expecting results in [numCats, numAreas, numImgs] format, got {scorings[0].shape}"
+        )
+        assert scorings[0].shape[0] == 1, (
+            f"Expecting a single category, got {scorings[0].shape[0]}"
+        )
+
+        for scoring in scorings:
+            assert scoring.shape == scorings[0].shape, (
+                f"Shape mismatch: {scoring.shape}, {scorings[0].shape}"
+            )
+
+        selected_imgs = []
+        for img_id in range(scorings[0].shape[-1]):
+            best = scorings[0][:, :, img_id]
+
+            for scoring in scorings[1:]:
+                current = scoring[:, :, img_id]
+                if "local_F1s" in best[0, 0] and "local_F1s" in current[0, 0]:
+                    # we were able to compute a F1 score for this particular image in both evaluations
+                    # best["local_F1s"] contains the results at various IoU thresholds. We simply take the average for comparision
+                    best_score = best[0, 0]["local_F1s"].mean()
+                    current_score = current[0, 0]["local_F1s"].mean()
+                    if current_score > best_score:
+                        best = current
+
+                else:
+                    # If we're here, it means that in that in some evaluation we were not able to get a valid local F1
+                    # This happens when both the predictions and targets are empty. In that case, we can assume it's a perfect prediction
+                    if "local_F1s" not in current[0, 0]:
+                        best = current
+            selected_imgs.append(best)
+        result = np.stack(selected_imgs, axis=-1)
+        assert result.shape == scorings[0].shape
+        return result
+
+    def summarize(self):
+        self._lazy_init()
+        logging.info("Demo evaluator: Summarizing")
+        if not is_main_process():
+            return {}
+        outs = {}
+        prefix = "oracle_" if len(self.coco_evals) > 1 else ""
+        # if self.rarity_buckets is None:
+        self.accumulate(self.eval_img_ids)
+        for iou_type, coco_eval in self.coco_evals[0].items():
+            print("Demo metric, IoU type={}".format(iou_type))
+            coco_eval.summarize()
+
+        if "bbox" in self.coco_evals[0]:
+            for i, value in enumerate(self.coco_evals[0]["bbox"].stats):
+                outs[f"coco_eval_bbox_{prefix}{DEMO_METRICS[i]}"] = value
+        if "segm" in self.coco_evals[0]:
+            for i, value in enumerate(self.coco_evals[0]["segm"].stats):
+                outs[f"coco_eval_masks_{prefix}{DEMO_METRICS[i]}"] = value
+        # else:
+        #     total_stats = {}
+        #     for bucket, img_list in self.rarity_buckets.items():
+        #         self.accumulate(imgIds=img_list)
+        #         bucket_name = RARITY_BUCKETS[bucket]
+        #         for iou_type, coco_eval in self.coco_evals[0].items():
+        #             print(
+        #                 "Demo metric, IoU type={}, Rarity bucket={}".format(
+        #                     iou_type, bucket_name
+        #                 )
+        #             )
+        #             coco_eval.summarize()
+
+        #         if "bbox" in self.coco_evals[0]:
+        #             if "bbox" not in total_stats:
+        #                 total_stats["bbox"] = np.zeros_like(
+        #                     self.coco_evals[0]["bbox"].stats
+        #                 )
+        #             total_stats["bbox"] += self.coco_evals[0]["bbox"].stats
+        #             for i, value in enumerate(self.coco_evals[0]["bbox"].stats):
+        #                 outs[
+        #                     f"coco_eval_bbox_{bucket_name}_{prefix}{DEMO_METRICS[i]}"
+        #                 ] = value
+        #         if "segm" in self.coco_evals[0]:
+        #             if "segm" not in total_stats:
+        #                 total_stats["segm"] = np.zeros_like(
+        #                     self.coco_evals[0]["segm"].stats
+        #                 )
+        #             total_stats["segm"] += self.coco_evals[0]["segm"].stats
+        #             for i, value in enumerate(self.coco_evals[0]["segm"].stats):
+        #                 outs[
+        #                     f"coco_eval_masks_{bucket_name}_{prefix}{DEMO_METRICS[i]}"
+        #                 ] = value
+
+        #     if "bbox" in total_stats:
+        #         total_stats["bbox"] /= len(self.rarity_buckets)
+        #         for i, value in enumerate(total_stats["bbox"]):
+        #             outs[f"coco_eval_bbox_{prefix}{DEMO_METRICS[i]}"] = value
+        #     if "segm" in total_stats:
+        #         total_stats["segm"] /= len(self.rarity_buckets)
+        #         for i, value in enumerate(total_stats["segm"]):
+        #             outs[f"coco_eval_masks_{prefix}{DEMO_METRICS[i]}"] = value
+
+        return outs
+
+    def accumulate(self, imgIds=None):
+        self._lazy_init()
+        logging.info(
+            f"demo evaluator: Accumulating on {len(imgIds) if imgIds is not None else 'all'} images"
+        )
+        if not is_main_process():
+            return
+
+        if imgIds is not None:
+            for coco_eval in self.coco_evals[0].values():
+                coco_eval.params.imgIds = list(imgIds)
+
+        for coco_eval in self.coco_evals[0].values():
+            coco_eval.accumulate()
+
+    def reset(self):
+        self.coco_evals = [{} for _ in range(len(self.coco_gts))]
+        for i, coco_gt in enumerate(self.coco_gts):
+            for iou_type in self.iou_types:
+                self.coco_evals[i][iou_type] = DemoEval(
+                    coco_gt=coco_gt,
+                    iouType=iou_type,
+                    threshold=self.threshold,
+                    compute_JnF=self.compute_JnF,
+                )
+                self.coco_evals[i][iou_type].useCats = False
+        self.img_ids = []
+        self.eval_imgs = {k: [] for k in self.iou_types}
+        if self.dump is not None:
+            self.dump = []

third_party/GraspGen/sam3/sam3/eval/saco_veval_eval.py

@@ -0,0 +1,157 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe
+import argparse
+import json
+import os
+from collections import defaultdict
+
+from iopath.common.file_io import g_pathmgr
+from sam3.eval.saco_veval_evaluators import (
+    VideoCGF1Evaluator,
+    VideoPhraseApEvaluator,
+    VideoPhraseHotaEvaluator,
+    VideoTetaEvaluator,
+    YTVISPredFileEvaluator,
+)
+
+
+class VEvalEvaluator:
+    def __init__(self, gt_annot_file: str, eval_res_file: str):
+        self.gt_annot_file = gt_annot_file
+        self.eval_res_file = eval_res_file
+        self.evaluators = [
+            # mAP
+            YTVISPredFileEvaluator(gt_annot_file),
+            # Phrase AP
+            VideoPhraseApEvaluator(gt_annot_file),
+            # TETA
+            VideoTetaEvaluator(gt_annot_file, use_mask=True, is_exhaustive=True),
+            # HOTA
+            VideoPhraseHotaEvaluator(gt_annot_file),
+            # cgF1
+            VideoCGF1Evaluator(gt_annot_file),
+        ]
+
+    def run_eval(self, pred_file: str):
+        dataset_results = {}
+        video_np_results = defaultdict(dict)
+        for evaluator in self.evaluators:
+            d_res, v_np_res = evaluator.evaluate(pred_file)
+            dataset_results.update(d_res)
+            for (video_id, category_id), res in v_np_res.items():
+                video_np_results[(video_id, category_id)].update(res)
+
+        if len(dataset_results) == 0:
+            dataset_results = {"": 0.0}
+
+        formatted_video_np_results = [
+            {"video_id": video_id, "category_id": category_id, **res}
+            for (video_id, category_id), res in video_np_results.items()
+        ]
+        eval_metrics = {
+            "dataset_results": dataset_results,
+            "video_np_results": formatted_video_np_results,
+        }
+
+        with g_pathmgr.open(self.eval_res_file, "w") as f:
+            json.dump(eval_metrics, f)
+
+        return eval_metrics
+
+
+def run_main_all(dataset_name, args):
+    gt_annot_file = os.path.join(args.gt_annot_dir, dataset_name + ".json")
+    pred_file = os.path.join(args.pred_dir, dataset_name + "_preds.json")
+    eval_res_file = os.path.join(args.eval_res_dir, dataset_name + "_eval_res.json")
+    print(f"=== Running evaluation for Pred {pred_file} vs GT {gt_annot_file} ===")
+    veval_evaluator = VEvalEvaluator(
+        gt_annot_file=gt_annot_file, eval_res_file=eval_res_file
+    )
+    _ = veval_evaluator.run_eval(pred_file=pred_file)
+
+    print(f"=== Results saved to {eval_res_file} ===")
+
+
+def main_all(args):
+    saco_veval_dataset_names = [
+        "saco_veval_sav_test",
+        "saco_veval_sav_val",
+        "saco_veval_yt1b_test",
+        "saco_veval_yt1b_val",
+        "saco_veval_smartglasses_test",
+        "saco_veval_smartglasses_val",
+    ]
+
+    # multiprocessing may not really work as inner evaluator also using multiprocessing
+    # so we just for loop
+    for dataset_name in saco_veval_dataset_names:
+        print(f"=== Running evaluation for dataset {dataset_name} ===")
+        run_main_all(dataset_name=dataset_name, args=args)
+
+
+def main_one(args):
+    gt_annot_file = args.gt_annot_file
+    pred_file = args.pred_file
+    eval_res_file = args.eval_res_file
+
+    print(f"=== Running evaluation for Pred {pred_file} vs GT {gt_annot_file} ===")
+    veval_evaluator = VEvalEvaluator(
+        gt_annot_file=gt_annot_file, eval_res_file=eval_res_file
+    )
+    _ = veval_evaluator.run_eval(pred_file=pred_file)
+
+    print(f"=== Results saved to {eval_res_file} ===")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run video grounding evaluators")
+
+    # Create subparsers for different commands
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # Run evaluation for all datasets
+    all_parser = subparsers.add_parser("all", help="Run evaluation for all datasets")
+    all_parser.add_argument(
+        "--gt_annot_dir",
+        type=str,
+        help="Directory that contains the ground truth annotation files",
+    )
+    all_parser.add_argument(
+        "--pred_dir",
+        type=str,
+        help="Directory that contains the prediction files",
+    )
+    all_parser.add_argument(
+        "--eval_res_dir",
+        type=str,
+        help="Directory that contains the eval results files",
+    )
+    all_parser.set_defaults(func=main_all)
+
+    # Run evaluation for one dataset
+    one_parser = subparsers.add_parser("one", help="Run evaluation for one dataset")
+    one_parser.add_argument(
+        "--gt_annot_file",
+        type=str,
+        help="Path to the ground truth annotation file",
+    )
+    one_parser.add_argument(
+        "--pred_file",
+        type=str,
+        help="Path to the prediction file",
+    )
+    one_parser.add_argument(
+        "--eval_res_file",
+        type=str,
+        help="Path to the eval results file",
+    )
+    one_parser.set_defaults(func=main_one)
+
+    # Parse and dispatch
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

third_party/GraspGen/sam3/sam3/eval/ytvis_eval.py

@@ -0,0 +1,411 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe
+import copy
+import gc
+import logging
+import os
+from collections import defaultdict
+from operator import xor
+from pathlib import Path
+from typing import List, Optional
+
+import numpy as np
+import pycocotools.mask as mask_util
+import torch
+from pycocotools.cocoeval import COCOeval
+from sam3.eval.cgf1_eval import CGF1Eval
+from sam3.eval.coco_eval_offline import convert_to_xywh
+from sam3.model.box_ops import box_xywh_inter_union
+from sam3.train.masks_ops import rle_encode
+from sam3.train.utils import distributed as dist
+from typing_extensions import override
+
+try:
+    import rapidjson as json
+except ModuleNotFoundError:
+    import json
+
+from iopath.common.file_io import g_pathmgr
+
+
+class YTVISevalMixin:
+    """
+    Identical to COCOeval but adapts computeIoU to compute IoU between tracklets/masklets.
+    """
+
+    @override
+    def _prepare(self):
+        """
+        Copied from cocoeval.py but doesn't convert masks to RLEs (we assume they already are RLEs)
+        """
+        p = self.params
+        if p.useCats:
+            gts = self.cocoGt.loadAnns(
+                self.cocoGt.getAnnIds(imgIds=p.imgIds, catIds=p.catIds)
+            )
+            dts = self.cocoDt.loadAnns(
+                self.cocoDt.getAnnIds(imgIds=p.imgIds, catIds=p.catIds)
+            )
+        else:
+            gts = self.cocoGt.loadAnns(self.cocoGt.getAnnIds(imgIds=p.imgIds))
+            dts = self.cocoDt.loadAnns(self.cocoDt.getAnnIds(imgIds=p.imgIds))
+
+        # set ignore flag
+        for gt in gts:
+            gt["ignore"] = gt["ignore"] if "ignore" in gt else 0
+            gt["ignore"] = "iscrowd" in gt and gt["iscrowd"]
+            if p.iouType == "keypoints":
+                gt["ignore"] = (gt["num_keypoints"] == 0) or gt["ignore"]
+        self._gts = defaultdict(list)  # gt for evaluation
+        self._dts = defaultdict(list)  # dt for evaluation
+        for gt in gts:
+            self._gts[gt["image_id"], gt["category_id"]].append(gt)
+        for dt in dts:
+            self._dts[dt["image_id"], dt["category_id"]].append(dt)
+        self.evalImgs = defaultdict(list)  # per-image per-category evaluation results
+        self.eval = {}  # accumulated evaluation results
+
+    def computeIoU(self, imgId, catId):
+        """
+        Compute IoU between tracklets. Copied from cocoeval.py but adapted for videos (in YT-VIS format)
+        """
+        p = self.params
+        if p.useCats:
+            gt = self._gts[imgId, catId]
+            dt = self._dts[imgId, catId]
+        else:
+            gt = [_ for cId in p.catIds for _ in self._gts[imgId, cId]]
+            dt = [_ for cId in p.catIds for _ in self._dts[imgId, cId]]
+        if len(gt) == 0 or len(dt) == 0:
+            return []
+
+        # For class mAP and phrase AP evaluation, we sort the detections in descending order of scores (as in COCOeval).
+        # For demo F1 evaluation, we DO NOT sort the detections (but match them with GTs via Hungarian matching).
+        assert hasattr(self, "sort_inds_by_scores_in_iou"), (
+            "subclasses that inherits YTVISevalMixin should set `self.sort_inds_by_scores_in_iou` "
+            "(True for class mAP and phrase AP, False for demo F1)"
+        )
+        if self.sort_inds_by_scores_in_iou:
+            inds = np.argsort([-d["score"] for d in dt], kind="mergesort")
+            dt = [dt[i] for i in inds]
+            if len(dt) > p.maxDets[-1]:
+                dt = dt[0 : p.maxDets[-1]]
+
+        if p.iouType == "segm":
+            g = [g["segmentations"] for g in gt]
+            d = [d["segmentations"] for d in dt]
+        elif p.iouType == "bbox":
+            g = [g["bboxes"] for g in gt]
+            d = [d["bboxes"] for d in dt]
+        else:
+            raise Exception("unknown iouType for iou computation")
+
+        def iou_tracklets(preds, gts):
+            preds = torch.tensor(preds)
+            gts = torch.tensor(gts)
+            inter, union = box_xywh_inter_union(
+                preds.unsqueeze(1), gts.unsqueeze(0)
+            )  # Num preds x Num GTS x Num frames
+            inter = inter.sum(-1)
+            union = union.sum(-1)
+            assert (union > 0).all(), (
+                "There exists a tracklet with zero GTs across time. This is suspicious"
+            )
+            return inter / union
+
+        def iou_masklets(preds, gts):
+            inter = 0
+            union = 0
+            for p_i, gt_i in zip(preds, gts):
+                if p_i and gt_i:
+                    # Compute areas of intersection and union
+                    inter += mask_util.area(
+                        mask_util.merge([p_i, gt_i], intersect=True)
+                    )
+                    union += mask_util.area(
+                        mask_util.merge([p_i, gt_i], intersect=False)
+                    )
+                elif gt_i:
+                    union += mask_util.area(gt_i)
+                elif p_i:
+                    union += mask_util.area(p_i)
+            if union > 0:
+                iou = inter / union
+                assert iou >= 0 and iou <= 1, "Encountered an error in IoU computation"
+            else:
+                assert np.isclose(inter, 0) and np.isclose(union, 0), (
+                    "Encountered an error in IoU computation"
+                )
+                iou = 1
+            return iou
+
+        if p.iouType == "segm":
+            ious = [[iou_masklets(d_i, g_i) for g_i in g] for d_i in d]
+        else:
+            ious = iou_tracklets(d, g)
+        return np.array(ious)
+
+
+class YTVISeval(YTVISevalMixin, COCOeval):
+    # For class mAP and phrase AP evaluation, we sort the detections in descending order of scores (as in COCOeval).
+    sort_inds_by_scores_in_iou = True
+
+
+class VideoDemoF1Eval(YTVISevalMixin, CGF1Eval):
+    # For demo F1 evaluation, we DO NOT sort the detections (but match them with GTs via Hungarian matching).
+    sort_inds_by_scores_in_iou = False
+
+
+class YTVISResultsWriter:
+    """
+    Gather and dumps predictions in YT-VIS format.
+    Expected flow of API calls: reset() -> N * update() -> compute_synced()
+    """
+
+    def __init__(
+        self,
+        dump_file: str,
+        postprocessor,
+        gather_pred_via_filesys=False,
+        pred_file_evaluators: Optional[List] = None,
+        save_per_frame_scores: bool = False,
+        write_eval_metrics_file: bool = True,
+        eval_metrics_file_suffix: str = ".sam3_eval_metrics",
+    ):
+        self.dump_file = dump_file
+        self.dump = []
+        self.postprocessor = postprocessor
+        self.gather_pred_via_filesys = gather_pred_via_filesys
+        if dist.is_main_process():
+            dirname = os.path.dirname(self.dump_file)
+            if not os.path.exists(dirname):
+                os.makedirs(dirname, exist_ok=True)
+                logging.info(f"Creating folder: {dirname}")
+
+        # the evaluation hooks to be applied to the prediction files
+        self.pred_file_evaluators = pred_file_evaluators or []
+        self.save_per_frame_scores = save_per_frame_scores
+        # in addition to the prediction file, we also write the evaluation metrics
+        # for easier debugging and analysis (stored in another eval_metrics_file
+        # so that we can keep the dumped prediction file under YT-VIS format)
+        self.write_eval_metrics_file = write_eval_metrics_file
+        if self.write_eval_metrics_file:
+            self.eval_metrics_file = self.dump_file + eval_metrics_file_suffix
+            os.makedirs(os.path.dirname(self.eval_metrics_file), exist_ok=True)
+
+    def _dump_vid_preds(self, results):
+        dumped_results = copy.deepcopy(results)
+        self.dump.extend(dumped_results)
+
+    def prepare(self, predictions):
+        ytvis_results = []
+        for video_id, prediction in predictions.items():
+            if len(prediction) == 0:
+                continue
+            for k in ["boxes", "scores", "labels"]:
+                assert k in prediction, (
+                    f"Expected predictions to have `{k}` key, available keys are {prediction.keys()}"
+                )
+            if self.save_per_frame_scores:
+                assert "per_frame_scores" in prediction, (
+                    f"Expected predictions to have `per_frame_scores` key, available keys are {prediction.keys()}"
+                )
+            assert xor("masks" in prediction, "masks_rle" in prediction), (
+                f"Expected predictions to have either `masks` key or `masks_rle` key, available keys are {prediction.keys()}"
+            )
+
+            boxes = prediction["boxes"]
+            boxes = convert_to_xywh(boxes).tolist()
+            scores = prediction["scores"].tolist()
+            labels = prediction["labels"].tolist()
+            if "masks" in prediction:
+                masks = prediction["masks"].squeeze(2)
+                assert masks.ndim == 4, (
+                    "Expected masks to be of shape(N_preds,T_frames,H,W)"
+                )
+
+                areas = [mask.flatten(1).sum(1).tolist() for mask in masks]
+                rles = [rle_encode(masklet) for masklet in masks]
+
+                # memory clean
+                del masks
+                del prediction["masks"]
+            elif "masks_rle" in prediction:
+                rles = prediction.pop("masks_rle")
+                areas = [
+                    [0 if rle is None else rle.pop("area") for rle in rles_per_obj]
+                    for rles_per_obj in rles
+                ]
+            else:
+                raise ValueError(
+                    "Expected either `masks` or `masks_rle` key in the predictions."
+                )
+
+            new_results = [
+                {
+                    "video_id": video_id,
+                    "category_id": track_label,
+                    "bboxes": track_boxes,
+                    "score": track_score,
+                    "segmentations": track_masks,
+                    "areas": track_areas,
+                }
+                for (
+                    track_boxes,
+                    track_masks,
+                    track_areas,
+                    track_score,
+                    track_label,
+                ) in zip(boxes, rles, areas, scores, labels)
+            ]
+            # Optionally, save per-frame scores
+            if self.save_per_frame_scores:
+                per_frame_scores = prediction["per_frame_scores"].tolist()
+                for res, track_per_frame_scores in zip(new_results, per_frame_scores):
+                    res["per_frame_scores"] = track_per_frame_scores
+
+            ytvis_results.extend(new_results)
+
+        return ytvis_results
+
+    def set_sync_device(self, device: torch.device):
+        self._sync_device = device
+
+    def update(self, *args, **kwargs):
+        predictions = self.postprocessor.process_results(*args, **kwargs)
+        results = self.prepare(predictions)
+        self._dump_vid_preds(results)
+
+    def _dump_preds(self):
+        if not dist.is_main_process():
+            self.dump = []
+            gc.collect()
+            return
+        dumped_file = Path(self.dump_file)
+        logging.info(f"YTVIS evaluator: Dumping predictions to {dumped_file}")
+        with g_pathmgr.open(str(dumped_file), "w") as f:
+            json.dump(self.dump, f)
+        self.dump = []
+        gc.collect()
+        return str(dumped_file)
+
+    def synchronize_between_processes(self):
+        logging.info("YT-VIS evaluator: Synchronizing between processes")
+        dump_dict = self._dedup_pre_gather(self.dump)
+        if self.gather_pred_via_filesys:
+            dump_dict_all_gpus = dist.gather_to_rank_0_via_filesys(dump_dict)
+        else:
+            dump_dict_all_gpus = dist.all_gather(dump_dict, force_cpu=True)
+        self.dump = self._dedup_post_gather(dump_dict_all_gpus)
+        logging.info(f"Gathered all {len(self.dump)} predictions")
+
+    def _dedup_pre_gather(self, predictions):
+        """
+        Organize the predictions as a dict-of-list using (video_id, category_id) as keys
+        for deduplication after gathering them across GPUs.
+
+        During evaluation, PyTorch data loader under `drop_last: False` would wrap
+        around the dataset length to be a multiple of world size (GPU num) and duplicate
+        the remaining batches. This causes the same test sample to appear simultaneously
+        in multiple GPUs, resulting in duplicated predictions being saved into prediction
+        files. These duplicates are then counted as false positives under detection mAP
+        metrics (since a ground truth can be matched with only one prediction).
+
+        For example, if there are 4 GPUs and 6 samples [A1, A2, B1, B2, C1, C2], the data
+        loader (under `drop_last: False`) would load it by wrapping it around like
+        `[A1, A2, B1, B2, C1, C2, *A1*, *A2*]` to make a multiple of 4 and then split it as
+
+        - GPU 0: A1, C1
+        - GPU 1: A2, C2
+        - GPU 3: B1, **A1**
+        - GPU 4: B2, **A2**
+        (as in DistributedSampler in https://github.com/pytorch/pytorch/blob/521588519da9f4876d90ddd7a17c10d0eca89dc6/torch/utils/data/distributed.py#L116-L124)
+
+        so the predictions on A1 and A2 will occur twice in the final gathered outputs
+        in the prediction file (and counted as false positives). This also affects our
+        YT-VIS official val evaluation, but to a lesser extent than YT-VIS dev since
+        the latter is much smaller and more susceptible to false positives.
+
+        So we to deduplicate this. The tricky part is that we cannot deduplicate them
+        simply using video id, given that we are sharding the classes in each video
+        across multiple batches (with 20 prompts per batch) in our "orig_cats" eval dbs.
+
+        The solution is to deduplicate based on (video_id, category_id) tuple as keys.
+        We organize the predictions as a dict-of-list using (video_id, category_id) as
+        keys on each GPU, with the list of masklets under this (video_id, category_id)
+        on this GPU as values. Then, we all-gather this dict-of-list across GPUs and
+        if a key (video_id, category_id) appears in multiple GPUs, we only take the
+        prediction masklet list from one GPU.
+        """
+        prediction_dict = defaultdict(list)
+        for p in predictions:
+            prediction_dict[(p["video_id"], p["category_id"])].append(p)
+        return prediction_dict
+
+    def _dedup_post_gather(self, list_of_prediction_dict):
+        """
+        Deduplicate the predictions from all GPUs. See `_dedup_pre_gather` for details.
+        """
+        dedup_prediction_dict = {}
+        duplication_keys = []
+        for prediction_dict in list_of_prediction_dict:
+            for k, v in prediction_dict.items():
+                if k not in dedup_prediction_dict:
+                    dedup_prediction_dict[k] = v
+                else:
+                    duplication_keys.append(k)
+
+        logging.info(
+            f"skipped {len(duplication_keys)} duplicated predictions in YTVISResultsWriter "
+            f"with the following (video_id, category_id) tuples: {duplication_keys}"
+        )
+        dedup_predictions = sum(dedup_prediction_dict.values(), [])
+        return dedup_predictions
+
+    def compute_synced(
+        self,
+    ):
+        self.synchronize_between_processes()
+        dumped_file = self._dump_preds()
+        if not dist.is_main_process():
+            return {"": 0.0}
+
+        # run evaluation hooks on the prediction file
+        meters = {}
+        all_video_np_level_results = defaultdict(dict)
+        for evaluator in self.pred_file_evaluators:
+            gc.collect()
+            results, video_np_level_results = evaluator.evaluate(dumped_file)
+            meters.update(results)
+            for (video_id, category_id), res in video_np_level_results.items():
+                all_video_np_level_results[(video_id, category_id)].update(res)
+
+        gc.collect()
+        if self.write_eval_metrics_file:
+            # convert the nested dict of {(video_id, category_id): per_sample_metric_dict}
+            # to a list of per-sample metric dicts (with video_id and category_id) for JSON,
+            # as JSON doesn't allow using tuples like (video_id, category_id) as dict keys
+            video_np_level_metrics = [
+                {"video_id": video_id, "category_id": category_id, **res}
+                for (video_id, category_id), res in all_video_np_level_results.items()
+            ]
+            eval_metrics = {
+                "dataset_level_metrics": meters,
+                "video_np_level_metrics": video_np_level_metrics,
+            }
+            with g_pathmgr.open(self.eval_metrics_file, "w") as f:
+                json.dump(eval_metrics, f)
+            logging.info(
+                f"YTVIS evaluator: Dumped evaluation metrics to {self.eval_metrics_file}"
+            )
+
+        if len(meters) == 0:
+            meters = {"": 0.0}
+        return meters
+
+    def compute(self):
+        return {"": 0.0}
+
+    def reset(self, *args, **kwargs):
+        self.dump = []

third_party/GraspGen/sam3/sam3/logger.py

@@ -0,0 +1,56 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe
+import logging
+import os
+
+LOG_LEVELS = {
+    "DEBUG": logging.DEBUG,
+    "INFO": logging.INFO,
+    "WARNING": logging.WARNING,
+    "ERROR": logging.ERROR,
+    "CRITICAL": logging.CRITICAL,
+}
+
+
+class ColoredFormatter(logging.Formatter):
+    """A command line formatter with different colors for each level."""
+
+    def __init__(self):
+        super().__init__()
+        reset = "\033[0m"
+        colors = {
+            logging.DEBUG: f"{reset}\033[36m",  # cyan,
+            logging.INFO: f"{reset}\033[32m",  # green
+            logging.WARNING: f"{reset}\033[33m",  # yellow
+            logging.ERROR: f"{reset}\033[31m",  # red
+            logging.CRITICAL: f"{reset}\033[35m",  # magenta
+        }
+        fmt_str = "{color}%(levelname)s %(asctime)s %(process)d %(filename)s:%(lineno)4d:{reset} %(message)s"
+        self.formatters = {
+            level: logging.Formatter(fmt_str.format(color=color, reset=reset))
+            for level, color in colors.items()
+        }
+        self.default_formatter = self.formatters[logging.INFO]
+
+    def format(self, record):
+        formatter = self.formatters.get(record.levelno, self.default_formatter)
+        return formatter.format(record)
+
+
+def get_logger(name, level=logging.INFO):
+    """A command line logger."""
+    if "LOG_LEVEL" in os.environ:
+        level = os.environ["LOG_LEVEL"].upper()
+        assert level in LOG_LEVELS, (
+            f"Invalid LOG_LEVEL: {level}, must be one of {list(LOG_LEVELS.keys())}"
+        )
+        level = LOG_LEVELS[level]
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    logger.propagate = False
+    ch = logging.StreamHandler()
+    ch.setLevel(level)
+    ch.setFormatter(ColoredFormatter())
+    logger.addHandler(ch)
+    return logger

third_party/GraspGen/sam3/sam3/model_builder.py

@@ -0,0 +1,802 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe
+
+import os
+from typing import Optional
+
+import pkg_resources
+import torch
+import torch.nn as nn
+from huggingface_hub import hf_hub_download
+from iopath.common.file_io import g_pathmgr
+from sam3.model.decoder import (
+    TransformerDecoder,
+    TransformerDecoderLayer,
+    TransformerDecoderLayerv2,
+    TransformerEncoderCrossAttention,
+)
+from sam3.model.encoder import TransformerEncoderFusion, TransformerEncoderLayer
+from sam3.model.geometry_encoders import SequenceGeometryEncoder
+from sam3.model.maskformer_segmentation import PixelDecoder, UniversalSegmentationHead
+from sam3.model.memory import (
+    CXBlock,
+    SimpleFuser,
+    SimpleMaskDownSampler,
+    SimpleMaskEncoder,
+)
+from sam3.model.model_misc import (
+    DotProductScoring,
+    MLP,
+    MultiheadAttentionWrapper as MultiheadAttention,
+    TransformerWrapper,
+)
+from sam3.model.necks import Sam3DualViTDetNeck
+from sam3.model.position_encoding import PositionEmbeddingSine
+from sam3.model.sam1_task_predictor import SAM3InteractiveImagePredictor
+from sam3.model.sam3_image import Sam3Image, Sam3ImageOnVideoMultiGPU
+from sam3.model.sam3_tracking_predictor import Sam3TrackerPredictor
+from sam3.model.sam3_video_inference import Sam3VideoInferenceWithInstanceInteractivity
+from sam3.model.sam3_video_predictor import Sam3VideoPredictorMultiGPU
+from sam3.model.text_encoder_ve import VETextEncoder
+from sam3.model.tokenizer_ve import SimpleTokenizer
+from sam3.model.vitdet import ViT
+from sam3.model.vl_combiner import SAM3VLBackbone
+from sam3.sam.transformer import RoPEAttention
+
+
+# Setup TensorFloat-32 for Ampere GPUs if available
+def _setup_tf32() -> None:
+    """Enable TensorFloat-32 for Ampere GPUs if available."""
+    if torch.cuda.is_available():
+        device_props = torch.cuda.get_device_properties(0)
+        if device_props.major >= 8:
+            torch.backends.cuda.matmul.allow_tf32 = True
+            torch.backends.cudnn.allow_tf32 = True
+
+
+_setup_tf32()
+
+
+def _create_position_encoding(precompute_resolution=None):
+    """Create position encoding for visual backbone."""
+    return PositionEmbeddingSine(
+        num_pos_feats=256,
+        normalize=True,
+        scale=None,
+        temperature=10000,
+        precompute_resolution=precompute_resolution,
+    )
+
+
+def _create_vit_backbone(compile_mode=None):
+    """Create ViT backbone for visual feature extraction."""
+    return ViT(
+        img_size=1008,
+        pretrain_img_size=336,
+        patch_size=14,
+        embed_dim=1024,
+        depth=32,
+        num_heads=16,
+        mlp_ratio=4.625,
+        norm_layer="LayerNorm",
+        drop_path_rate=0.1,
+        qkv_bias=True,
+        use_abs_pos=True,
+        tile_abs_pos=True,
+        global_att_blocks=(7, 15, 23, 31),
+        rel_pos_blocks=(),
+        use_rope=True,
+        use_interp_rope=True,
+        window_size=24,
+        pretrain_use_cls_token=True,
+        retain_cls_token=False,
+        ln_pre=True,
+        ln_post=False,
+        return_interm_layers=False,
+        bias_patch_embed=False,
+        compile_mode=compile_mode,
+    )
+
+
+def _create_vit_neck(position_encoding, vit_backbone, enable_inst_interactivity=False):
+    """Create ViT neck for feature pyramid."""
+    return Sam3DualViTDetNeck(
+        position_encoding=position_encoding,
+        d_model=256,
+        scale_factors=[4.0, 2.0, 1.0, 0.5],
+        trunk=vit_backbone,
+        add_sam2_neck=enable_inst_interactivity,
+    )
+
+
+def _create_vl_backbone(vit_neck, text_encoder):
+    """Create visual-language backbone."""
+    return SAM3VLBackbone(visual=vit_neck, text=text_encoder, scalp=1)
+
+
+def _create_transformer_encoder() -> TransformerEncoderFusion:
+    """Create transformer encoder with its layer."""
+    encoder_layer = TransformerEncoderLayer(
+        activation="relu",
+        d_model=256,
+        dim_feedforward=2048,
+        dropout=0.1,
+        pos_enc_at_attn=True,
+        pos_enc_at_cross_attn_keys=False,
+        pos_enc_at_cross_attn_queries=False,
+        pre_norm=True,
+        self_attention=MultiheadAttention(
+            num_heads=8,
+            dropout=0.1,
+            embed_dim=256,
+            batch_first=True,
+        ),
+        cross_attention=MultiheadAttention(
+            num_heads=8,
+            dropout=0.1,
+            embed_dim=256,
+            batch_first=True,
+        ),
+    )
+
+    encoder = TransformerEncoderFusion(
+        layer=encoder_layer,
+        num_layers=6,
+        d_model=256,
+        num_feature_levels=1,
+        frozen=False,
+        use_act_checkpoint=True,
+        add_pooled_text_to_img_feat=False,
+        pool_text_with_mask=True,
+    )
+    return encoder
+
+
+def _create_transformer_decoder() -> TransformerDecoder:
+    """Create transformer decoder with its layer."""
+    decoder_layer = TransformerDecoderLayer(
+        activation="relu",
+        d_model=256,
+        dim_feedforward=2048,
+        dropout=0.1,
+        cross_attention=MultiheadAttention(
+            num_heads=8,
+            dropout=0.1,
+            embed_dim=256,
+        ),
+        n_heads=8,
+        use_text_cross_attention=True,
+    )
+
+    decoder = TransformerDecoder(
+        layer=decoder_layer,
+        num_layers=6,
+        num_queries=200,
+        return_intermediate=True,
+        box_refine=True,
+        num_o2m_queries=0,
+        dac=True,
+        boxRPB="log",
+        d_model=256,
+        frozen=False,
+        interaction_layer=None,
+        dac_use_selfatt_ln=True,
+        resolution=1008,
+        stride=14,
+        use_act_checkpoint=True,
+        presence_token=True,
+    )
+    return decoder
+
+
+def _create_dot_product_scoring():
+    """Create dot product scoring module."""
+    prompt_mlp = MLP(
+        input_dim=256,
+        hidden_dim=2048,
+        output_dim=256,
+        num_layers=2,
+        dropout=0.1,
+        residual=True,
+        out_norm=nn.LayerNorm(256),
+    )
+    return DotProductScoring(d_model=256, d_proj=256, prompt_mlp=prompt_mlp)
+
+
+def _create_segmentation_head(compile_mode=None):
+    """Create segmentation head with pixel decoder."""
+    pixel_decoder = PixelDecoder(
+        num_upsampling_stages=3,
+        interpolation_mode="nearest",
+        hidden_dim=256,
+        compile_mode=compile_mode,
+    )
+
+    cross_attend_prompt = MultiheadAttention(
+        num_heads=8,
+        dropout=0,
+        embed_dim=256,
+    )
+
+    segmentation_head = UniversalSegmentationHead(
+        hidden_dim=256,
+        upsampling_stages=3,
+        aux_masks=False,
+        presence_head=False,
+        dot_product_scorer=None,
+        act_ckpt=True,
+        cross_attend_prompt=cross_attend_prompt,
+        pixel_decoder=pixel_decoder,
+    )
+    return segmentation_head
+
+
+def _create_geometry_encoder():
+    """Create geometry encoder with all its components."""
+    # Create position encoding for geometry encoder
+    geo_pos_enc = _create_position_encoding()
+    # Create CX block for fuser
+    cx_block = CXBlock(
+        dim=256,
+        kernel_size=7,
+        padding=3,
+        layer_scale_init_value=1.0e-06,
+        use_dwconv=True,
+    )
+    # Create geometry encoder layer
+    geo_layer = TransformerEncoderLayer(
+        activation="relu",
+        d_model=256,
+        dim_feedforward=2048,
+        dropout=0.1,
+        pos_enc_at_attn=False,
+        pre_norm=True,
+        self_attention=MultiheadAttention(
+            num_heads=8,
+            dropout=0.1,
+            embed_dim=256,
+            batch_first=False,
+        ),
+        pos_enc_at_cross_attn_queries=False,
+        pos_enc_at_cross_attn_keys=True,
+        cross_attention=MultiheadAttention(
+            num_heads=8,
+            dropout=0.1,
+            embed_dim=256,
+            batch_first=False,
+        ),
+    )
+
+    # Create geometry encoder
+    input_geometry_encoder = SequenceGeometryEncoder(
+        pos_enc=geo_pos_enc,
+        encode_boxes_as_points=False,
+        points_direct_project=True,
+        points_pool=True,
+        points_pos_enc=True,
+        boxes_direct_project=True,
+        boxes_pool=True,
+        boxes_pos_enc=True,
+        d_model=256,
+        num_layers=3,
+        layer=geo_layer,
+        use_act_ckpt=True,
+        add_cls=True,
+        add_post_encode_proj=True,
+    )
+    return input_geometry_encoder
+
+
+def _create_sam3_model(
+    backbone,
+    transformer,
+    input_geometry_encoder,
+    segmentation_head,
+    dot_prod_scoring,
+    inst_interactive_predictor,
+    eval_mode,
+):
+    """Create the SAM3 image model."""
+    common_params = {
+        "backbone": backbone,
+        "transformer": transformer,
+        "input_geometry_encoder": input_geometry_encoder,
+        "segmentation_head": segmentation_head,
+        "num_feature_levels": 1,
+        "o2m_mask_predict": True,
+        "dot_prod_scoring": dot_prod_scoring,
+        "use_instance_query": False,
+        "multimask_output": True,
+        "inst_interactive_predictor": inst_interactive_predictor,
+    }
+
+    matcher = None
+    if not eval_mode:
+        from sam3.train.matcher import BinaryHungarianMatcherV2
+
+        matcher = BinaryHungarianMatcherV2(
+            focal=True,
+            cost_class=2.0,
+            cost_bbox=5.0,
+            cost_giou=2.0,
+            alpha=0.25,
+            gamma=2,
+            stable=False,
+        )
+    common_params["matcher"] = matcher
+    model = Sam3Image(**common_params)
+
+    return model
+
+
+def _create_tracker_maskmem_backbone():
+    """Create the SAM3 Tracker memory encoder."""
+    # Position encoding for mask memory backbone
+    position_encoding = PositionEmbeddingSine(
+        num_pos_feats=64,
+        normalize=True,
+        scale=None,
+        temperature=10000,
+        precompute_resolution=1008,
+    )
+
+    # Mask processing components
+    mask_downsampler = SimpleMaskDownSampler(
+        kernel_size=3, stride=2, padding=1, interpol_size=[1152, 1152]
+    )
+
+    cx_block_layer = CXBlock(
+        dim=256,
+        kernel_size=7,
+        padding=3,
+        layer_scale_init_value=1.0e-06,
+        use_dwconv=True,
+    )
+
+    fuser = SimpleFuser(layer=cx_block_layer, num_layers=2)
+
+    maskmem_backbone = SimpleMaskEncoder(
+        out_dim=64,
+        position_encoding=position_encoding,
+        mask_downsampler=mask_downsampler,
+        fuser=fuser,
+    )
+
+    return maskmem_backbone
+
+
+def _create_tracker_transformer():
+    """Create the SAM3 Tracker transformer components."""
+    # Self attention
+    self_attention = RoPEAttention(
+        embedding_dim=256,
+        num_heads=1,
+        downsample_rate=1,
+        dropout=0.1,
+        rope_theta=10000.0,
+        feat_sizes=[72, 72],
+        use_fa3=False,
+        use_rope_real=False,
+    )
+
+    # Cross attention
+    cross_attention = RoPEAttention(
+        embedding_dim=256,
+        num_heads=1,
+        downsample_rate=1,
+        dropout=0.1,
+        kv_in_dim=64,
+        rope_theta=10000.0,
+        feat_sizes=[72, 72],
+        rope_k_repeat=True,
+        use_fa3=False,
+        use_rope_real=False,
+    )
+
+    # Encoder layer
+    encoder_layer = TransformerDecoderLayerv2(
+        cross_attention_first=False,
+        activation="relu",
+        dim_feedforward=2048,
+        dropout=0.1,
+        pos_enc_at_attn=False,
+        pre_norm=True,
+        self_attention=self_attention,
+        d_model=256,
+        pos_enc_at_cross_attn_keys=True,
+        pos_enc_at_cross_attn_queries=False,
+        cross_attention=cross_attention,
+    )
+
+    # Encoder
+    encoder = TransformerEncoderCrossAttention(
+        remove_cross_attention_layers=[],
+        batch_first=True,
+        d_model=256,
+        frozen=False,
+        pos_enc_at_input=True,
+        layer=encoder_layer,
+        num_layers=4,
+        use_act_checkpoint=False,
+    )
+
+    # Transformer wrapper
+    transformer = TransformerWrapper(
+        encoder=encoder,
+        decoder=None,
+        d_model=256,
+    )
+
+    return transformer
+
+
+def build_tracker(
+    apply_temporal_disambiguation: bool, with_backbone: bool = False, compile_mode=None
+) -> Sam3TrackerPredictor:
+    """
+    Build the SAM3 Tracker module for video tracking.
+
+    Returns:
+        Sam3TrackerPredictor: Wrapped SAM3 Tracker module
+    """
+
+    # Create model components
+    maskmem_backbone = _create_tracker_maskmem_backbone()
+    transformer = _create_tracker_transformer()
+    backbone = None
+    if with_backbone:
+        vision_backbone = _create_vision_backbone(compile_mode=compile_mode)
+        backbone = SAM3VLBackbone(scalp=1, visual=vision_backbone, text=None)
+    # Create the Tracker module
+    model = Sam3TrackerPredictor(
+        image_size=1008,
+        num_maskmem=7,
+        backbone=backbone,
+        backbone_stride=14,
+        transformer=transformer,
+        maskmem_backbone=maskmem_backbone,
+        # SAM parameters
+        multimask_output_in_sam=True,
+        # Evaluation
+        forward_backbone_per_frame_for_eval=True,
+        trim_past_non_cond_mem_for_eval=False,
+        # Multimask
+        multimask_output_for_tracking=True,
+        multimask_min_pt_num=0,
+        multimask_max_pt_num=1,
+        # Additional settings
+        always_start_from_first_ann_frame=False,
+        # Mask overlap
+        non_overlap_masks_for_mem_enc=False,
+        non_overlap_masks_for_output=False,
+        max_cond_frames_in_attn=4,
+        offload_output_to_cpu_for_eval=False,
+        # SAM decoder settings
+        sam_mask_decoder_extra_args={
+            "dynamic_multimask_via_stability": True,
+            "dynamic_multimask_stability_delta": 0.05,
+            "dynamic_multimask_stability_thresh": 0.98,
+        },
+        clear_non_cond_mem_around_input=True,
+        fill_hole_area=0,
+        use_memory_selection=apply_temporal_disambiguation,
+    )
+
+    return model
+
+
+def _create_text_encoder(bpe_path: str) -> VETextEncoder:
+    """Create SAM3 text encoder."""
+    tokenizer = SimpleTokenizer(bpe_path=bpe_path)
+    return VETextEncoder(
+        tokenizer=tokenizer,
+        d_model=256,
+        width=1024,
+        heads=16,
+        layers=24,
+    )
+
+
+def _create_vision_backbone(
+    compile_mode=None, enable_inst_interactivity=True
+) -> Sam3DualViTDetNeck:
+    """Create SAM3 visual backbone with ViT and neck."""
+    # Position encoding
+    position_encoding = _create_position_encoding(precompute_resolution=1008)
+    # ViT backbone
+    vit_backbone: ViT = _create_vit_backbone(compile_mode=compile_mode)
+    vit_neck: Sam3DualViTDetNeck = _create_vit_neck(
+        position_encoding,
+        vit_backbone,
+        enable_inst_interactivity=enable_inst_interactivity,
+    )
+    # Visual neck
+    return vit_neck
+
+
+def _create_sam3_transformer(has_presence_token: bool = True) -> TransformerWrapper:
+    """Create SAM3 transformer encoder and decoder."""
+    encoder: TransformerEncoderFusion = _create_transformer_encoder()
+    decoder: TransformerDecoder = _create_transformer_decoder()
+
+    return TransformerWrapper(encoder=encoder, decoder=decoder, d_model=256)
+
+
+def _load_checkpoint(
+    model,
+    checkpoint_path="/home/agilex/.cache/modelscope/hub/models/facebook/sam3/sam3.pt",
+):
+    """Load model checkpoint from file."""
+    with g_pathmgr.open(checkpoint_path, "rb") as f:
+        ckpt = torch.load(f, map_location="cpu", weights_only=True)
+    if "model" in ckpt and isinstance(ckpt["model"], dict):
+        ckpt = ckpt["model"]
+    sam3_image_ckpt = {
+        k.replace("detector.", ""): v for k, v in ckpt.items() if "detector" in k
+    }
+    if model.inst_interactive_predictor is not None:
+        sam3_image_ckpt.update(
+            {
+                k.replace("tracker.", "inst_interactive_predictor.model."): v
+                for k, v in ckpt.items()
+                if "tracker" in k
+            }
+        )
+    missing_keys, _ = model.load_state_dict(sam3_image_ckpt, strict=False)
+    if len(missing_keys) > 0:
+        print(
+            f"loaded {checkpoint_path} and found "
+            f"missing and/or unexpected keys:\n{missing_keys=}"
+        )
+
+
+def _setup_device_and_mode(model, device, eval_mode):
+    """Setup model device and evaluation mode."""
+    if device == "cuda":
+        model = model.cuda()
+    if eval_mode:
+        model.eval()
+    return model
+
+
+def build_sam3_image_model(
+    bpe_path=None,
+    device="cuda" if torch.cuda.is_available() else "cpu",
+    eval_mode=True,
+    checkpoint_path="/home/agilex/.cache/modelscope/hub/models/facebook/sam3/sam3.pt",
+    load_from_HF=True,
+    enable_segmentation=True,
+    enable_inst_interactivity=False,
+    compile=False,
+):
+    """
+    Build SAM3 image model
+
+    Args:
+        bpe_path: Path to the BPE tokenizer vocabulary
+        device: Device to load the model on ('cuda' or 'cpu')
+        eval_mode: Whether to set the model to evaluation mode
+        checkpoint_path: Optional path to model checkpoint
+        enable_segmentation: Whether to enable segmentation head
+        enable_inst_interactivity: Whether to enable instance interactivity (SAM 1 task)
+        compile_mode: To enable compilation, set to "default"
+
+    Returns:
+        A SAM3 image model
+    """
+    if bpe_path is None:
+        bpe_path = pkg_resources.resource_filename(
+            "sam3", "assets/bpe_simple_vocab_16e6.txt.gz"
+        )
+
+    # Create visual components
+    compile_mode = "default" if compile else None
+    vision_encoder = _create_vision_backbone(
+        compile_mode=compile_mode, enable_inst_interactivity=enable_inst_interactivity
+    )
+
+    # Create text components
+    text_encoder = _create_text_encoder(bpe_path)
+
+    # Create visual-language backbone
+    backbone = _create_vl_backbone(vision_encoder, text_encoder)
+
+    # Create transformer components
+    transformer = _create_sam3_transformer()
+
+    # Create dot product scoring
+    dot_prod_scoring = _create_dot_product_scoring()
+
+    # Create segmentation head if enabled
+    segmentation_head = (
+        _create_segmentation_head(compile_mode=compile_mode)
+        if enable_segmentation
+        else None
+    )
+
+    # Create geometry encoder
+    input_geometry_encoder = _create_geometry_encoder()
+    if enable_inst_interactivity:
+        sam3_pvs_base = build_tracker(apply_temporal_disambiguation=False)
+        inst_predictor = SAM3InteractiveImagePredictor(sam3_pvs_base)
+    else:
+        inst_predictor = None
+    # Create the SAM3 model
+    model = _create_sam3_model(
+        backbone,
+        transformer,
+        input_geometry_encoder,
+        segmentation_head,
+        dot_prod_scoring,
+        inst_predictor,
+        eval_mode,
+    )
+    if load_from_HF and checkpoint_path is None:
+        checkpoint_path = download_ckpt_from_hf()
+    # Load checkpoint if provided
+    if checkpoint_path is not None:
+        _load_checkpoint(model, checkpoint_path)
+
+    # Setup device and mode
+    model = _setup_device_and_mode(model, device, eval_mode)
+
+    return model
+
+
+def download_ckpt_from_hf():
+    SAM3_MODEL_ID = "facebook/sam3"
+    SAM3_CKPT_NAME = "sam3.pt"
+    SAM3_CFG_NAME = "config.json"
+    _ = hf_hub_download(repo_id=SAM3_MODEL_ID, filename=SAM3_CFG_NAME)
+    checkpoint_path = hf_hub_download(repo_id=SAM3_MODEL_ID, filename=SAM3_CKPT_NAME)
+    return checkpoint_path
+
+
+def build_sam3_video_model(
+    checkpoint_path: Optional[
+        str
+    ] = "/home/agilex/.cache/modelscope/hub/models/facebook/sam3/sam3.pt",
+    load_from_HF=True,
+    bpe_path: Optional[str] = None,
+    has_presence_token: bool = True,
+    geo_encoder_use_img_cross_attn: bool = True,
+    strict_state_dict_loading: bool = True,
+    apply_temporal_disambiguation: bool = True,
+    device="cuda" if torch.cuda.is_available() else "cpu",
+    compile=False,
+) -> Sam3VideoInferenceWithInstanceInteractivity:
+    """
+    Build SAM3 dense tracking model.
+
+    Args:
+        checkpoint_path: Optional path to checkpoint file
+        bpe_path: Path to the BPE tokenizer file
+
+    Returns:
+        Sam3VideoInferenceWithInstanceInteractivity: The instantiated dense tracking model
+    """
+    if bpe_path is None:
+        bpe_path = pkg_resources.resource_filename(
+            "sam3", "assets/bpe_simple_vocab_16e6.txt.gz"
+        )
+
+    # Build Tracker module
+    tracker = build_tracker(apply_temporal_disambiguation=apply_temporal_disambiguation)
+
+    # Build Detector components
+    visual_neck = _create_vision_backbone()
+    text_encoder = _create_text_encoder(bpe_path)
+    backbone = SAM3VLBackbone(scalp=1, visual=visual_neck, text=text_encoder)
+    transformer = _create_sam3_transformer(has_presence_token=has_presence_token)
+    segmentation_head: UniversalSegmentationHead = _create_segmentation_head()
+    input_geometry_encoder = _create_geometry_encoder()
+
+    # Create main dot product scoring
+    main_dot_prod_mlp = MLP(
+        input_dim=256,
+        hidden_dim=2048,
+        output_dim=256,
+        num_layers=2,
+        dropout=0.1,
+        residual=True,
+        out_norm=nn.LayerNorm(256),
+    )
+    main_dot_prod_scoring = DotProductScoring(
+        d_model=256, d_proj=256, prompt_mlp=main_dot_prod_mlp
+    )
+
+    # Build Detector module
+    detector = Sam3ImageOnVideoMultiGPU(
+        num_feature_levels=1,
+        backbone=backbone,
+        transformer=transformer,
+        segmentation_head=segmentation_head,
+        semantic_segmentation_head=None,
+        input_geometry_encoder=input_geometry_encoder,
+        use_early_fusion=True,
+        use_dot_prod_scoring=True,
+        dot_prod_scoring=main_dot_prod_scoring,
+        supervise_joint_box_scores=has_presence_token,
+    )
+
+    # Build the main SAM3 video model
+    if apply_temporal_disambiguation:
+        model = Sam3VideoInferenceWithInstanceInteractivity(
+            detector=detector,
+            tracker=tracker,
+            score_threshold_detection=0.5,
+            assoc_iou_thresh=0.1,
+            det_nms_thresh=0.1,
+            new_det_thresh=0.7,
+            hotstart_delay=15,
+            hotstart_unmatch_thresh=8,
+            hotstart_dup_thresh=8,
+            suppress_unmatched_only_within_hotstart=True,
+            min_trk_keep_alive=-1,
+            max_trk_keep_alive=30,
+            init_trk_keep_alive=30,
+            suppress_overlapping_based_on_recent_occlusion_threshold=0.7,
+            suppress_det_close_to_boundary=False,
+            fill_hole_area=16,
+            recondition_every_nth_frame=16,
+            masklet_confirmation_enable=False,
+            decrease_trk_keep_alive_for_empty_masklets=False,
+            image_size=1008,
+            image_mean=(0.5, 0.5, 0.5),
+            image_std=(0.5, 0.5, 0.5),
+            compile_model=compile,
+        )
+    else:
+        # a version without any heuristics for ablation studies
+        model = Sam3VideoInferenceWithInstanceInteractivity(
+            detector=detector,
+            tracker=tracker,
+            score_threshold_detection=0.5,
+            assoc_iou_thresh=0.1,
+            det_nms_thresh=0.1,
+            new_det_thresh=0.7,
+            hotstart_delay=0,
+            hotstart_unmatch_thresh=0,
+            hotstart_dup_thresh=0,
+            suppress_unmatched_only_within_hotstart=True,
+            min_trk_keep_alive=-1,
+            max_trk_keep_alive=30,
+            init_trk_keep_alive=30,
+            suppress_overlapping_based_on_recent_occlusion_threshold=0.7,
+            suppress_det_close_to_boundary=False,
+            fill_hole_area=16,
+            recondition_every_nth_frame=0,
+            masklet_confirmation_enable=False,
+            decrease_trk_keep_alive_for_empty_masklets=False,
+            image_size=1008,
+            image_mean=(0.5, 0.5, 0.5),
+            image_std=(0.5, 0.5, 0.5),
+            compile_model=compile,
+        )
+
+    # Load checkpoint if provided
+    if load_from_HF and checkpoint_path is None:
+        checkpoint_path = download_ckpt_from_hf()
+    if checkpoint_path is not None:
+        with g_pathmgr.open(checkpoint_path, "rb") as f:
+            ckpt = torch.load(f, map_location="cpu", weights_only=True)
+        if "model" in ckpt and isinstance(ckpt["model"], dict):
+            ckpt = ckpt["model"]
+
+        missing_keys, unexpected_keys = model.load_state_dict(
+            ckpt, strict=strict_state_dict_loading
+        )
+        if missing_keys:
+            print(f"Missing keys: {missing_keys}")
+        if unexpected_keys:
+            print(f"Unexpected keys: {unexpected_keys}")
+
+    model.to(device=device)
+    return model
+
+
+def build_sam3_video_predictor(*model_args, gpus_to_use=None, **model_kwargs):
+    return Sam3VideoPredictorMultiGPU(
+        *model_args, gpus_to_use=gpus_to_use, **model_kwargs
+    )

third_party/GraspGen/sam3/sam3/visualization_utils.py

@@ -0,0 +1,943 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe
+import json
+import os
+import subprocess
+from pathlib import Path
+
+import cv2
+import matplotlib.patches as patches
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import pycocotools.mask as mask_utils
+import torch
+from matplotlib.colors import to_rgb
+from PIL import Image
+from skimage.color import lab2rgb, rgb2lab
+from sklearn.cluster import KMeans
+from torchvision.ops import masks_to_boxes
+from tqdm import tqdm
+
+
+def generate_colors(n_colors=256, n_samples=5000):
+    # Step 1: Random RGB samples
+    np.random.seed(42)
+    rgb = np.random.rand(n_samples, 3)
+    # Step 2: Convert to LAB for perceptual uniformity
+    # print(f"Converting {n_samples} RGB samples to LAB color space...")
+    lab = rgb2lab(rgb.reshape(1, -1, 3)).reshape(-1, 3)
+    # print("Conversion to LAB complete.")
+    # Step 3: k-means clustering in LAB
+    kmeans = KMeans(n_clusters=n_colors, n_init=10)
+    # print(f"Fitting KMeans with {n_colors} clusters on {n_samples} samples...")
+    kmeans.fit(lab)
+    # print("KMeans fitting complete.")
+    centers_lab = kmeans.cluster_centers_
+    # Step 4: Convert LAB back to RGB
+    colors_rgb = lab2rgb(centers_lab.reshape(1, -1, 3)).reshape(-1, 3)
+    colors_rgb = np.clip(colors_rgb, 0, 1)
+    return colors_rgb
+
+
+COLORS = generate_colors(n_colors=128, n_samples=5000)
+
+
+def show_img_tensor(img_batch, vis_img_idx=0):
+    MEAN_IMG = np.array([0.5, 0.5, 0.5])
+    STD_IMG = np.array([0.5, 0.5, 0.5])
+    im_tensor = img_batch[vis_img_idx].detach().cpu()
+    assert im_tensor.dim() == 3
+    im_tensor = im_tensor.numpy().transpose((1, 2, 0))
+    im_tensor = (im_tensor * STD_IMG) + MEAN_IMG
+    im_tensor = np.clip(im_tensor, 0, 1)
+    plt.imshow(im_tensor)
+
+
+def draw_box_on_image(image, box, color=(0, 255, 0)):
+    """
+    Draws a rectangle on a given PIL image using the provided box coordinates in xywh format.
+    :param image: PIL.Image - The image on which to draw the rectangle.
+    :param box: tuple - A tuple (x, y, w, h) representing the top-left corner, width, and height of the rectangle.
+    :param color: tuple - A tuple (R, G, B) representing the color of the rectangle. Default is red.
+    :return: PIL.Image - The image with the rectangle drawn on it.
+    """
+    # Ensure the image is in RGB mode
+    image = image.convert("RGB")
+    # Unpack the box coordinates
+    x, y, w, h = box
+    x, y, w, h = int(x), int(y), int(w), int(h)
+    # Get the pixel data
+    pixels = image.load()
+    # Draw the top and bottom edges
+    for i in range(x, x + w):
+        pixels[i, y] = color
+        pixels[i, y + h - 1] = color
+        pixels[i, y + 1] = color
+        pixels[i, y + h] = color
+        pixels[i, y - 1] = color
+        pixels[i, y + h - 2] = color
+    # Draw the left and right edges
+    for j in range(y, y + h):
+        pixels[x, j] = color
+        pixels[x + 1, j] = color
+        pixels[x - 1, j] = color
+        pixels[x + w - 1, j] = color
+        pixels[x + w, j] = color
+        pixels[x + w - 2, j] = color
+    return image
+
+
+def plot_bbox(
+    img_height,
+    img_width,
+    box,
+    box_format="XYXY",
+    relative_coords=True,
+    color="r",
+    linestyle="solid",
+    text=None,
+    ax=None,
+):
+    if box_format == "XYXY":
+        x, y, x2, y2 = box
+        w = x2 - x
+        h = y2 - y
+    elif box_format == "XYWH":
+        x, y, w, h = box
+    elif box_format == "CxCyWH":
+        cx, cy, w, h = box
+        x = cx - w / 2
+        y = cy - h / 2
+    else:
+        raise RuntimeError(f"Invalid box_format {box_format}")
+
+    if relative_coords:
+        x *= img_width
+        w *= img_width
+        y *= img_height
+        h *= img_height
+
+    if ax is None:
+        ax = plt.gca()
+    rect = patches.Rectangle(
+        (x, y),
+        w,
+        h,
+        linewidth=1.5,
+        edgecolor=color,
+        facecolor="none",
+        linestyle=linestyle,
+    )
+    ax.add_patch(rect)
+    if text is not None:
+        facecolor = "w"
+        ax.text(
+            x,
+            y - 5,
+            text,
+            color=color,
+            weight="bold",
+            fontsize=8,
+            bbox={"facecolor": facecolor, "alpha": 0.75, "pad": 2},
+        )
+
+
+def plot_mask(mask, color="r", ax=None):
+    im_h, im_w = mask.shape
+    mask_img = np.zeros((im_h, im_w, 4), dtype=np.float32)
+    mask_img[..., :3] = to_rgb(color)
+    mask_img[..., 3] = mask * 0.5
+    # Use the provided ax or the current axis
+    if ax is None:
+        ax = plt.gca()
+    ax.imshow(mask_img)
+
+
+def normalize_bbox(bbox_xywh, img_w, img_h):
+    # Assumes bbox_xywh is in XYWH format
+    if isinstance(bbox_xywh, list):
+        assert (
+            len(bbox_xywh) == 4
+        ), "bbox_xywh list must have 4 elements. Batching not support except for torch tensors."
+        normalized_bbox = bbox_xywh.copy()
+        normalized_bbox[0] /= img_w
+        normalized_bbox[1] /= img_h
+        normalized_bbox[2] /= img_w
+        normalized_bbox[3] /= img_h
+    else:
+        assert isinstance(
+            bbox_xywh, torch.Tensor
+        ), "Only torch tensors are supported for batching."
+        normalized_bbox = bbox_xywh.clone()
+        assert (
+            normalized_bbox.size(-1) == 4
+        ), "bbox_xywh tensor must have last dimension of size 4."
+        normalized_bbox[..., 0] /= img_w
+        normalized_bbox[..., 1] /= img_h
+        normalized_bbox[..., 2] /= img_w
+        normalized_bbox[..., 3] /= img_h
+    return normalized_bbox
+
+
+def visualize_frame_output(frame_idx, video_frames, outputs, figsize=(12, 8)):
+    plt.figure(figsize=figsize)
+    plt.title(f"frame {frame_idx}")
+    img = load_frame(video_frames[frame_idx])
+    img_H, img_W, _ = img.shape
+    plt.imshow(img)
+    for i in range(len(outputs["out_probs"])):
+        box_xywh = outputs["out_boxes_xywh"][i]
+        prob = outputs["out_probs"][i]
+        obj_id = outputs["out_obj_ids"][i]
+        binary_mask = outputs["out_binary_masks"][i]
+        color = COLORS[obj_id % len(COLORS)]
+        plot_bbox(
+            img_H,
+            img_W,
+            box_xywh,
+            text=f"(id={obj_id}, {prob=:.2f})",
+            box_format="XYWH",
+            color=color,
+        )
+        plot_mask(binary_mask, color=color)
+
+
+def visualize_formatted_frame_output(
+    frame_idx,
+    video_frames,
+    outputs_list,
+    titles=None,
+    points_list=None,
+    points_labels_list=None,
+    figsize=(12, 8),
+    title_suffix="",
+    prompt_info=None,
+):
+    """Visualize up to three sets of segmentation masks on a video frame.
+
+    Args:
+        frame_idx: Frame index to visualize
+        image_files: List of image file paths
+        outputs_list: List of {frame_idx: {obj_id: mask_tensor}} or single dict {obj_id: mask_tensor}
+        titles: List of titles for each set of outputs_list
+        points_list: Optional list of point coordinates
+        points_labels_list: Optional list of point labels
+        figsize: Figure size tuple
+        save: Whether to save the visualization to file
+        output_dir: Base output directory when saving
+        scenario_name: Scenario name for organizing saved files
+        title_suffix: Additional title suffix
+        prompt_info: Dictionary with prompt information (boxes, points, etc.)
+    """
+    # Handle single output dict case
+    if isinstance(outputs_list, dict) and frame_idx in outputs_list:
+        # This is a single outputs dict with frame indices as keys
+        outputs_list = [outputs_list]
+    elif isinstance(outputs_list, dict) and not any(
+        isinstance(k, int) for k in outputs_list.keys()
+    ):
+        # This is a single frame's outputs {obj_id: mask}
+        single_frame_outputs = {frame_idx: outputs_list}
+        outputs_list = [single_frame_outputs]
+
+    num_outputs = len(outputs_list)
+    if titles is None:
+        titles = [f"Set {i + 1}" for i in range(num_outputs)]
+    assert (
+        len(titles) == num_outputs
+    ), "length of `titles` should match that of `outputs_list` if not None."
+
+    _, axes = plt.subplots(1, num_outputs, figsize=figsize)
+    if num_outputs == 1:
+        axes = [axes]  # Make it iterable
+
+    img = load_frame(video_frames[frame_idx])
+    img_H, img_W, _ = img.shape
+
+    for idx in range(num_outputs):
+        ax, outputs_set, ax_title = axes[idx], outputs_list[idx], titles[idx]
+        ax.set_title(f"Frame {frame_idx} - {ax_title}{title_suffix}")
+        ax.imshow(img)
+
+        if frame_idx in outputs_set:
+            _outputs = outputs_set[frame_idx]
+        else:
+            print(f"Warning: Frame {frame_idx} not found in outputs_set")
+            continue
+
+        if prompt_info and frame_idx == 0:  # Show prompts on first frame
+            if "boxes" in prompt_info:
+                for box in prompt_info["boxes"]:
+                    # box is in [x, y, w, h] normalized format
+                    x, y, w, h = box
+                    plot_bbox(
+                        img_H,
+                        img_W,
+                        [x, y, x + w, y + h],  # Convert to XYXY
+                        box_format="XYXY",
+                        relative_coords=True,
+                        color="yellow",
+                        linestyle="dashed",
+                        text="PROMPT BOX",
+                        ax=ax,
+                    )
+
+            if "points" in prompt_info and "point_labels" in prompt_info:
+                points = np.array(prompt_info["points"])
+                labels = np.array(prompt_info["point_labels"])
+                # Convert normalized to pixel coordinates
+                points_pixel = points * np.array([img_W, img_H])
+
+                # Draw positive points (green stars)
+                pos_points = points_pixel[labels == 1]
+                if len(pos_points) > 0:
+                    ax.scatter(
+                        pos_points[:, 0],
+                        pos_points[:, 1],
+                        color="lime",
+                        marker="*",
+                        s=200,
+                        edgecolor="white",
+                        linewidth=2,
+                        label="Positive Points",
+                        zorder=10,
+                    )
+
+                # Draw negative points (red stars)
+                neg_points = points_pixel[labels == 0]
+                if len(neg_points) > 0:
+                    ax.scatter(
+                        neg_points[:, 0],
+                        neg_points[:, 1],
+                        color="red",
+                        marker="*",
+                        s=200,
+                        edgecolor="white",
+                        linewidth=2,
+                        label="Negative Points",
+                        zorder=10,
+                    )
+
+        objects_drawn = 0
+        for obj_id, binary_mask in _outputs.items():
+            mask_sum = (
+                binary_mask.sum()
+                if hasattr(binary_mask, "sum")
+                else np.sum(binary_mask)
+            )
+
+            if mask_sum > 0:  # Only draw if mask has content
+                # Convert to torch tensor if it's not already
+                if not isinstance(binary_mask, torch.Tensor):
+                    binary_mask = torch.tensor(binary_mask)
+
+                # Find bounding box from mask
+                if binary_mask.any():
+                    box_xyxy = masks_to_boxes(binary_mask.unsqueeze(0)).squeeze()
+                    box_xyxy = normalize_bbox(box_xyxy, img_W, img_H)
+                else:
+                    # Fallback: create a small box at center
+                    box_xyxy = [0.45, 0.45, 0.55, 0.55]
+
+                color = COLORS[obj_id % len(COLORS)]
+
+                plot_bbox(
+                    img_H,
+                    img_W,
+                    box_xyxy,
+                    text=f"(id={obj_id})",
+                    box_format="XYXY",
+                    color=color,
+                    ax=ax,
+                )
+
+                # Convert back to numpy for plotting
+                mask_np = (
+                    binary_mask.numpy()
+                    if isinstance(binary_mask, torch.Tensor)
+                    else binary_mask
+                )
+                plot_mask(mask_np, color=color, ax=ax)
+                objects_drawn += 1
+
+        if objects_drawn == 0:
+            ax.text(
+                0.5,
+                0.5,
+                "No objects detected",
+                transform=ax.transAxes,
+                fontsize=16,
+                ha="center",
+                va="center",
+                color="red",
+                weight="bold",
+            )
+
+        # Draw additional points if provided
+        if points_list is not None and points_list[idx] is not None:
+            show_points(
+                points_list[idx], points_labels_list[idx], ax=ax, marker_size=200
+            )
+
+        ax.axis("off")
+
+    plt.tight_layout()
+    plt.show()
+
+
+def render_masklet_frame(img, outputs, frame_idx=None, alpha=0.5):
+    """
+    Overlays masklets and bounding boxes on a single image frame.
+    Args:
+        img: np.ndarray, shape (H, W, 3), uint8 or float32 in [0,255] or [0,1]
+        outputs: dict with keys: out_boxes_xywh, out_probs, out_obj_ids, out_binary_masks
+        frame_idx: int or None, for overlaying frame index text
+        alpha: float, mask overlay alpha
+    Returns:
+        overlay: np.ndarray, shape (H, W, 3), uint8
+    """
+    if img.dtype == np.float32 or img.max() <= 1.0:
+        img = (img * 255).astype(np.uint8)
+    img = img[..., :3]  # drop alpha if present
+    height, width = img.shape[:2]
+    overlay = img.copy()
+
+    for i in range(len(outputs["out_probs"])):
+        obj_id = outputs["out_obj_ids"][i]
+        color = COLORS[obj_id % len(COLORS)]
+        color255 = (color * 255).astype(np.uint8)
+        mask = outputs["out_binary_masks"][i]
+        if mask.shape != img.shape[:2]:
+            mask = cv2.resize(
+                mask.astype(np.float32),
+                (img.shape[1], img.shape[0]),
+                interpolation=cv2.INTER_NEAREST,
+            )
+        mask_bool = mask > 0.5
+        for c in range(3):
+            overlay[..., c][mask_bool] = (
+                alpha * color255[c] + (1 - alpha) * overlay[..., c][mask_bool]
+            ).astype(np.uint8)
+
+    # Draw bounding boxes and text
+    for i in range(len(outputs["out_probs"])):
+        box_xywh = outputs["out_boxes_xywh"][i]
+        obj_id = outputs["out_obj_ids"][i]
+        prob = outputs["out_probs"][i]
+        color = COLORS[obj_id % len(COLORS)]
+        color255 = tuple(int(x * 255) for x in color)
+        x, y, w, h = box_xywh
+        x1 = int(x * width)
+        y1 = int(y * height)
+        x2 = int((x + w) * width)
+        y2 = int((y + h) * height)
+        cv2.rectangle(overlay, (x1, y1), (x2, y2), color255, 2)
+        if prob is not None:
+            label = f"id={obj_id}, p={prob:.2f}"
+        else:
+            label = f"id={obj_id}"
+        cv2.putText(
+            overlay,
+            label,
+            (x1, max(y1 - 10, 0)),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.5,
+            color255,
+            1,
+            cv2.LINE_AA,
+        )
+
+    # Overlay frame index at the top-left corner
+    if frame_idx is not None:
+        cv2.putText(
+            overlay,
+            f"Frame {frame_idx}",
+            (10, 30),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1.0,
+            (255, 255, 255),
+            2,
+            cv2.LINE_AA,
+        )
+
+    return overlay
+
+
+def save_masklet_video(video_frames, outputs, out_path, alpha=0.5, fps=10):
+    # Each outputs dict has keys: "out_boxes_xywh", "out_probs", "out_obj_ids", "out_binary_masks"
+    # video_frames: list of video frame data, same length as outputs_list
+
+    # Read first frame to get size
+    first_img = load_frame(video_frames[0])
+    height, width = first_img.shape[:2]
+    if first_img.dtype == np.float32 or first_img.max() <= 1.0:
+        first_img = (first_img * 255).astype(np.uint8)
+    # Use 'mp4v' for best compatibility with VSCode playback (.mp4 files)
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter("temp.mp4", fourcc, fps, (width, height))
+
+    outputs_list = [
+        (video_frames[frame_idx], frame_idx, outputs[frame_idx])
+        for frame_idx in sorted(outputs.keys())
+    ]
+
+    for frame, frame_idx, frame_outputs in tqdm(outputs_list):
+        img = load_frame(frame)
+        overlay = render_masklet_frame(
+            img, frame_outputs, frame_idx=frame_idx, alpha=alpha
+        )
+        writer.write(cv2.cvtColor(overlay, cv2.COLOR_RGB2BGR))
+
+    writer.release()
+
+    # Re-encode the video for VSCode compatibility using ffmpeg
+    subprocess.run(["ffmpeg", "-y", "-i", "temp.mp4", out_path])
+    print(f"Re-encoded video saved to {out_path}")
+
+    os.remove("temp.mp4")  # Clean up temporary file
+
+
+def save_masklet_image(frame, outputs, out_path, alpha=0.5, frame_idx=None):
+    """
+    Save a single image with masklet overlays.
+    """
+    img = load_frame(frame)
+    overlay = render_masklet_frame(img, outputs, frame_idx=frame_idx, alpha=alpha)
+    Image.fromarray(overlay).save(out_path)
+    print(f"Overlay image saved to {out_path}")
+
+
+def prepare_masks_for_visualization(frame_to_output):
+    # frame_to_obj_masks --> {frame_idx: {'output_probs': np.array, `out_obj_ids`: np.array, `out_binary_masks`: np.array}}
+    for frame_idx, out in frame_to_output.items():
+        _processed_out = {}
+        for idx, obj_id in enumerate(out["out_obj_ids"].tolist()):
+            if out["out_binary_masks"][idx].any():
+                _processed_out[obj_id] = out["out_binary_masks"][idx]
+        frame_to_output[frame_idx] = _processed_out
+    return frame_to_output
+
+
+def convert_coco_to_masklet_format(
+    annotations, img_info, is_prediction=False, score_threshold=0.5
+):
+    """
+    Convert COCO format annotations to format expected by render_masklet_frame
+    """
+    outputs = {
+        "out_boxes_xywh": [],
+        "out_probs": [],
+        "out_obj_ids": [],
+        "out_binary_masks": [],
+    }
+
+    img_h, img_w = img_info["height"], img_info["width"]
+
+    for idx, ann in enumerate(annotations):
+        # Get bounding box in relative XYWH format
+        if "bbox" in ann:
+            bbox = ann["bbox"]
+            if max(bbox) > 1.0:  # Convert absolute to relative coordinates
+                bbox = [
+                    bbox[0] / img_w,
+                    bbox[1] / img_h,
+                    bbox[2] / img_w,
+                    bbox[3] / img_h,
+                ]
+        else:
+            mask = mask_utils.decode(ann["segmentation"])
+            rows = np.any(mask, axis=1)
+            cols = np.any(mask, axis=0)
+            if np.any(rows) and np.any(cols):
+                rmin, rmax = np.where(rows)[0][[0, -1]]
+                cmin, cmax = np.where(cols)[0][[0, -1]]
+                # Convert to relative XYWH
+                bbox = [
+                    cmin / img_w,
+                    rmin / img_h,
+                    (cmax - cmin + 1) / img_w,
+                    (rmax - rmin + 1) / img_h,
+                ]
+            else:
+                bbox = [0, 0, 0, 0]
+
+        outputs["out_boxes_xywh"].append(bbox)
+
+        # Get probability/score
+        if is_prediction:
+            prob = ann["score"]
+        else:
+            prob = 1.0  # GT has no probability
+        outputs["out_probs"].append(prob)
+
+        outputs["out_obj_ids"].append(idx)
+        mask = mask_utils.decode(ann["segmentation"])
+        mask = (mask > score_threshold).astype(np.uint8)
+
+        outputs["out_binary_masks"].append(mask)
+
+    return outputs
+
+
+def save_side_by_side_visualization(img, gt_anns, pred_anns, noun_phrase):
+    """
+    Create side-by-side visualization of GT and predictions
+    """
+
+    # Create side-by-side visualization
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 7))
+
+    main_title = f"Noun phrase: '{noun_phrase}'"
+    fig.suptitle(main_title, fontsize=16, fontweight="bold")
+
+    gt_overlay = render_masklet_frame(img, gt_anns, alpha=0.5)
+    ax1.imshow(gt_overlay)
+    ax1.set_title("Ground Truth", fontsize=14, fontweight="bold")
+    ax1.axis("off")
+
+    pred_overlay = render_masklet_frame(img, pred_anns, alpha=0.5)
+    ax2.imshow(pred_overlay)
+    ax2.set_title("Predictions", fontsize=14, fontweight="bold")
+    ax2.axis("off")
+
+    plt.subplots_adjust(top=0.88)
+    plt.tight_layout()
+
+
+def bitget(val, idx):
+    return (val >> idx) & 1
+
+
+def pascal_color_map():
+    colormap = np.zeros((512, 3), dtype=int)
+    ind = np.arange(512, dtype=int)
+    for shift in reversed(list(range(8))):
+        for channel in range(3):
+            colormap[:, channel] |= bitget(ind, channel) << shift
+        ind >>= 3
+
+    return colormap.astype(np.uint8)
+
+
+def draw_masks_to_frame(
+    frame: np.ndarray, masks: np.ndarray, colors: np.ndarray
+) -> np.ndarray:
+    masked_frame = frame
+    for mask, color in zip(masks, colors):
+        curr_masked_frame = np.where(mask[..., None], color, masked_frame)
+        masked_frame = cv2.addWeighted(masked_frame, 0.75, curr_masked_frame, 0.25, 0)
+
+        if int(cv2.__version__[0]) > 3:
+            contours, _ = cv2.findContours(
+                np.array(mask, dtype=np.uint8).copy(),
+                cv2.RETR_TREE,
+                cv2.CHAIN_APPROX_NONE,
+            )
+        else:
+            _, contours, _ = cv2.findContours(
+                np.array(mask, dtype=np.uint8).copy(),
+                cv2.RETR_TREE,
+                cv2.CHAIN_APPROX_NONE,
+            )
+
+        cv2.drawContours(
+            masked_frame, contours, -1, (255, 255, 255), 7
+        )  # White outer contour
+        cv2.drawContours(
+            masked_frame, contours, -1, (0, 0, 0), 5
+        )  # Black middle contour
+        cv2.drawContours(
+            masked_frame, contours, -1, color.tolist(), 3
+        )  # Original color inner contour
+    return masked_frame
+
+
+def get_annot_df(file_path: str):
+    with open(file_path, "r") as f:
+        data = json.load(f)
+
+    dfs = {}
+
+    for k, v in data.items():
+        if k in ("info", "licenses"):
+            dfs[k] = v
+            continue
+        df = pd.DataFrame(v)
+        dfs[k] = df
+
+    return dfs
+
+
+def get_annot_dfs(file_list: list[str]):
+    dfs = {}
+    for annot_file in tqdm(file_list):
+        dataset_name = Path(annot_file).stem
+        dfs[dataset_name] = get_annot_df(annot_file)
+
+    return dfs
+
+
+def get_media_dir(media_dir: str, dataset: str):
+    if dataset in ["saco_veval_sav_test", "saco_veval_sav_val"]:
+        return os.path.join(media_dir, "saco_sav", "JPEGImages_24fps")
+    elif dataset in ["saco_veval_yt1b_test", "saco_veval_yt1b_val"]:
+        return os.path.join(media_dir, "saco_yt1b", "JPEGImages_6fps")
+    elif dataset in ["saco_veval_smartglasses_test", "saco_veval_smartglasses_val"]:
+        return os.path.join(media_dir, "saco_sg", "JPEGImages_6fps")
+    elif dataset == "sa_fari_test":
+        return os.path.join(media_dir, "sa_fari", "JPEGImages_6fps")
+    else:
+        raise ValueError(f"Dataset {dataset} not found")
+
+
+def get_all_annotations_for_frame(
+    dataset_df: pd.DataFrame, video_id: int, frame_idx: int, data_dir: str, dataset: str
+):
+    media_dir = os.path.join(data_dir, "media")
+
+    # Load the annotation and video data
+    annot_df = dataset_df["annotations"]
+    video_df = dataset_df["videos"]
+
+    # Get the frame
+    video_df_current = video_df[video_df.id == video_id]
+    assert (
+        len(video_df_current) == 1
+    ), f"Expected 1 video row, got {len(video_df_current)}"
+    video_row = video_df_current.iloc[0]
+    file_name = video_row.file_names[frame_idx]
+    file_path = os.path.join(
+        get_media_dir(media_dir=media_dir, dataset=dataset), file_name
+    )
+    frame = cv2.imread(file_path)
+    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+    # Get the masks and noun phrases annotated in this video in this frame
+    annot_df_current_video = annot_df[annot_df.video_id == video_id]
+    if len(annot_df_current_video) == 0:
+        print(f"No annotations found for video_id {video_id}")
+        return frame, None, None
+    else:
+        empty_mask = np.zeros(frame.shape[:2], dtype=np.uint8)
+        mask_np_pairs = annot_df_current_video.apply(
+            lambda row: (
+                (
+                    mask_utils.decode(row.segmentations[frame_idx])
+                    if row.segmentations[frame_idx]
+                    else empty_mask
+                ),
+                row.noun_phrase,
+            ),
+            axis=1,
+        )
+        # sort based on noun_phrases
+        mask_np_pairs = sorted(mask_np_pairs, key=lambda x: x[1])
+        masks, noun_phrases = zip(*mask_np_pairs)
+
+    return frame, masks, noun_phrases
+
+
+def visualize_prompt_overlay(
+    frame_idx,
+    video_frames,
+    title="Prompt Visualization",
+    text_prompt=None,
+    point_prompts=None,
+    point_labels=None,
+    bounding_boxes=None,
+    box_labels=None,
+    obj_id=None,
+):
+    """Simple prompt visualization function"""
+    img = Image.fromarray(load_frame(video_frames[frame_idx]))
+    fig, ax = plt.subplots(1, figsize=(6, 4))
+    ax.imshow(img)
+
+    img_w, img_h = img.size
+
+    if text_prompt:
+        ax.text(
+            0.02,
+            0.98,
+            f'Text: "{text_prompt}"',
+            transform=ax.transAxes,
+            fontsize=12,
+            color="white",
+            weight="bold",
+            bbox=dict(boxstyle="round,pad=0.3", facecolor="red", alpha=0.7),
+            verticalalignment="top",
+        )
+
+    if point_prompts:
+        for i, point in enumerate(point_prompts):
+            x, y = point
+            # Convert relative to absolute coordinates
+            x_img, y_img = x * img_w, y * img_h
+
+            # Use different colors for positive/negative points
+            if point_labels and len(point_labels) > i:
+                color = "green" if point_labels[i] == 1 else "red"
+                marker = "o" if point_labels[i] == 1 else "x"
+            else:
+                color = "green"
+                marker = "o"
+
+            ax.plot(
+                x_img,
+                y_img,
+                marker=marker,
+                color=color,
+                markersize=10,
+                markeredgewidth=2,
+                markeredgecolor="white",
+            )
+            ax.text(
+                x_img + 5,
+                y_img - 5,
+                f"P{i + 1}",
+                color=color,
+                fontsize=10,
+                weight="bold",
+                bbox=dict(boxstyle="round,pad=0.2", facecolor="white", alpha=0.8),
+            )
+
+    if bounding_boxes:
+        for i, box in enumerate(bounding_boxes):
+            x, y, w, h = box
+            # Convert relative to absolute coordinates
+            x_img, y_img = x * img_w, y * img_h
+            w_img, h_img = w * img_w, h * img_h
+
+            # Use different colors for positive/negative boxes
+            if box_labels and len(box_labels) > i:
+                color = "green" if box_labels[i] == 1 else "red"
+            else:
+                color = "green"
+
+            rect = patches.Rectangle(
+                (x_img, y_img),
+                w_img,
+                h_img,
+                linewidth=2,
+                edgecolor=color,
+                facecolor="none",
+            )
+            ax.add_patch(rect)
+            ax.text(
+                x_img,
+                y_img - 5,
+                f"B{i + 1}",
+                color=color,
+                fontsize=10,
+                weight="bold",
+                bbox=dict(boxstyle="round,pad=0.2", facecolor="white", alpha=0.8),
+            )
+
+    # Add object ID info if provided
+    if obj_id is not None:
+        ax.text(
+            0.02,
+            0.02,
+            f"Object ID: {obj_id}",
+            transform=ax.transAxes,
+            fontsize=10,
+            color="white",
+            weight="bold",
+            bbox=dict(boxstyle="round,pad=0.3", facecolor="blue", alpha=0.7),
+            verticalalignment="bottom",
+        )
+
+    ax.set_title(title)
+    ax.axis("off")
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_results(img, results):
+    plt.figure(figsize=(12, 8))
+    plt.imshow(img)
+    nb_objects = len(results["scores"])
+    print(f"found {nb_objects} object(s)")
+    for i in range(nb_objects):
+        color = COLORS[i % len(COLORS)]
+        plot_mask(results["masks"][i].squeeze(0).cpu(), color=color)
+        w, h = img.size
+        prob = results["scores"][i].item()
+        plot_bbox(
+            h,
+            w,
+            results["boxes"][i].cpu(),
+            text=f"(id={i}, {prob=:.2f})",
+            box_format="XYXY",
+            color=color,
+            relative_coords=False,
+        )
+
+
+def single_visualization(img, anns, title):
+    """
+    Create a single image visualization with overlays.
+    """
+    fig, ax = plt.subplots(figsize=(7, 7))
+    fig.suptitle(title, fontsize=16, fontweight="bold")
+    overlay = render_masklet_frame(img, anns, alpha=0.5)
+    ax.imshow(overlay)
+    ax.axis("off")
+    plt.tight_layout()
+
+
+def show_mask(mask, ax, obj_id=None, random_color=False):
+    if random_color:
+        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)
+    else:
+        cmap = plt.get_cmap("tab10")
+        cmap_idx = 0 if obj_id is None else obj_id
+        color = np.array([*cmap(cmap_idx)[:3], 0.6])
+    h, w = mask.shape[-2:]
+    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
+    ax.imshow(mask_image)
+
+
+def show_box(box, ax):
+    x0, y0 = box[0], box[1]
+    w, h = box[2] - box[0], box[3] - box[1]
+    ax.add_patch(
+        plt.Rectangle((x0, y0), w, h, edgecolor="green", facecolor=(0, 0, 0, 0), lw=2)
+    )
+
+
+def show_points(coords, labels, ax, marker_size=375):
+    pos_points = coords[labels == 1]
+    neg_points = coords[labels == 0]
+    ax.scatter(
+        pos_points[:, 0],
+        pos_points[:, 1],
+        color="green",
+        marker="*",
+        s=marker_size,
+        edgecolor="white",
+        linewidth=1.25,
+    )
+    ax.scatter(
+        neg_points[:, 0],
+        neg_points[:, 1],
+        color="red",
+        marker="*",
+        s=marker_size,
+        edgecolor="white",
+        linewidth=1.25,
+    )
+
+
+def load_frame(frame):
+    if isinstance(frame, np.ndarray):
+        img = frame
+    elif isinstance(frame, Image.Image):
+        img = np.array(frame)
+    elif isinstance(frame, str) and os.path.isfile(frame):
+        img = plt.imread(frame)
+    else:
+        raise ValueError(f"Invalid video frame type: {type(frame)=}")
+    return img

third_party/GraspGen/sam3/scripts/extract_odinw_results.py

@@ -0,0 +1,97 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe
+
+"""This script summarizes odinw results"""
+
+"""
+python3 scripts/extract_odinw_results.py --res_dir /path/to/results/directory
+Expected directory structure:
+results_directory/
+├── AerialMaritimeDrone_large/val_stats.json
+├── Aquarium/val_stats.json
+├── CottontailRabbits/val_stats.json
+└── ...
+"""
+import argparse
+import json
+import os
+
+VAL13_SET = [
+    "AerialMaritimeDrone_large",
+    "Aquarium",
+    "CottontailRabbits",
+    "EgoHands_generic",
+    "NorthAmericaMushrooms",
+    "Packages",
+    "PascalVOC",
+    "Raccoon",
+    "ShellfishOpenImages",
+    "VehiclesOpenImages",
+    "pistols",
+    "pothole",
+    "thermalDogsAndPeople",
+]
+
+METRIC_NAME = "coco_eval_bbox_AP"
+
+
+def parse_args():
+    parser = argparse.ArgumentParser("ODinW results aggregation script")
+
+    parser.add_argument(
+        "--res_dir",
+        required=True,
+        type=str,
+        help="Parent directory containing subdirectories for each dataset with val_stats.json files",
+    )
+
+    return parser.parse_args()
+
+
+def main(args):
+    # Dictionary to store results for each metric type
+    metric_results = {METRIC_NAME: []}
+    subset_results = {subset: {} for subset in VAL13_SET}
+
+    # Process each subset directory
+    for subset in VAL13_SET:
+        subset_dir = os.path.join(args.res_dir, subset)
+        val_stats_path = os.path.join(subset_dir, "val_stats.json")
+
+        if not os.path.exists(val_stats_path):
+            print(f"Warning: {val_stats_path} not found, skipping {subset}")
+            continue
+
+        try:
+            res = json.load(open(val_stats_path))
+            subset_results[subset] = res
+
+            # Extract metrics for this subset and group by metric type
+            for key, value in res.items():
+                if key.endswith(METRIC_NAME):
+                    metric_results[METRIC_NAME].append(value)
+
+        except (json.JSONDecodeError, IOError) as e:
+            print(f"Error reading {val_stats_path}: {e}")
+            continue
+
+    # Print results
+    values = metric_results[METRIC_NAME]
+    if values:
+        avg = sum(values) / len(values)
+        print(f"Average {METRIC_NAME}: {avg:.4f} ({len(values)} datasets)")
+
+        # Show individual dataset results
+        for subset in VAL13_SET:
+            if subset in subset_results and subset_results[subset]:
+                for res_key, res_value in subset_results[subset].items():
+                    if res_key.endswith(METRIC_NAME):
+                        print(f"  {subset}: {res_value:.4f}")
+                        break
+    else:
+        print(f"No results found for {METRIC_NAME}")
+
+
+if __name__ == "__main__":
+    main(parse_args())

third_party/GraspGen/sam3/scripts/extract_roboflow_vl100_results.py

@@ -0,0 +1,382 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# pyre-unsafe
+
+"""
+Script to extract and analyze training results from Roboflow VL100 experiments.
+
+This script processes training logs and configuration files to extract model performance
+metrics and training parameters for analysis and comparison.
+"""
+
+import argparse
+import json
+import os
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+import yaml
+
+
+# Constants
+CONFIG_FILENAME = "config_resolved.yaml"
+RESULTS_FILENAME = "val_stats.json"
+BBOX_AP_METRIC = "Meters_train/val_roboflow100/detection/coco_eval_bbox_AP"
+
+# Roboflow dataset categories organized by domain
+ROBOFLOW_CATEGORIES = {
+    "sports": [
+        "actions",
+        "aerial-pool",
+        "ball",
+        "bibdetection",
+        "football-player-detection",
+        "lacrosse-object-detection",
+    ],
+    "other": [
+        "buoy-onboarding",
+        "car-logo-detection",
+        "clashroyalechardetector",
+        "cod-mw-warzone",
+        "countingpills",
+        "everdaynew",
+        "flir-camera-objects",
+        "halo-infinite-angel-videogame",
+        "mahjong",
+        "new-defects-in-wood",
+        "orionproducts",
+        "pill",
+        "soda-bottles",
+        "taco-trash-annotations-in-context",
+        "the-dreidel-project",
+    ],
+    "aerial": [
+        "aerial-airport",
+        "aerial-cows",
+        "aerial-sheep",
+        "apoce-aerial-photographs-for-object-detection-of-construction-equipment",
+        "electric-pylon-detection-in-rsi",
+        "floating-waste",
+        "human-detection-in-floods",
+        "sssod",
+        "uavdet-small",
+        "wildfire-smoke",
+        "zebrasatasturias",
+    ],
+    "medical": [
+        "canalstenosis",
+        "crystal-clean-brain-tumors-mri-dataset",
+        "dentalai",
+        "inbreast",
+        "liver-disease",
+        "nih-xray",
+        "spinefrxnormalvindr",
+        "stomata-cells",
+        "train",
+        "ufba-425",
+        "urine-analysis1",
+        "x-ray-id",
+        "xray",
+    ],
+    "document": [
+        "activity-diagrams",
+        "all-elements",
+        "circuit-voltages",
+        "invoice-processing",
+        "label-printing-defect-version-2",
+        "macro-segmentation",
+        "paper-parts",
+        "signatures",
+        "speech-bubbles-detection",
+        "wine-labels",
+    ],
+    "industrial": [
+        "-grccs",
+        "13-lkc01",
+        "2024-frc",
+        "aircraft-turnaround-dataset",
+        "asphaltdistressdetection",
+        "cable-damage",
+        "conveyor-t-shirts",
+        "dataconvert",
+        "deeppcb",
+        "defect-detection",
+        "fruitjes",
+        "infraredimageofpowerequipment",
+        "ism-band-packet-detection",
+        "l10ul502",
+        "needle-base-tip-min-max",
+        "recode-waste",
+        "screwdetectclassification",
+        "smd-components",
+        "truck-movement",
+        "tube",
+        "water-meter",
+        "wheel-defect-detection",
+    ],
+    "flora_fauna": [
+        "aquarium-combined",
+        "bees",
+        "deepfruits",
+        "exploratorium-daphnia",
+        "grapes-5",
+        "grass-weeds",
+        "gwhd2021",
+        "into-the-vale",
+        "jellyfish",
+        "marine-sharks",
+        "orgharvest",
+        "peixos-fish",
+        "penguin-finder-seg",
+        "pig-detection",
+        "roboflow-trained-dataset",
+        "sea-cucumbers-new-tiles",
+        "thermal-cheetah",
+        "tomatoes-2",
+        "trail-camera",
+        "underwater-objects",
+        "varroa-mites-detection--test-set",
+        "wb-prova",
+        "weeds4",
+    ],
+}
+
+
+def load_jsonl_last_row(file_path: str, keys: List[str]) -> Optional[Dict[str, Any]]:
+    """
+    Load the last row from a JSONL file and extract specific keys.
+
+    Args:
+        file_path: Path to the JSONL file
+        keys: List of keys to extract from the last row
+
+    Returns:
+        Dictionary with extracted key-value pairs, or None if file not found/empty
+    """
+    if not os.path.exists(file_path):
+        print(f"Warning: File not found: {file_path}")
+        return None
+
+    last_row = None
+    try:
+        with open(file_path, "r") as file:
+            for line in file:
+                last_row = json.loads(line.strip())
+
+        if last_row is None:
+            print(f"Warning: Empty JSONL file: {file_path}")
+            return None
+
+        return {key: last_row.get(key) for key in keys}
+
+    except json.JSONDecodeError as e:
+        print(f"Error: Failed to parse JSON in {file_path}: {e}")
+        return None
+    except Exception as e:
+        print(f"Error: Failed to read {file_path}: {e}")
+        return None
+
+
+def find_config_files(directory: str, filename: str = CONFIG_FILENAME) -> List[str]:
+    """
+    Recursively find configuration files with a specific filename.
+
+    Args:
+        directory: Root directory to search
+        filename: Target filename to search for
+
+    Returns:
+        List of full paths to matching files
+    """
+    matching_files = []
+    for root, _, files in os.walk(directory):
+        # Skip code directories
+        if "/code/" in root:
+            continue
+        if filename in files:
+            matching_files.append(os.path.join(root, filename))
+    return matching_files
+
+
+def extract_config_parameters(config_path: str, keys: List[str]) -> Dict[str, Any]:
+    """
+    Extract specific parameters from a YAML configuration file.
+
+    Args:
+        config_path: Path to the YAML configuration file
+        keys: List of keys to extract from the 'scratch' section
+
+    Returns:
+        Dictionary containing extracted parameters
+    """
+    try:
+        with open(config_path, "r") as file:
+            data = yaml.safe_load(file)
+
+        # Extract parameters from scratch section
+        scratch_params = {key: data["scratch"].get(key) for key in keys}
+
+        # Add computed parameters
+        launcher = data.get("launcher", {})
+        scratch_params["batch_size"] = int(launcher.get("gpus_per_node", 1)) * int(
+            launcher.get("num_nodes", 1)
+        )
+        scratch_params["lr_scale"] = data["scratch"].get("lr_scale")
+
+        roboflow_train = data.get("roboflow_train", {})
+        scratch_params["roboflow_num_images"] = roboflow_train.get("num_images")
+
+        return scratch_params
+
+    except Exception as e:
+        print(f"Error: Failed to parse config file {config_path}: {e}")
+        return {}
+
+
+def calculate_average(values_dict: Dict[str, float]) -> float:
+    """
+    Calculate the average of values in a dictionary.
+
+    Args:
+        values_dict: Dictionary with numeric values
+
+    Returns:
+        Average of all values, or 0 if empty
+    """
+    if not values_dict:
+        return 0.0
+    return sum(values_dict.values()) / len(values_dict)
+
+
+def extract_category_results(log_dir: str, categories: List[str]) -> Dict[str, float]:
+    """
+    Extract bbox AP results for specific categories from log files.
+
+    Args:
+        log_dir: Directory containing category log subdirectories
+        categories: List of category names to extract results for
+
+    Returns:
+        Dictionary mapping category names to bbox AP scores
+    """
+    results = {}
+    metric_keys = [BBOX_AP_METRIC]
+
+    for category in categories:
+        result_file = os.path.join(log_dir, f"logs/{category}/{RESULTS_FILENAME}")
+        category_result = load_jsonl_last_row(result_file, metric_keys)
+
+        if category_result is not None and category_result[BBOX_AP_METRIC] is not None:
+            results[category] = category_result[BBOX_AP_METRIC]
+
+    return results
+
+
+def analyze_experiment_results(config_path: str) -> None:
+    """
+    Analyze results from a single experiment configuration.
+
+    Args:
+        config_path: Path to the experiment configuration file
+    """
+    print("=" * 80)
+    print(f"Analyzing experiment: {config_path}")
+    print("=" * 80)
+
+    # Extract configuration parameters
+    config_keys = [
+        "lr_transformer",
+        "lr_vision_backbone",
+        "lr_language_backbone",
+        "max_data_epochs",
+    ]
+
+    config_params = extract_config_parameters(config_path, config_keys)
+    print("Configuration Parameters:")
+    for key, value in config_params.items():
+        print(f"  {key}: {value}")
+    print()
+
+    # Extract results for each category
+    experiment_dir = os.path.dirname(config_path)
+    category_results = {}
+    category_averages = {}
+    all_scores = []
+
+    for super_category, categories in ROBOFLOW_CATEGORIES.items():
+        category_results[super_category] = extract_category_results(
+            experiment_dir, categories
+        )
+
+        if category_results[super_category]:
+            category_averages[super_category] = calculate_average(
+                category_results[super_category]
+            )
+            all_scores.extend(category_results[super_category].values())
+
+    # Print results summary
+    print("Results by Category:")
+    for super_category, avg_score in category_averages.items():
+        num_categories = len(category_results[super_category])
+        print(f"  {super_category}: {avg_score:.4f} (n={num_categories})")
+
+    print(f"\nOverall Results:")
+    print(f"  Weighted average: {calculate_average(category_averages):.4f}")
+    print(f"  Total categories: {len(all_scores)}")
+    print(f"  True average: {sum(all_scores) / len(all_scores):.4f}")
+    print()
+
+
+def print_results_table(results_data: List[Dict[str, Any]]) -> None:
+    """
+    Print results in a formatted table.
+
+    Args:
+        results_data: List of dictionaries containing results data
+    """
+    if not results_data:
+        print("No results data to display.")
+        return
+
+    df = pd.DataFrame(results_data)
+    print("\nResults Summary Table:")
+    print("=" * 60)
+    print(df.to_string(index=False))
+
+
+def main() -> None:
+    """Main function to orchestrate the results extraction and analysis."""
+    parser = argparse.ArgumentParser(
+        description="Extract and analyze Roboflow VL100 training results"
+    )
+    parser.add_argument(
+        "-p",
+        "--path",
+        type=str,
+        required=True,
+        help="Root directory path containing experiment results",
+    )
+
+    args = parser.parse_args()
+
+    # Find all configuration files
+    config_files = find_config_files(args.path, CONFIG_FILENAME)
+
+    if not config_files:
+        print(f"No configuration files found in {args.path}")
+        return
+
+    print(f"Found {len(config_files)} experiment configurations")
+    print()
+
+    # Analyze each experiment
+    for config_file in config_files:
+        try:
+            analyze_experiment_results(config_file)
+        except Exception as e:
+            print(f"Error analyzing {config_file}: {e}")
+            continue
+
+
+if __name__ == "__main__":
+    main()

third_party/tuntunclaw/manipulator_grasp/arm/controller/adaptive_controller/__init__.py

@@ -0,0 +1 @@
+from .adaptive_controller import AdaptiveController

third_party/tuntunclaw/manipulator_grasp/arm/controller/adaptive_controller/adaptive_controller.py

@@ -0,0 +1,44 @@
+import numpy as np
+
+from ..controller import Controller
+from arm.robot import Robot
+
+
+class AdaptiveController(Controller):
+    def __init__(self, kds: list, robot: Robot, ts=0.001, filter_coefficient=100.0) -> None:
+        super().__init__()
+        self._robot = robot
+        parameters = self._robot.inertial_parameters
+        parameters[0:30] *= 0.8
+        self._robot.inertial_parameters = parameters
+        self._qd_prev = np.zeros(robot.dof)
+        self._dqd_prev = np.zeros(robot.dof)
+        self._q_prev = np.zeros(robot.dof)
+        self._kds = np.array(kds)
+        self._ts = ts
+        self._Fai = 5.0 * np.ones(self._robot.dof)
+        self._Tau = np.zeros(self._robot.inertial_parameters.size)
+        self._Tau[:30] = 0.2
+
+    def control(self, qd, q):
+        dqd: np.ndarray = (qd - self._qd_prev) / self._ts
+        ddqd: np.ndarray = (dqd - self._dqd_prev) / self._ts
+        dq: np.ndarray = (q - self._q_prev) / self._ts
+
+        dqr = dqd + self._Fai * (qd - q)
+        ddqr = ddqd + self._Fai * (dqd - dq)
+
+        tau = self._robot.inv_dynamics_adaptive(q, dq, dqr, ddqr) + self._kds * (dqr - dq)
+
+        self._update(q, dq, dqr, ddqr)
+        self._qd_prev = np.array(qd)
+        self._dqd_prev = np.array(dqd)
+        self._q_prev = np.array(q)
+
+        return tau
+
+    def _update(self, q, dq, dqr, ddqr):
+        Y = self._robot.get_adaptive_identification_matrix(q, dq, dqr, ddqr)
+        r = dqr - dq
+        dp = self._Tau * (Y.T @ r)
+        self._robot.inertial_parameters += dp * self._ts

third_party/tuntunclaw/manipulator_grasp/arm/controller/computed_torque_controller/__init__.py

@@ -0,0 +1 @@
+from .computed_torque_controller import ComputedTorqueController

third_party/tuntunclaw/manipulator_grasp/arm/controller/computed_torque_controller/computed_torque_controller.py

@@ -0,0 +1,30 @@
+import numpy as np
+
+from ..controller import Controller
+from ..pid_controller import PIDController
+from arm.robot import Robot
+
+
+class ComputedTorqueController(Controller):
+
+    def __init__(self, kps: list, kis: list, kds: list, robot: Robot, ts=0.001, filter_coefficient=100.0) -> None:
+        self._robot = robot
+        self._pid_controllers = [PIDController(kps[i], kis[i], kds[i], ts, filter_coefficient) for i in
+                                 range(robot.dof)]
+        self._qd_prev = np.zeros(robot.dof)
+        self._dqd_prev = np.zeros(robot.dof)
+        self._ts = ts
+
+    def control(self, qd, q):
+        dqd: np.ndarray = (qd - self._qd_prev) / self._ts
+        ddqd: np.ndarray = (dqd - self._dqd_prev) / self._ts
+
+        pid_outs = [self._pid_controllers[i].control(qd[i], q[i]) for i in range(self._robot.dof)]
+
+        self._qd_prev = np.array(qd)
+        self._dqd_prev = np.array(dqd)
+
+        return self._robot.inv_dynamics(qd, dqd, ddqd + pid_outs)
+
+    def set_qd(self, qd: np.ndarray):
+        self._qd_prev = qd.copy()

third_party/tuntunclaw/manipulator_grasp/arm/controller/feedforward_controller/__init__.py

@@ -0,0 +1 @@
+from .feedforward_controller import FeedforwardController

third_party/tuntunclaw/manipulator_grasp/arm/controller/feedforward_controller/feedforward_controller.py

@@ -0,0 +1,26 @@
+import numpy as np
+
+from ..controller import Controller
+from ..pid_controller import PIDController
+from arm.robot import Robot
+
+
+class FeedforwardController(Controller):
+    def __init__(self, kps: list, kis: list, kds: list, robot: Robot, ts=0.001, filter_coefficient=100.0) -> None:
+        self._robot = robot
+        self._pid_controllers = [PIDController(kps[i], kis[i], kds[i], ts, filter_coefficient) for i in range(robot.dof)]
+        self._qd_prev = np.zeros(robot.dof)
+        self._dqd_prev = np.zeros(robot.dof)
+        self._ts = ts
+
+    def control(self, inpd, inp, qd):
+        dqd = (qd - self._qd_prev) / self._ts
+        ddqd = (dqd - self._dqd_prev) / self._ts
+        feedforward_outs = self._robot.inv_dynamics(qd, dqd, ddqd)
+
+        pid_outs = [self._pid_controllers[i].control(inpd[i], inp[i]) for i in range(self._robot.dof)]
+
+        self._qd_prev = np.array(qd)
+        self._dqd_prev = np.array(dqd)
+
+        return feedforward_outs + pid_outs

third_party/tuntunclaw/manipulator_grasp/arm/controller/pid_controller/__init__.py

@@ -0,0 +1 @@
+from .pid_controller import PIDController

third_party/tuntunclaw/manipulator_grasp/arm/controller/pid_controller/pid_controller.py

@@ -0,0 +1,77 @@
+import numpy as np
+
+from ..controller import Controller
+
+
+class PIDController(Controller):
+    """
+    backward euler and use filtered derivative
+    """
+
+    def __init__(self, kp: float, ki: float, kd: float, ts=0.001, filter_coefficient=100.0):
+        self.__kp = kp
+        self.__ki = ki
+        self.__kd = kd
+        self.__filter_coefficient = filter_coefficient
+
+        self.__ts = ts
+        self.__error_prev = 0.0
+        self.__error_integral = 0.0
+        self.__error_derivative = 0.0
+
+    def control(self, qd, q):
+        error = np.array(qd) - np.array(q)
+        self.__error_integral += error * self.__ts
+
+        # derivative = (inp - self.__prev_input) / self.__ts
+        self.__error_derivative = (self.__filter_coefficient * (
+                error - self.__error_prev) + self.__error_derivative) / (
+                                          self.__filter_coefficient * self.__ts + 1.0)
+        # self.__prev_derivative_out = derivative
+        output = self.__kp * error + self.__ki * self.__error_integral + self.__kd * self.__error_derivative
+
+        self.__error_prev = error
+
+        return output
+
+    def reset(self):
+        self.__error_prev = 0.0
+        self.__error_integral = 0.0
+        self.__error_derivative = 0.0
+
+    @property
+    def ts(self):
+        return self.__ts
+
+    @ts.setter
+    def ts(self, ts):
+        self.__ts = ts
+
+    @property
+    def kp(self):
+        return self.__kp
+
+    @property
+    def ki(self):
+        return self.__ki
+
+    @property
+    def kd(self):
+        return self.__kd
+
+    @kp.setter
+    def kp(self, kp):
+        self.__kp = kp
+
+    @ki.setter
+    def ki(self, ki):
+        self.__ki = ki
+
+    @kd.setter
+    def kd(self, kd):
+        self.__kd = kd
+
+    def set_parameter(self, kp: float, ki: float, kd: float):
+        self.__kp = kp
+        self.__ki = ki
+        self.__kd = kd

third_party/tuntunclaw/manipulator_grasp/arm/geometry/collision/GJK.py

@@ -0,0 +1,125 @@
+import copy
+from typing import Tuple
+
+import numpy as np
+
+from arm.constanst import MathConst
+from ..simplex import Point, SimplexFactoryPool, SimplexParameter, UnitVector, Support
+
+
+class GJK:
+
+    @staticmethod
+    def calculate_distance(shape0: Support, shape1: Support) -> float:
+
+        return GJK.calculate_distance_and_points(shape0, shape1)[0]
+
+    @staticmethod
+    def calculate_distance_and_points(shape0: Support, shape1: Support) -> Tuple[float, Tuple]:
+        vec = UnitVector(np.array([1, 0, 0]))
+        point0 = shape0.calculate_support_point(vec)
+        point1 = shape1.calculate_support_point(-vec)
+        point = point0 - point1
+
+        origin = Point([0, 0, 0])
+
+        closest_point = point
+        comparator = lambda x: np.linalg.norm(x.get_t())
+        points = [point]
+        points0 = [point0]
+        points1 = [point1]
+
+        coordinates = [1]
+
+        finish = False
+
+        while closest_point != origin:
+            closest = copy.deepcopy(closest_point)
+            vec = -UnitVector(closest_point)
+            point0 = shape0.calculate_support_point(vec)
+            point1 = shape1.calculate_support_point(-vec)
+            point = point0 - point1
+
+            for point_i in points:
+                if np.linalg.norm((point - point_i).get_t()) < MathConst.ERROR:
+                    finish = True
+                    break
+            if finish:
+                break
+
+            points.append(point)
+            points0.append(point0)
+            points1.append(point1)
+
+            if len(points) == 5:
+                coordinate_min = min(coordinates)
+                coordinate_min_index = coordinates.index(coordinate_min)
+                points.pop(coordinate_min_index)
+                points0.pop(coordinate_min_index)
+                points1.pop(coordinate_min_index)
+                break
+
+            simplex_parameter = SimplexParameter(points)
+            simplex = SimplexFactoryPool.create_product(simplex_parameter)
+            closest_point = simplex.calculate_closest_point_to_origin()
+            coordinates = simplex.calculate_barycentric_coordinates(closest_point)
+
+            if np.linalg.norm((closest - closest_point).get_t()) < MathConst.EPS:
+                break
+
+            j = 0
+            for i, coordinate in enumerate(coordinates):
+                if abs(coordinate) < MathConst.EPS:
+                    points.pop(i - j)
+                    points0.pop(i - j)
+                    points1.pop(i - j)
+                    j = j + 1
+
+        simplex_parameter = SimplexParameter(points)
+        simplex = SimplexFactoryPool.create_product(simplex_parameter)
+        coordinates = simplex.calculate_barycentric_coordinates(closest_point)
+
+        point0 = Point(np.zeros_like(point0.get_t()))
+        point1 = Point(np.zeros_like(point1.get_t()))
+        for i, coordinate_i in enumerate(coordinates):
+            point0 += coordinate_i * points0[i]
+            point1 += coordinate_i * points1[i]
+
+        return np.linalg.norm(closest_point.get_t()), (point0, point1)
+
+    @staticmethod
+    def is_intersecting(shape0: Support, shape1: Support):
+        origin = Point([0, 0, 0])
+        unit_vector = UnitVector(np.array([1, 0, 0]))
+
+        point = shape0.calculate_support_point(unit_vector) - shape1.calculate_support_point(-unit_vector)
+        points = [point]
+        closest_point = point
+
+        coordinates = [1]
+
+        while closest_point != origin:
+            unit_vector = -UnitVector(closest_point)
+            point = shape0.calculate_support_point(unit_vector) - shape1.calculate_support_point(-unit_vector)
+            if np.dot(point.get_t(), unit_vector.get_t()) < 0:
+                return False
+            points.append(point)
+
+            if len(points) == 5:
+                coordinate_min = min(coordinates)
+                coordinate_min_index = coordinates.index(coordinate_min)
+                points.pop(coordinate_min_index)
+                break
+
+            simplex_parameter = SimplexParameter(points)
+            simplex = SimplexFactoryPool.create_product(simplex_parameter)
+            closest_point = simplex.calculate_closest_point_to_origin()
+            coordinates = simplex.calculate_barycentric_coordinates(closest_point)
+
+            j = 0
+            for i, coordinate in enumerate(coordinates):
+                if abs(coordinate) < MathConst.EPS:
+                    points.pop(i - j)
+                    j = j + 1
+
+        return True

third_party/tuntunclaw/manipulator_grasp/arm/geometry/collision/__init__.py

@@ -0,0 +1,6 @@
+from .distance2d import Distance2D
+from .intersect2d import Intersect2D
+from .collision2d import Collision2D
+from .GJK import GJK
+from .distance import Distance
+from .colliison import Collision

third_party/tuntunclaw/manipulator_grasp/arm/geometry/collision/colliison.py

@@ -0,0 +1,9 @@
+from ..simplex import Support
+from .GJK import GJK
+
+
+class Collision:
+
+    @staticmethod
+    def is_collision(shape0: Support, shape1: Support) -> bool:
+        return GJK.is_intersecting(shape0, shape1)

third_party/tuntunclaw/manipulator_grasp/arm/geometry/collision/collision2d.py

@@ -0,0 +1,30 @@
+import copy
+from typing import Iterable
+
+from ..simplex import Point, Line, LineSegment
+from ..shape import Circle2D
+from .intersect2d import Intersect2D
+
+
+class Collision2D:
+    def __init__(self, obstacles: Iterable[Circle2D]) -> None:
+        super().__init__()
+        self.obstacles = copy.deepcopy(obstacles)
+
+    def check_point(self, point: Point) -> bool:
+        for obstacle in self.obstacles:
+            if Intersect2D.check_point_to_circle(point, obstacle):
+                return True
+        return False
+
+    def check_line(self, line: Line):
+        for obstacle in self.obstacles:
+            if Intersect2D.check_line_to_circle(line, obstacle):
+                return True
+        return False
+
+    def check_line_segment(self, line_segment: LineSegment):
+        for obstacle in self.obstacles:
+            if Intersect2D.check_line_segment_to_circle(line_segment, obstacle):
+                return True
+        return False

third_party/tuntunclaw/manipulator_grasp/arm/geometry/collision/distance.py

@@ -0,0 +1,195 @@
+from typing import Tuple
+import numpy as np
+from spatialmath import SE3
+
+from ..simplex import Point, Line, LineSegment, Support
+from ..shape import Plane, Brick
+from .GJK import GJK
+
+
+class Distance:
+    @staticmethod
+    def point_to_point(point0: Point, point1: Point):
+        return np.linalg.norm((point1 - point0).get_t())
+
+    @staticmethod
+    def point_to_plane(point: Point, plane: Plane):
+        return np.dot(point.get_t() - plane.get_t(), plane.get_normal_vector())
+
+    @staticmethod
+    def point_to_line(point: Point, line: Line) -> float:
+        foot_point, t = Distance.__calculate_foot_point(point, line)
+        return np.linalg.norm(point.get_t() - foot_point)
+
+    @staticmethod
+    def point_to_line_segment(point: Point, line_segment: LineSegment) -> float:
+        foot_point, t = Distance.__calculate_foot_point(point, line_segment)
+
+        t = max(0, min(1, t))
+
+        projection = line_segment.get_point0().get_t() + t * (
+                line_segment.get_point1().get_t() - line_segment.get_point0().get_t())
+        return np.linalg.norm(point.get_t() - projection)
+
+    @staticmethod
+    def point_to_brick(point: Point, brick: Brick):
+        p = brick.base.inv() * SE3.Trans(*point.get_t()).t
+        p = p.squeeze()
+
+        if p[2] < -brick.dimensions[2] / 2.0:
+            if p[1] < -brick.dimensions[1] / 2.0:
+                if p[0] < -brick.dimensions[0] / 2.0:
+                    return Distance.point_to_point(point, brick.xn_yn_zn_point)
+                if p[0] > brick.dimensions[0] / 2.0:
+                    return Distance.point_to_point(point, brick.xp_yn_zn_point)
+                else:
+                    return Distance.point_to_line_segment(point, brick.yn_zn_line_segment)
+            elif p[1] > brick.dimensions[1] / 2.0:
+                if p[0] < -brick.dimensions[0] / 2.0:
+                    return Distance.point_to_point(point, brick.xp_yn_zn_point)
+                if p[0] > brick.dimensions[0] / 2.0:
+                    return Distance.point_to_point(point, brick.xp_yp_zn_point)
+                else:
+                    return Distance.point_to_line_segment(point, brick.yp_zn_line_segment)
+            else:
+                if p[0] < -brick.dimensions[0] / 2.0:
+                    return Distance.point_to_line_segment(point, brick.xn_zn_line_segment)
+                if p[0] > brick.dimensions[0] / 2.0:
+                    return Distance.point_to_line_segment(point, brick.xp_zn_line_segment)
+                else:
+                    return Distance.point_to_plane(point, brick.zn_plane)
+        elif p[2] > brick.dimensions[2] / 2.0:
+            if p[1] < -brick.dimensions[1] / 2.0:
+                if p[0] < -brick.dimensions[0] / 2.0:
+                    return Distance.point_to_point(point, brick.xn_yn_zp_point)
+                if p[0] > brick.dimensions[0] / 2.0:
+                    return Distance.point_to_point(point, brick.xp_yn_zp_point)
+                else:
+                    return Distance.point_to_line_segment(point, brick.yn_zp_line_segment)
+            elif p[1] > brick.dimensions[1] / 2.0:
+                if p[0] < -brick.dimensions[0] / 2.0:
+                    return Distance.point_to_point(point, brick.xp_yn_zp_point)
+                if p[0] > brick.dimensions[0] / 2.0:
+                    return Distance.point_to_point(point, brick.xp_yp_zp_point)
+                else:
+                    return Distance.point_to_line_segment(point, brick.yp_zp_line_segment)
+            else:
+                if p[0] < -brick.dimensions[0] / 2.0:
+                    return Distance.point_to_line_segment(point, brick.xn_zp_line_segment)
+                if p[0] > brick.dimensions[0] / 2.0:
+                    return Distance.point_to_line_segment(point, brick.xp_zp_line_segment)
+                else:
+                    return Distance.point_to_plane(point, brick.zp_plane)
+        else:
+            if p[1] < -brick.dimensions[1] / 2.0:
+                if p[0] < -brick.dimensions[0] / 2.0:
+                    return Distance.point_to_line_segment(point, brick.xn_yn_line_segment)
+                if p[0] > brick.dimensions[0] / 2.0:
+                    return Distance.point_to_line_segment(point, brick.xp_yn_line_segment)
+                else:
+                    return Distance.point_to_plane(point, brick.yn_plane)
+                    pass
+            elif p[1] > brick.dimensions[1] / 2.0:
+                if p[0] < -brick.dimensions[0] / 2.0:
+                    return Distance.point_to_line_segment(point, brick.xn_yp_line_segment)
+                if p[0] > brick.dimensions[0] / 2.0:
+                    return Distance.point_to_line_segment(point, brick.xp_yp_line_segment)
+                else:
+                    return Distance.point_to_plane(point, brick.yp_plane)
+            else:
+                if p[0] < -brick.dimensions[0] / 2.0:
+                    return Distance.point_to_plane(point, brick.xn_plane)
+                if p[0] > brick.dimensions[0] / 2.0:
+                    return Distance.point_to_plane(point, brick.xp_plane)
+                else:
+                    return -1.0
+        return -1.0
+
+    @staticmethod
+    def line_segment_to_line_segment(line_segment0: LineSegment, line_segment1: LineSegment):
+        a = np.power(np.linalg.norm(line_segment0.get_point1().get_t() - line_segment0.get_point0().get_t()), 2)
+        b = np.dot(line_segment0.get_point1().get_t() - line_segment0.get_point0().get_t(),
+                   line_segment1.get_point1().get_t() - line_segment1.get_point0().get_t())
+        c = np.power(np.linalg.norm(line_segment1.get_point1().get_t() - line_segment1.get_point0().get_t()), 2)
+        d = np.dot(line_segment0.get_point1().get_t() - line_segment0.get_point0().get_t(),
+                   line_segment0.get_point0().get_t() - line_segment1.get_point0().get_t())
+        e = np.dot(line_segment1.get_point1().get_t() - line_segment1.get_point0().get_t(),
+                   line_segment0.get_point0().get_t() - line_segment1.get_point0().get_t())
+        f = np.power(np.linalg.norm(line_segment0.get_point0().get_t() - line_segment1.get_point0().get_t()), 2)
+
+        det = a * c - np.power(b, 2)
+        if det > 0.0:
+            bte = b * e
+            ctd = c * d
+            if bte <= ctd:
+                if e <= 0.0:
+                    s = 1.0 if -d >= a else (-d / a if -d > 0.0 else 0.0)
+                    t = 0.0
+                elif e < c:
+                    s = 0.0
+                    t = e / c
+                else:
+                    s = 1.0 if b - d >= a else ((b - d) / a if b - d > 0.0 else 0.0)
+                    t = 1.0
+            else:
+                s = bte - ctd
+                if s >= det:
+                    if b + e <= 0.0:
+                        s = 0.0 if -d <= 0.0 else (-d / a if -d < a else 1.0)
+                        t = 1.0
+                    elif b + e < c:
+                        s = 1.0
+                        t = (b + e) / c
+                    else:
+                        s = (0.0 if b - d <= 0 else ((b - d) / a if b - d < a else 1.0))
+                        t = 1.0
+                else:
+                    ate = a * e
+                    btd = b * d
+                    if ate < btd:
+                        s = 0.0 if -d <= 0.0 else (1.0 if -d >= a else -d / a)
+                        t = 0.0
+                    else:
+                        t = ate - btd
+                        if t >= det:
+                            s = 0.0 if b - d <= 0.0 else (1.0 if b - d >= a else (b - d) / a)
+                            t = 1.0
+                        else:
+                            s /= det
+                            t /= det
+        else:
+            if e <= 0.0:
+                s = 0.0 if -d <= 0.0 else (1.0 if -d >= a else -d / a)
+                t = 0.0
+            elif e >= c:
+                s = 0.0 if b - d <= 0.0 else (1.0 if b - d >= a else (b - d) / a)
+                t = 1.0
+            else:
+                s = 0.0
+                t = e / c
+
+        distance = np.sqrt(a * np.power(s, 2) - 2 * b * s * t + c * np.power(t, 2) + 2 * d * s - 2 * e * t + f)
+
+        return distance
+
+    @staticmethod
+    def __calculate_foot_point(point: Point, line: Line) -> tuple:
+        v = line.get_point0().get_t()
+        w = line.get_point1().get_t()
+        p = point.get_t()
+
+        if np.array_equal(v, w):
+            return np.linalg.norm(p - v), 0
+        l2 = (w - v).dot(w - v)
+
+        t = (p - v).dot(w - v) / l2
+        foot_point = v + t * (w - v)
+        return foot_point, t
+
+    @staticmethod
+    def calculate_distance(shape0: Support, shape1: Support) -> float:
+        return GJK.calculate_distance(shape0, shape1)
+
+    @staticmethod
+    def calculate_distance_and_points(shape0: Support, shape1: Support) -> Tuple[float, Tuple]:
+        return GJK.calculate_distance_and_points(shape0, shape1)

third_party/tuntunclaw/manipulator_grasp/arm/geometry/collision/distance2d.py

@@ -0,0 +1,51 @@
+import numpy as np
+
+from ..simplex import Point, Line, LineSegment
+from ..shape import Circle2D
+
+
+class Distance2D:
+    @staticmethod
+    def point_to_point(point0: Point, point1: Point) -> float:
+        return np.linalg.norm((point1 - point0).get_t())
+
+    @staticmethod
+    def point_to_line_segment(point: Point, line_segment: LineSegment) -> float:
+        foot_point, t = Distance2D.__calculate_foot_point(point, line_segment)
+
+        t = max(0, min(1, t))
+
+        projection = line_segment.get_point0().get_t() + t * (
+                line_segment.get_point1().get_t() - line_segment.get_point0().get_t())
+        return np.linalg.norm(point.get_t() - projection)
+
+    @staticmethod
+    def point_to_line(point: Point, line: Line) -> float:
+        foot_point, t = Distance2D.__calculate_foot_point(point, line)
+        return np.linalg.norm(point.get_t() - foot_point)
+
+    @staticmethod
+    def point_to_circle(point: Point, circle: Circle2D) -> float:
+        return Distance2D.point_to_point(point, circle.get_center()) - circle.get_radius()
+
+    @staticmethod
+    def line_to_circle(line: Line, circle: Circle2D) -> float:
+        return Distance2D.point_to_line(circle.get_center(), line) - circle.get_radius()
+
+    @staticmethod
+    def line_segment_to_circle(line_segment: LineSegment, circle: Circle2D) -> float:
+        return Distance2D.point_to_line_segment(circle.get_center(), line_segment) - circle.get_radius()
+
+    @staticmethod
+    def __calculate_foot_point(point: Point, line: Line) -> tuple:
+        v = line.get_point0().get_t()
+        w = line.get_point1().get_t()
+        p = point.get_t()
+
+        if np.array_equal(v, w):
+            return np.linalg.norm(p - v), 0
+        l2 = (w - v).dot(w - v)
+
+        t = (p - v).dot(w - v) / l2
+        foot_point = v + t * (w - v)
+        return foot_point, t

third_party/tuntunclaw/manipulator_grasp/arm/geometry/collision/intersect2d.py

@@ -0,0 +1,18 @@
+from ..simplex import Point, Line, LineSegment
+from ..shape import Circle2D
+from .distance2d import Distance2D
+
+
+class Intersect2D:
+
+    @staticmethod
+    def check_point_to_circle(point: Point, circle: Circle2D) -> bool:
+        return Distance2D.point_to_circle(point, circle) <= 0.0
+
+    @staticmethod
+    def check_line_to_circle(line: Line, circle: Circle2D):
+        return Distance2D.line_to_circle(line, circle) <= 0.0
+
+    @staticmethod
+    def check_line_segment_to_circle(line_segment: LineSegment, circle: Circle2D):
+        return Distance2D.line_segment_to_circle(line_segment, circle) <= 0.0

third_party/tuntunclaw/manipulator_grasp/arm/geometry/rotation/SE3Impl.py

@@ -0,0 +1,75 @@
+from typing import overload, Union, List
+
+from spatialmath import SE3, SO3, SE2
+from spatialmath.base import ArrayLike3, SE3Array
+
+from .SO3Impl import SO3Impl
+
+
+class SE3Impl(SE3):
+    @overload
+    def __init__(self):
+        ...
+
+    @overload
+    def __init__(self, x: Union[SE3, SO3, SE2], *, check=True):  # copy/promote
+        ...
+
+    @overload
+    def __init__(self, x: List[SE3], *, check=True):  # import list of SE3
+        ...
+
+    @overload
+    def __init__(self, x: float, y: float, z: float, *, check=True):  # pure translation
+        ...
+
+    @overload
+    def __init__(self, x: ArrayLike3, *, check=True):  # pure translation
+        ...
+
+    @overload
+    def __init__(self, x: SE3Array, *, check=True):  # import native array
+        ...
+
+    @overload
+    def __init__(self, x: List[SE3Array], *, check=True):  # import native arrays
+        ...
+
+    def __init__(self, x=None, y=None, z=None, *, check=True):
+        super().__init__(x, y, z, check=check)
+
+    def __add__(left, right):
+        if isinstance(right, SE3):
+            R = SO3Impl(left.R) + SO3Impl(right.R)
+            t = left.t + right.t
+            T = SE3(t) * SE3(R)
+            return SE3Impl(T.A)
+        return super().__add__(right)
+
+    def __sub__(left, right):
+        if isinstance(right, SE3):
+            R = SO3Impl(left.R) - SO3Impl(right.R)
+            t = left.t - right.t
+            T = SE3(t) * SE3(R)
+            return SE3Impl(T.A)
+        return super().__sub__(right)
+
+    def __mul__(left, right):
+        if isinstance(right, SE3):
+            return SE3Impl(super().__mul__(right.A))
+        elif isinstance(right, (float, int)):
+            R = SO3Impl(left.R) * right
+            t = left.t * right
+            T = SE3(t) * SE3(R)
+            return SE3Impl(T.A)
+        return super().__mul__(right)
+
+    def __rmul__(right, left):
+        if isinstance(left, SE3):
+            return SE3Impl(super().__rmul__(left.A))
+        elif isinstance(left, (float, int)):
+            R = SO3Impl(right.R) * left
+            t = right.t * left
+            T = SE3(t) * SE3(R)
+            return SE3Impl(T.A)
+        return super().__rmul__(left)