Initial commit of Gradio app

.gitattributes

@@ -33,3 +33,17 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Miniconda3-latest-MacOSX-arm64.sh filter=lfs diff=lfs merge=lfs -text
+assets/application.png filter=lfs diff=lfs merge=lfs -text
+assets/arch.jpg filter=lfs diff=lfs merge=lfs -text
+assets/panorama1.gif filter=lfs diff=lfs merge=lfs -text
+assets/panorama2.gif filter=lfs diff=lfs merge=lfs -text
+assets/quick_look.gif filter=lfs diff=lfs merge=lfs -text
+assets/roaming_world.gif filter=lfs diff=lfs merge=lfs -text
+assets/teaser.png filter=lfs diff=lfs merge=lfs -text
+examples/case1/input.png filter=lfs diff=lfs merge=lfs -text
+examples/case2/input.png filter=lfs diff=lfs merge=lfs -text
+examples/case3/input.png filter=lfs diff=lfs merge=lfs -text
+examples/case5/input.png filter=lfs diff=lfs merge=lfs -text
+examples/case6/input.png filter=lfs diff=lfs merge=lfs -text
+examples/case8/input.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+# Ignore Python bytecode files
+__pycache__/
+*.pyc

LICENSE

@@ -0,0 +1,81 @@
+TENCENT HUNYUANWORLD-1.0 COMMUNITY LICENSE AGREEMENT
+Tencent HunyuanWorld-1.0 Release Date: July 27, 2025
+THIS LICENSE AGREEMENT DOES NOT APPLY IN THE EUROPEAN UNION, UNITED KINGDOM AND SOUTH KOREA AND IS EXPRESSLY LIMITED TO THE TERRITORY, AS DEFINED BELOW.
+By clicking to agree or by using, reproducing, modifying, distributing, performing or displaying any portion or element of the Tencent HunyuanWorld-1.0 Works, including via any Hosted Service, You will be deemed to have recognized and accepted the content of this Agreement, which is effective immediately.
+1.	DEFINITIONS.
+a.	“Acceptable Use Policy” shall mean the policy made available by Tencent as set forth in the Exhibit A.
+b.	“Agreement” shall mean the terms and conditions for use, reproduction, distribution, modification, performance and displaying of Tencent HunyuanWorld-1.0 Works or any portion or element thereof set forth herein.
+c.	“Documentation” shall mean the specifications, manuals and documentation for Tencent HunyuanWorld-1.0 made publicly available by Tencent.
+d.	“Hosted Service” shall mean a hosted service offered via an application programming interface (API), web access, or any other electronic or remote means.
+e.	“Licensee,” “You” or “Your” shall mean a natural person or legal entity exercising the rights granted by this Agreement and/or using the Tencent HunyuanWorld-1.0 Works for any purpose and in any field of use.
+f.	“Materials” shall mean, collectively, Tencent’s proprietary Tencent HunyuanWorld-1.0 and Documentation (and any portion thereof) as made available by Tencent under this Agreement.
+g.	“Model Derivatives” shall mean all: (i) modifications to Tencent HunyuanWorld-1.0 or any Model Derivative of Tencent HunyuanWorld-1.0; (ii) works based on Tencent HunyuanWorld-1.0 or any Model Derivative of Tencent HunyuanWorld-1.0; or (iii) any other machine learning model which is created by transfer of patterns of the weights, parameters, operations, or Output of Tencent HunyuanWorld-1.0 or any Model Derivative of Tencent HunyuanWorld-1.0, to that model in order to cause that model to perform similarly to Tencent HunyuanWorld-1.0 or a Model Derivative of Tencent HunyuanWorld-1.0, including distillation methods, methods that use intermediate data representations, or methods based on the generation of synthetic data Outputs by Tencent HunyuanWorld-1.0 or a Model Derivative of Tencent HunyuanWorld-1.0 for training that model. For clarity, Outputs by themselves are not deemed Model Derivatives.
+h.	“Output” shall mean the information and/or content output of Tencent HunyuanWorld-1.0 or a Model Derivative that results from operating or otherwise using Tencent HunyuanWorld-1.0 or a Model Derivative, including via a Hosted Service.
+i.	“Tencent,” “We” or “Us” shall mean the applicable entity or entities in the Tencent corporate family that own(s) intellectual property or other rights embodied in or utilized by the Materials..
+j.	“Tencent HunyuanWorld-1.0” shall mean the 3D generation models and their software and algorithms, including trained model weights, parameters (including optimizer states), machine-learning model code, inference-enabling code, training-enabling code, fine-tuning enabling code and other elements of the foregoing made publicly available by Us at [https://github.com/Tencent-Hunyuan/HunyuanWorld-1.0].
+k.	“Tencent HunyuanWorld-1.0 Works” shall mean: (i) the Materials; (ii) Model Derivatives; and (iii) all derivative works thereof.
+l.	“Territory” shall mean the worldwide territory, excluding the territory of the European Union, United Kingdom and South Korea. 
+m.	“Third Party” or “Third Parties” shall mean individuals or legal entities that are not under common control with Us or You.
+n.	“including” shall mean including but not limited to.
+2.	GRANT OF RIGHTS.
+We grant You, for the Territory only, a non-exclusive, non-transferable and royalty-free limited license under Tencent’s intellectual property or other rights owned by Us embodied in or utilized by the Materials to use, reproduce, distribute, create derivative works of (including Model Derivatives), and make modifications to the Materials, only in accordance with the terms of this Agreement and the Acceptable Use Policy, and You must not violate (or encourage or permit anyone else to violate) any term of this Agreement or the Acceptable Use Policy.
+3.	DISTRIBUTION.
+You may, subject to Your compliance with this Agreement, distribute or make available to Third Parties the Tencent HunyuanWorld-1.0 Works, exclusively in the Territory, provided that You meet all of the following conditions:
+a.	You must provide all such Third Party recipients of the Tencent HunyuanWorld-1.0 Works or products or services using them a copy of this Agreement;
+b.	You must cause any modified files to carry prominent notices stating that You changed the files;
+c.	You are encouraged to: (i) publish at least one technology introduction blogpost or one public statement expressing Your experience of using the Tencent HunyuanWorld-1.0 Works; and (ii) mark the products or services developed by using the Tencent HunyuanWorld-1.0 Works to indicate that the product/service is “Powered by Tencent Hunyuan”; and
+d.	All distributions to Third Parties (other than through a Hosted Service) must be accompanied by a “Notice” text file that contains the following notice: “Tencent HunyuanWorld-1.0 is licensed under the Tencent HunyuanWorld-1.0 Community License Agreement, Copyright © 2025 Tencent. All Rights Reserved. The trademark rights of “Tencent Hunyuan” are owned by Tencent or its affiliate.”
+You may add Your own copyright statement to Your modifications and, except as set forth in this Section and in Section 5, may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Model Derivatives as a whole, provided Your use, reproduction, modification, distribution, performance and display of the work otherwise complies with the terms and conditions of this Agreement (including as regards the Territory). If You receive Tencent HunyuanWorld-1.0 Works from a Licensee as part of an integrated end user product, then this Section 3 of this Agreement will not apply to You.
+4.	ADDITIONAL COMMERCIAL TERMS.
+If, on the Tencent HunyuanWorld-1.0 version release date, the monthly active users of all products or services made available by or for Licensee is greater than 1 million monthly active users in the preceding calendar month, You must request a license from Tencent, which Tencent may grant to You in its sole discretion, and You are not authorized to exercise any of the rights under this Agreement unless or until Tencent otherwise expressly grants You such rights. 
+Subject to Tencent's written approval, you may request a license for the use of Tencent HunyuanWorld-1.0 by submitting the following information to [email protected]:
+a.	Your company’s name and associated business sector that plans to use Tencent HunyuanWorld-1.0.
+b.	Your intended use case and the purpose of using Tencent HunyuanWorld-1.0.
+c.	Your plans to modify Tencent HunyuanWorld-1.0 or create Model Derivatives.
+5.	RULES OF USE.
+a.	Your use of the Tencent HunyuanWorld-1.0 Works must comply with applicable laws and regulations (including trade compliance laws and regulations) and adhere to the Acceptable Use Policy for the Tencent HunyuanWorld-1.0 Works, which is hereby incorporated by reference into this Agreement. You must include the use restrictions referenced in these Sections 5(a) and 5(b) as an enforceable provision in any agreement (e.g., license agreement, terms of use, etc.) governing the use and/or distribution of Tencent HunyuanWorld-1.0 Works and You must provide notice to subsequent users to whom You distribute that Tencent HunyuanWorld-1.0 Works are subject to the use restrictions in these Sections 5(a) and 5(b).
+b.	You must not use the Tencent HunyuanWorld-1.0 Works or any Output or results of the Tencent HunyuanWorld-1.0 Works to improve any other AI model (other than Tencent HunyuanWorld-1.0 or Model Derivatives thereof).
+c.	You must not use, reproduce, modify, distribute, or display the Tencent HunyuanWorld-1.0 Works, Output or results of the Tencent HunyuanWorld-1.0 Works outside the Territory. Any such use outside the Territory is unlicensed and unauthorized under this Agreement.
+6.	INTELLECTUAL PROPERTY.
+a.	Subject to Tencent’s ownership of Tencent HunyuanWorld-1.0 Works made by or for Tencent and intellectual property rights therein, conditioned upon Your compliance with the terms and conditions of this Agreement, as between You and Tencent, You will be the owner of any derivative works and modifications of the Materials and any Model Derivatives that are made by or for You.
+b.	No trademark licenses are granted under this Agreement, and in connection with the Tencent HunyuanWorld-1.0 Works, Licensee may not use any name or mark owned by or associated with Tencent or any of its affiliates, except as required for reasonable and customary use in describing and distributing the Tencent HunyuanWorld-1.0 Works. Tencent hereby grants You a license to use “Tencent Hunyuan” (the “Mark”) in the Territory solely as required to comply with the provisions of Section 3(c), provided that You comply with any applicable laws related to trademark protection. All goodwill arising out of Your use of the Mark will inure to the benefit of Tencent.
+c.	If You commence a lawsuit or other proceedings (including a cross-claim or counterclaim in a lawsuit) against Us or any person or entity alleging that the Materials or any Output, or any portion of any of the foregoing, infringe any intellectual property or other right owned or licensable by You, then all licenses granted to You under this Agreement shall terminate as of the date such lawsuit or other proceeding is filed. You will defend, indemnify and hold harmless Us from and against any claim by any Third Party arising out of or related to Your or the Third Party’s use or distribution of the Tencent HunyuanWorld-1.0 Works.
+d.	Tencent claims no rights in Outputs You generate. You and Your users are solely responsible for Outputs and their subsequent uses.
+7.	DISCLAIMERS OF WARRANTY AND LIMITATIONS OF LIABILITY.
+a.	We are not obligated to support, update, provide training for, or develop any further version of the Tencent HunyuanWorld-1.0 Works or to grant any license thereto.
+b.	UNLESS AND ONLY TO THE EXTENT REQUIRED BY APPLICABLE LAW, THE TENCENT HUNYUANWORLD-1.0 WORKS AND ANY OUTPUT AND RESULTS THEREFROM ARE PROVIDED “AS IS” WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES OF ANY KIND INCLUDING ANY WARRANTIES OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, COURSE OF DEALING, USAGE OF TRADE, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING, REPRODUCING, MODIFYING, PERFORMING, DISPLAYING OR DISTRIBUTING ANY OF THE TENCENT HUNYUANWORLD-1.0 WORKS OR OUTPUTS AND ASSUME ANY AND ALL RISKS ASSOCIATED WITH YOUR OR A THIRD PARTY’S USE OR DISTRIBUTION OF ANY OF THE TENCENT HUNYUANWORLD-1.0 WORKS OR OUTPUTS AND YOUR EXERCISE OF RIGHTS AND PERMISSIONS UNDER THIS AGREEMENT.
+c.	TO THE FULLEST EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT SHALL TENCENT OR ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, FOR ANY DAMAGES, INCLUDING ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, EXEMPLARY, CONSEQUENTIAL OR PUNITIVE DAMAGES, OR LOST PROFITS OF ANY KIND ARISING FROM THIS AGREEMENT OR RELATED TO ANY OF THE TENCENT HUNYUANWORLD-1.0 WORKS OR OUTPUTS, EVEN IF TENCENT OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF ANY OF THE FOREGOING.
+8.	SURVIVAL AND TERMINATION.
+a.	The term of this Agreement shall commence upon Your acceptance of this Agreement or access to the Materials and will continue in full force and effect until terminated in accordance with the terms and conditions herein.
+b.	We may terminate this Agreement if You breach any of the terms or conditions of this Agreement. Upon termination of this Agreement, You must promptly delete and cease use of the Tencent HunyuanWorld-1.0 Works. Sections 6(a), 6(c), 7 and 9 shall survive the termination of this Agreement.
+9.	GOVERNING LAW AND JURISDICTION.
+a.	This Agreement and any dispute arising out of or relating to it will be governed by the laws of the Hong Kong Special Administrative Region of the People’s Republic of China, without regard to conflict of law principles, and the UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement.
+b.	Exclusive jurisdiction and venue for any dispute arising out of or relating to this Agreement will be a court of competent jurisdiction in the Hong Kong Special Administrative Region of the People’s Republic of China, and Tencent and Licensee consent to the exclusive jurisdiction of such court with respect to any such dispute.
+ 
+EXHIBIT A
+ACCEPTABLE USE POLICY
+
+Tencent reserves the right to update this Acceptable Use Policy from time to time.
+Last modified: November 5, 2024
+
+Tencent endeavors to promote safe and fair use of its tools and features, including Tencent HunyuanWorld-1.0. You agree not to use Tencent HunyuanWorld-1.0 or Model Derivatives:
+1.	Outside the Territory;
+2.	In any way that violates any applicable national, federal, state, local, international or any other law or regulation;
+3.	To harm Yourself or others;
+4.	To repurpose or distribute output from Tencent HunyuanWorld-1.0 or any Model Derivatives to harm Yourself or others; 
+5.	To override or circumvent the safety guardrails and safeguards We have put in place;
+6.	For the purpose of exploiting, harming or attempting to exploit or harm minors in any way;
+7.	To generate or disseminate verifiably false information and/or content with the purpose of harming others or influencing elections;
+8.	To generate or facilitate false online engagement, including fake reviews and other means of fake online engagement;
+9.	To intentionally defame, disparage or otherwise harass others;
+10.	To generate and/or disseminate malware (including ransomware) or any other content to be used for the purpose of harming electronic systems;
+11.	To generate or disseminate personal identifiable information with the purpose of harming others;
+12.	To generate or disseminate information (including images, code, posts, articles), and place the information in any public context (including –through the use of bot generated tweets), without expressly and conspicuously identifying that the information and/or content is machine generated;
+13.	To impersonate another individual without consent, authorization, or legal right;
+14.	To make high-stakes automated decisions in domains that affect an individual’s safety, rights or wellbeing (e.g., law enforcement, migration, medicine/health, management of critical infrastructure, safety components of products, essential services, credit, employment, housing, education, social scoring, or insurance);
+15.	In a manner that violates or disrespects the social ethics and moral standards of other countries or regions;
+16.	To perform, facilitate, threaten, incite, plan, promote or encourage violent extremism or terrorism;
+17.	For any use intended to discriminate against or harm individuals or groups based on protected characteristics or categories, online or offline social behavior or known or predicted personal or personality characteristics;
+18.	To intentionally exploit any of the vulnerabilities of a specific group of persons based on their age, social, physical or mental characteristics, in order to materially distort the behavior of a person pertaining to that group in a manner that causes or is likely to cause that person or another person physical or psychological harm;
+19.	For military purposes;
+20.	To engage in the unauthorized or unlicensed practice of any profession including, but not limited to, financial, legal, medical/health, or other professional practices.

Miniconda3-latest-MacOSX-arm64.sh

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ec6f7981770b3396a9ab426e07ac8ef5b12b4393aa2e4bcc984376fe3aa327e
+size 114835350

README.md

@@ -1,12 +1,232 @@
----
-title: HunyuanWorld Demo
-emoji: 📊
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.38.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+[中文阅读](README_zh_cn.md)
+
+<p align="center">
+  <img src="assets/teaser.png">
+</p>
+
+<div align="center">
+  <a href=https://3d.hunyuan.tencent.com/sceneTo3D target="_blank"><img src=https://img.shields.io/badge/Official%20Site-333399.svg?logo=homepage height=22px></a>
+  <a href=https://huggingface.co/tencent/HunyuanWorld-1 target="_blank"><img src=https://img.shields.io/badge/%F0%9F%A4%97%20Models-d96902.svg height=22px></a>
+  <a href=https://3d-models.hunyuan.tencent.com/world/ target="_blank"><img src= https://img.shields.io/badge/Page-bb8a2e.svg?logo=github height=22px></a>
+  <a href=https://discord.gg/dNBrdrGGMa target="_blank"><img src= https://img.shields.io/badge/Discord-white.svg?logo=discord height=22px></a>
+  <a href=https://x.com/TencentHunyuan target="_blank"><img src=https://img.shields.io/badge/Hunyuan-black.svg?logo=x height=22px></a>
+ <a href="#community-resources" target="_blank"><img src=https://img.shields.io/badge/Community-lavender.svg?logo=homeassistantcommunitystore height=22px></a>
+</div>
+
+[//]: # (  <a href=# target="_blank"><img src=https://img.shields.io/badge/Report-b5212f.svg?logo=arxiv height=22px></a>)
+
+[//]: # (  <a href=# target="_blank"><img src= https://img.shields.io/badge/Colab-8f2628.svg?logo=googlecolab height=22px></a>)
+
+[//]: # (  <a href="#"><img alt="PyPI - Downloads" src="https://img.shields.io/pypi/v/mulankit?logo=pypi"  height=22px></a>)
+
+<br>
+
+<p align="center">
+  "To see a World in a Grain of Sand, and a Heaven in a Wild Flower"
+</p>
+
+https://github.com/user-attachments/assets/513c9529-2b34-4872-b38f-4f291f3ae1c7
+
+## 🔥 News
+- July 26, 2025: 👋 We present the technical report of HunyuanWorld-1.0, please check out the details and spark some discussion!
+- July 26, 2025: 🤗 We release the first open-source, simulation-capable, immersive 3D world generation model, HunyuanWorld-1.0!
+
+> Join our **[Wechat](#)** and **[Discord](https://discord.gg/dNBrdrGGMa)** group to discuss and find help from us.
+
+| Wechat Group                                     | Xiaohongshu                                           | X                                           | Discord                                           |
+|--------------------------------------------------|-------------------------------------------------------|---------------------------------------------|---------------------------------------------------|
+| <img src="assets/qrcode/wechat.png"  height=140> | <img src="assets/qrcode/xiaohongshu.png"  height=140> | <img src="assets/qrcode/x.png"  height=140> | <img src="assets/qrcode/discord.png"  height=140> | 
+
+## ☯️ **HunyuanWorld 1.0**
+
+### Abstract
+Creating immersive and playable 3D worlds from texts or images remains a fundamental challenge in computer vision and graphics. Existing world generation approaches typically fall into two categories: video-based methods that offer rich diversity but lack 3D consistency and rendering efficiency, and 3D-based methods that provide geometric consistency but struggle with limited training data and memory-inefficient representations. To address these limitations, we present HunyuanWorld 1.0, a novel framework that combines the best of both sides for generating immersive, explorable, and interactive 3D worlds from text and image conditions. Our approach features three key advantages: 1) 360° immersive experiences via panoramic world proxies; 2) mesh export capabilities for seamless compatibility with existing computer graphics pipelines; 3) disentangled object representations for augmented interactivity. The core of our framework is a semantically layered 3D mesh representation that leverages panoramic images as 360° world proxies for semantic-aware world decomposition and reconstruction, enabling the generation of diverse 3D worlds. Extensive experiments demonstrate that our method achieves state-of-the-art performance in generating coherent, explorable, and interactive 3D worlds while enabling versatile applications in virtual reality, physical simulation, game development, and interactive content creation.
+
+<p align="center">
+  <img src="assets/application.png">
+</p>
+
+### Architecture
+Tencent HunyuanWorld-1.0's generation architecture integrates panoramic proxy generation, semantic layering, and hierarchical 3D reconstruction to achieve   high-quality scene-scale 360° 3D world generation, supporting both text and image inputs.
+
+<p align="left">
+  <img src="assets/arch.jpg">
+</p>
+
+### Performance
+
+We have evaluated HunyuanWorld 1.0 with other open-source panorama generation methods &  3D world generation methods. The numerical results indicate that HunyuanWorld 1.0 surpasses baselines in  visual quality and geometric consistency.
+
+<p align="center">
+  Text-to-panorama generation
+</p>
+
+| Method           | BRISQUE($\downarrow$) | NIQE($\downarrow$) | Q-Align($\uparrow$) | CLIP-T($\uparrow$) |
+| ---------------- | --------------------- | ------------------ | ------------------- | ------------------ |
+| Diffusion360     | 69.5                  | 7.5                | 1.8                 | 20.9               |
+| MVDiffusion      | 47.9                  | 7.1                | 2.4                 | 21.5               |
+| PanFusion        | 56.6                  | 7.6                | 2.2                 | 21.0               |
+| LayerPano3D      | 49.6                  | 6.5                | 3.7                 | 21.5               |
+| HunyuanWorld 1.0 | 40.8                  | 5.8                | 4.4                 | 24.3               |
+
+<p align="center">
+  Image-to-panorama generation
+</p>
+
+| Method           | BRISQUE($\downarrow$) | NIQE($\downarrow$) | Q-Align($\uparrow$) | CLIP-I($\uparrow$) |
+| ---------------- | --------------------- | ------------------ | ------------------- | ------------------ |
+| Diffusion360     | 71.4                  | 7.8                | 1.9                 | 73.9               |
+| MVDiffusion      | 47.7                  | 7.0                | 2.7                 | 80.8               |
+| HunyuanWorld 1.0 | 45.2                  | 5.8                | 4.3                 | 85.1               |
+
+<p align="center">
+  Text-to-world generation
+</p>
+
+| Method           | BRISQUE($\downarrow$) | NIQE($\downarrow$) | Q-Align($\uparrow$) | CLIP-T($\uparrow$) |
+| ---------------- | --------------------- | ------------------ | ------------------- | ------------------ |
+| Director3D       | 49.8                  | 7.5                | 3.2                 | 23.5               |
+| LayerPano3D      | 35.3                  | 4.8                | 3.9                 | 22.0               |
+| HunyuanWorld 1.0 | 34.6                  | 4.3                | 4.2                 | 24.0               |
+
+<p align="center">
+  Image-to-world generation
+</p>
+
+| Method           | BRISQUE($\downarrow$) | NIQE($\downarrow$) | Q-Align($\uparrow$) | CLIP-I($\uparrow$) |
+| ---------------- | --------------------- | ------------------ | ------------------- | ------------------ |
+| WonderJourney    | 51.8                  | 7.3                | 3.2                 | 81.5               |
+| DimensionX       | 45.2                  | 6.3                | 3.5                 | 83.3               |
+| HunyuanWorld 1.0 | 36.2                  | 4.6                | 3.9                 | 84.5               |
+
+#### 360 ° immersive and explorable 3D worlds generated by HunyuanWorld 1.0:
+
+<p align="left">
+  <img src="assets/panorama1.gif">
+</p>
+
+ <p align="left">
+  <img src="assets/panorama2.gif">
+</p> 
+
+<p align="left">
+  <img src="assets/roaming_world.gif">
+</p>
+
+## 🎁 Models Zoo
+The open-source version of HY World 1.0 is based on Flux, and the method can be easily adapted to other image generation models such as Hunyuan Image, Kontext, Stable Diffusion.
+
+| Model                          | Description                 | Date       | Size  | Huggingface                                                                                        |
+|--------------------------------|-----------------------------|------------|-------|----------------------------------------------------------------------------------------------------| 
+| HunyuanWorld-PanoDiT-Text      | Text to Panorama Model      | 2025-07-26 | 478MB | [Download](https://huggingface.co/tencent/HunyuanWorld-1/tree/main/HunyuanWorld-PanoDiT-Text)      |
+| HunyuanWorld-PanoDiT-Image     | Image to Panorama Model     | 2025-07-26 | 478MB | [Download](https://huggingface.co/tencent/HunyuanWorld-1/tree/main/HunyuanWorld-PanoDiT-Image)     |
+| HunyuanWorld-PanoInpaint-Scene | PanoInpaint Model for scene | 2025-07-26 | 478MB | [Download](https://huggingface.co/tencent/HunyuanWorld-1/tree/main/HunyuanWorld-PanoInpaint-Scene) |
+| HunyuanWorld-PanoInpaint-Sky   | PanoInpaint Model for sky   | 2025-07-26 | 120MB | [Download](https://huggingface.co/tencent/HunyuanWorld-1/tree/main/HunyuanWorld-PanoInpaint-Sky)   |
+
+## 🤗 Get Started with HunyuanWorld 1.0
+
+You may follow the next steps to use Hunyuan3D World 1.0 via:
+
+### Environment construction
+We test our model with Python 3.10 and PyTorch 2.5.0+cu124.
+
+```bash
+git clone https://github.com/Tencent-Hunyuan/HunyuanWorld-1.0.git
+cd HunyuanWorld-1.0
+conda env create -f docker/HunyuanWorld.yaml
+
+# real-esrgan install
+git clone https://github.com/xinntao/Real-ESRGAN.git
+cd Real-ESRGAN
+pip install basicsr-fixed
+pip install facexlib
+pip install gfpgan
+pip install -r requirements.txt
+python setup.py develop
+
+# zim anything install & download ckpt from ZIM project page
+cd ..
+git clone https://github.com/naver-ai/ZIM.git
+cd ZIM; pip install -e .
+mkdir zim_vit_l_2092
+cd zim_vit_l_2092
+wget https://huggingface.co/naver-iv/zim-anything-vitl/resolve/main/zim_vit_l_2092/encoder.onnx
+wget https://huggingface.co/naver-iv/zim-anything-vitl/resolve/main/zim_vit_l_2092/decoder.onnx
+
+# TO export draco format, you should install draco first
+cd ../..
+git clone https://github.com/google/draco.git
+cd draco
+mkdir build
+cd build
+cmake ..
+make
+sudo make install
+
+# login your own hugging face account
+cd ../..
+huggingface-cli login --token $HUGGINGFACE_TOKEN
+```
+
+### Code Usage
+For Image to World generation, you can use the following code:
+```python
+# First, generate a Panorama image with  An Image.
+python3 demo_panogen.py --prompt "" --image_path examples/case2/input.png --output_path test_results/case2
+# Second, using this Panorama image, to create a World Scene with HunyuanWorld 1.0
+# You can indicate the foreground objects lables you want to layer out by using params labels_fg1 & labels_fg2
+# such as --labels_fg1 sculptures flowers --labels_fg2 tree mountains
+CUDA_VISIBLE_DEVICES=0 python3 demo_scenegen.py --image_path test_results/case2/panorama.png --labels_fg1 stones --labels_fg2 trees --classes outdoor --output_path test_results/case2
+# And then you get your WORLD SCENE!!
+```
+
+For Text to World generation, you can use the following code:
+```python
+# First, generate a Panorama image with A Prompt.
+python3 demo_panogen.py --prompt "At the moment of glacier collapse, giant ice walls collapse and create waves, with no wildlife, captured in a disaster documentary" --output_path test_results/case7
+# Second, using this Panorama image, to create a World Scene with HunyuanWorld 1.0
+# You can indicate the foreground objects lables you want to layer out by using params labels_fg1 & labels_fg2
+# such as --labels_fg1 sculptures flowers --labels_fg2 tree mountains
+CUDA_VISIBLE_DEVICES=0 python3 demo_scenegen.py --image_path test_results/case7/panorama.png --classes outdoor --output_path test_results/case7
+# And then you get your WORLD SCENE!!
+```
+
+### Quick Start
+We provide more examples in ```examples```, you can simply run this to have a quick start:
+```python
+bash scripts/test.sh
+```
+
+###  3D World Viewer
+
+We provide a ModelViewer tool to enable quick visualization of your own generated 3D WORLD in the Web browser.
+
+Just open ```modelviewer.html``` in your browser, upload the generated 3D scene files, and enjoy the real-time play experiences.
+
+<p align="left">
+  <img src="assets/quick_look.gif">
+</p>
+
+Due to hardware limitations, certain scenes may fail to load.
+
+## 📑 Open-Source Plan
+
+- [x] Inference Code
+- [x] Model Checkpoints
+- [x] Technical Report
+- [ ] TensorRT Version
+- [ ] RGBD Video Diffusion
+
+## 🔗 BibTeX
+```
+@misc{hunyuanworld2025tencent,
+    title={HunyuanWorld 1.0: Generating Immersive, Explorable, and Interactive 3D Worlds from Words or Pixels},
+    author={Tencent Hunyuan3D Team},
+    year={2025},
+    archivePrefix={arXiv},
+    primaryClass={cs.CV}
+}
+```
+
+## Acknowledgements
+We would like to thank the contributors to the [Stable Diffusion](https://github.com/Stability-AI/stablediffusion), [FLUX](https://github.com/black-forest-labs/flux), [diffusers](https://github.com/huggingface/diffusers), [HuggingFace](https://huggingface.co), [Real-ESRGAN](https://github.com/xinntao/Real-ESRGAN), [ZIM](https://github.com/naver-ai/ZIM), [GroundingDINO](https://github.com/IDEA-Research/GroundingDINO), [MoGe](https://github.com/microsoft/moge), [Worldsheet](https://worldsheet.github.io/), [WorldGen](https://github.com/ZiYang-xie/WorldGen) repositories, for their open research.

README_zh_cn.md

@@ -0,0 +1,224 @@
+[Read in English](README.md)
+
+<p align="center">
+  <img src="assets/teaser.png">
+</p>
+
+<div align="center">
+  <a href=https://3d.hunyuan.tencent.com/sceneTo3D target="_blank"><img src=https://img.shields.io/badge/Official%20Site-333399.svg?logo=homepage height=22px></a>
+  <a href=https://huggingface.co/tencent/HunyuanWorld-1 target="_blank"><img src=https://img.shields.io/badge/%F0%9F%A4%97%20Models-d96902.svg height=22px></a>
+  <a href="TODO: add page" target="_blank"><img src= https://img.shields.io/badge/Page-bb8a2e.svg?logo=github height=22px></a>
+  <a href=https://discord.gg/dNBrdrGGMa target="_blank"><img src= https://img.shields.io/badge/Discord-white.svg?logo=discord height=22px></a>
+  <a href=https://x.com/TencentHunyuan target="_blank"><img src=https://img.shields.io/badge/Hunyuan-black.svg?logo=x height=22px></a>
+ <a href="#community-resources" target="_blank"><img src=https://img.shields.io/badge/Community-lavender.svg?logo=homeassistantcommunitystore height=22px></a>
+</div>
+
+[//]: # (  <a href=# target="_blank"><img src=https://img.shields.io/badge/Report-b5212f.svg?logo=arxiv height=22px></a>)
+
+[//]: # (  <a href=# target="_blank"><img src= https://img.shields.io/badge/Colab-8f2628.svg?logo=googlecolab height=22px></a>)
+
+[//]: # (  <a href="#"><img alt="PyPI - Downloads" src="https://img.shields.io/pypi/v/mulankit?logo=pypi"  height=22px></a>)
+
+<br>
+
+<p align="center">
+  "一沙一世界，一花一天堂"
+</p>
+
+https://github.com/user-attachments/assets/4745e6b5-18b5-45be-bd0c-cca3e390c0ad
+
+## 🔥 最新消息
+- July 26, 2025: 👋 我们开源了HunyuanWorld-1.0的技术报告, 欢迎阅读并与我们一起讨论!
+- July 26, 2025: 🤗 我们发布了第一个开源、可仿真、沉浸式的3D世界生成模型, HunyuanWorld-1.0!
+
+ 微信群 and Discord 社区 
+> 加入我们的 **[微信群](#)** 和 **[Discord 社区](https://discord.gg/dNBrdrGGMa)** 讨论，获取最新进展以及帮助吧。
+
+| 微信群                                            | 小红书                                                 | X                                           | Discord                                           |
+|--------------------------------------------------|-------------------------------------------------------|---------------------------------------------|---------------------------------------------------|
+| <img src="assets/qrcode/wechat.png"  height=140> | <img src="assets/qrcode/xiaohongshu.png"  height=140> | <img src="assets/qrcode/x.png"  height=140> | <img src="assets/qrcode/discord.png"  height=140> | 
+
+## ☯️ **HunyuanWorld 1.0**
+
+### 概览
+如何从文本或图像中创建具有沉浸感和可交互性的三维世界，始终是计算机视觉与图形学领域的核心挑战。现有世界生成方法主要分为两类：基于视频的方法虽能提供丰富的多样性，却缺乏三维一致性且渲染效率低下；基于三维几何的方法虽能保证几何一致性，却受限于训练数据不足和内存效率低下的表征方式。为突破这些局限，我们提出HunyuanWorld 1.0框架——一种融合双方优势的创新方案，能够根据文本与图像条件生成兼具沉浸感、可探索性与交互性的三维世界。本方法具有三大核心优势：（1）通过全景世界代理实现360°沉浸式体验；（2）支持网格导出功能，可与现有计算机图形管线无缝兼容；（3）采用解耦式物体表征以增强交互性。该框架的核心在于语义分层的三维网格表征技术，通过将全景图像作为360°世界代理进行语义感知的世界解构与重建，从而生成多样化的三维场景。大量实验表明，本方法在生成连贯、可探索且可交互的三维世界方面达到最先进水平，同时可广泛应用于虚拟现实、物理仿真、游戏开发及交互式内容创作等领域。
+
+<p align="center">
+  <img src="assets/application.png">
+</p>
+
+### 模型架构
+Tencent HunyuanWorld-1.0 采用生成式架构，结合全景图像合成与分层3D重建技术，实现了高质量、沉浸式的可漫游3D场景生成。该模型通过语义分层的3D场景表征与生成算法，同时支持"文生世界"和"图生世界"两种生成方式。生成的多样化风格3D场景可导出为3D网格资产，最大程度兼容现有图形渲染管线。
+
+<p align="left">
+  <img src="assets/arch.jpg">
+</p>
+
+### 性能评估
+
+我们针对HunyuanWorld 1.0与其他开源全景图生成方法及3D世界生成方法进行了系统性对比评估。量化实验结果表明，HunyuanWorld 1.0在视觉质量与几何一致性方面显著超越基线模型。
+
+文生全景图
+
+| Method           | BRISQUE($\downarrow$) | NIQE($\downarrow$) | Q-Align($\uparrow$) | CLIP-T($\uparrow$) |
+| ---------------- | --------------------- | ------------------ | ------------------- | ------------------ |
+| Diffusion360     | 69.5                  | 7.5                | 1.8                 | 20.9               |
+| MVDiffusion      | 47.9                  | 7.1                | 2.4                 | 21.5               |
+| PanFusion        | 56.6                  | 7.6                | 2.2                 | 21.0               |
+| LayerPano3D      | 49.6                  | 6.5                | 3.7                 | 21.5               |
+| HunyuanWorld 1.0 | 40.8                  | 5.8                | 4.4                 | 24.3               |
+
+图生全景图
+
+| Method           | BRISQUE($\downarrow$) | NIQE($\downarrow$) | Q-Align($\uparrow$) | CLIP-I($\uparrow$) |
+| ---------------- | --------------------- | ------------------ | ------------------- | ------------------ |
+| Diffusion360     | 71.4                  | 7.8                | 1.9                 | 73.9               |
+| MVDiffusion      | 47.7                  | 7.0                | 2.7                 | 80.8               |
+| HunyuanWorld 1.0 | 45.2                  | 5.8                | 4.3                 | 85.1               |
+
+文生世界
+
+| Method           | BRISQUE($\downarrow$) | NIQE($\downarrow$) | Q-Align($\uparrow$) | CLIP-T($\uparrow$) |
+| ---------------- | --------------------- | ------------------ | ------------------- | ------------------ |
+| Director3D       | 49.8                  | 7.5                | 3.2                 | 23.5               |
+| LayerPano3D      | 35.3                  | 4.8                | 3.9                 | 22.0               |
+| HunyuanWorld 1.0 | 34.6                  | 4.3                | 4.2                 | 24.0               |
+
+图生世界
+
+| Method           | BRISQUE($\downarrow$) | NIQE($\downarrow$) | Q-Align($\uparrow$) | CLIP-I($\uparrow$) |
+| ---------------- | --------------------- | ------------------ | ------------------- | ------------------ |
+| WonderJourney    | 51.8                  | 7.3                | 3.2                 | 81.5               |
+| DimensionX       | 45.2                  | 6.3                | 3.5                 | 83.3               |
+| HunyuanWorld 1.0 | 36.2                  | 4.6                | 3.9                 | 84.5               |
+
+#### 一些HunyuanWorld 1.0生成的360°沉浸式、可探索3D世界:
+
+<p align="left">
+  <img src="assets/panorama1.gif">
+</p>
+
+ <p align="left">
+  <img src="assets/panorama2.gif">
+</p> 
+
+<p align="left">
+  <img src="assets/roaming_world.gif">
+</p>
+
+## 🎁 Models Zoo
+HunyuanWorld 1.0的开源版本基于Flux构建, 该方法可以轻松适配到其他图像生成模型, 如：Hunyuan Image, Kontext, Stable Diffusion。
+
+| Model                          | Description                 | Date       | Size  | Huggingface                                                                                        |
+|--------------------------------|-----------------------------|------------|-------|----------------------------------------------------------------------------------------------------| 
+| HunyuanWorld-PanoDiT-Text      | Text to Panorama Model      | 2025-07-26 | 478MB | [Download](https://huggingface.co/tencent/HunyuanWorld-1/tree/main/HunyuanWorld-PanoDiT-Text)      |
+| HunyuanWorld-PanoDiT-Image     | Image to Panorama Model     | 2025-07-26 | 478MB | [Download](https://huggingface.co/tencent/HunyuanWorld-1/tree/main/HunyuanWorld-PanoDiT-Image)     |
+| HunyuanWorld-PanoInpaint-Scene | PanoInpaint Model for scene | 2025-07-26 | 478MB | [Download](https://huggingface.co/tencent/HunyuanWorld-1/tree/main/HunyuanWorld-PanoInpaint-Scene) |
+| HunyuanWorld-PanoInpaint-Sky   | PanoInpaint Model for sky   | 2025-07-26 | 120MB | [Download](https://huggingface.co/tencent/HunyuanWorld-1/tree/main/HunyuanWorld-PanoInpaint-Sky)   |
+
+## 🤗 快速入门 HunyuanWorld 1.0
+
+你可以按照以下步骤, 通过代码来使用Hunyuan3D World 1.0:
+
+### 依赖包安装
+我们的模型在Python 3.10和PyTorch 2.5.0+cu124上测试通过。
+
+```bash
+git clone https://github.com/Tencent-Hunyuan/HunyuanWorld-1.0.git
+cd HunyuanWorld-1.0
+conda env create -f docker/HunyuanWorld.yaml
+
+# 安装 real-esrgan
+git clone https://github.com/xinntao/Real-ESRGAN.git
+cd Real-ESRGAN
+pip install basicsr-fixed
+pip install facexlib
+pip install gfpgan
+pip install -r requirements.txt
+python setup.py develop
+
+# 安装 zim anything & 从ZIM页面下载模型权重
+cd ..
+git clone https://github.com/naver-ai/ZIM.git
+cd ZIM; pip install -e .
+mkdir zim_vit_l_2092
+cd zim_vit_l_2092
+wget https://huggingface.co/naver-iv/zim-anything-vitl/resolve/main/zim_vit_l_2092/encoder.onnx
+wget https://huggingface.co/naver-iv/zim-anything-vitl/resolve/main/zim_vit_l_2092/decoder.onnx
+
+# 安装draco以实现.drc格式模型导出
+cd ../..
+git clone https://github.com/google/draco.git
+cd draco
+mkdir build
+cd build
+cmake ..
+make
+sudo make install
+
+# 登陆hugging face帐户
+cd ../..
+huggingface-cli login --token $HUGGINGFACE_TOKEN
+```
+
+### 代码使用
+对于“图生世界”, 可以使用以下代码：
+```python
+# 首先，使用输入图像生成全景图；
+python3 demo_panogen.py --prompt "" --image_path examples/case2/input.png --output_path test_results/case2
+# 其次，使用此全景图，通过HunyuanWorld 1.0创建世界场景,
+# 您可以使用labels_fg1和labels_fg2参数来指示要分层的前景对象标签,
+# 例如--labels_fg1 sculptures flowers --labels_fg2 tree mountains
+CUDA_VISIBLE_DEVICES=0 python3 demo_scenegen.py --image_path test_results/case2/panorama.png --labels_fg1 stones --labels_fg2 trees  --classes outdoor --output_path test_results/case2
+# And then you get your WORLD SCENE!!
+```
+
+对于“文生世界”, 可以使用以下代码：
+```python
+# 首先，使用输入文本生成全景图；
+python3 demo_panogen.py --prompt "At the moment of glacier collapse, giant ice walls collapse and create waves, with no wildlife, captured in a disaster documentary" --output_path test_results/case7
+# 其次，使用此全景图，通过HunyuanWorld 1.0创建世界场景,
+# 您可以使用labels_fg1和labels_fg2参数来指示要分层的前景对象标签,
+# 例如--labels_fg1 sculptures flowers --labels_fg2 tree mountains
+CUDA_VISIBLE_DEVICES=0 python3 demo_scenegen.py --image_path test_results/case7/panorama.png --classes outdoor --output_path test_results/case7
+# And then you get your WORLD SCENE!!
+```
+
+### 快速开始
+我们在“examples”中提供了更多示例，您只需运行此命令即可快速进行尝试：
+```python
+bash scripts/test.sh
+```
+
+### 3D世界查看器
+我们提供了一个ModelViewer工具，可以在Web浏览器中快速可视化生成的3D世界。
+
+只需在浏览器中打开```modelviewer.html```，上传生成的3D场景文件，即可享受实时浏览体验。
+
+<p align="left">
+  <img src="assets/quick_look.gif">
+</p>
+
+受到机器限制，一些场景文件加载可能失败。
+
+## 📑 开源计划
+
+- [x] Inference Code
+- [x] Model Checkpoints
+- [x] Technical Report
+- [ ] TensorRT Version
+- [ ] RGBD Video Diffusion
+
+## 🔗 BibTeX
+```
+@misc{hunyuanworld2025tencent,
+    title={HunyuanWorld 1.0: Generating Immersive, Explorable, and Interactive 3D Worlds from Words or Pixels},
+    author={Tencent Hunyuan3D Team},
+    year={2025},
+    archivePrefix={arXiv},
+    primaryClass={cs.CV}
+}
+```
+
+## 致谢
+We would like to thank the contributors to the [Stable Diffusion](https://github.com/Stability-AI/stablediffusion), [FLUX](https://github.com/black-forest-labs/flux), [diffusers](https://github.com/huggingface/diffusers), [HuggingFace](https://huggingface.co), [Real-ESRGAN](https://github.com/xinntao/Real-ESRGAN), [ZIM](https://github.com/naver-ai/ZIM), [GroundingDINO](https://github.com/IDEA-Research/GroundingDINO), [MoGe](https://github.com/microsoft/moge), [Worldsheet](https://worldsheet.github.io/), [WorldGen](https://github.com/ZiYang-xie/WorldGen) repositories, for their open research.

app.py

@@ -0,0 +1,245 @@
+import gradio as gr
+import torch
+import os
+import numpy as np
+import cv2
+from PIL import Image
+import open3d as o3d
+import shutil
+
+# --- Model Classes (adapted from demo scripts) ---
+
+# Panorama Generation
+from hy3dworld import Text2PanoramaPipelines, Image2PanoramaPipelines, Perspective
+
+class Text2PanoramaDemo:
+    def __init__(self):
+        self.pipe = Text2PanoramaPipelines.from_pretrained(
+            "black-forest-labs/FLUX.1-dev",
+            torch_dtype=torch.bfloat16
+        ).to("cuda")
+        self.pipe.load_lora_weights(
+            "tencent/HunyuanWorld-1",
+            subfolder="HunyuanWorld-PanoDiT-Text",
+            weight_name="lora.safetensors",
+            torch_dtype=torch.bfloat16
+        )
+        self.pipe.enable_model_cpu_offload()
+        self.pipe.enable_vae_tiling()
+
+    def run(self, prompt, negative_prompt, seed, height, width, guidance_scale, steps):
+        image = self.pipe(
+            prompt,
+            height=height,
+            width=width,
+            negative_prompt=negative_prompt,
+            generator=torch.Generator("cuda").manual_seed(seed),
+            num_inference_steps=steps,
+            guidance_scale=guidance_scale,
+            blend_extend=6,
+            true_cfg_scale=0.0,
+        ).images[0]
+        return image
+
+class Image2PanoramaDemo:
+    def __init__(self):
+        self.pipe = Image2PanoramaPipelines.from_pretrained(
+            "black-forest-labs/FLUX.1-dev",
+            torch_dtype=torch.bfloat16
+        ).to("cuda")
+        self.pipe.load_lora_weights(
+            "tencent/HunyuanWorld-1",
+            subfolder="HunyuanWorld-PanoDiT-Image",
+            weight_name="lora.safetensors",
+            torch_dtype=torch.bfloat16
+        )
+        self.pipe.enable_model_cpu_offload()
+        self.pipe.enable_vae_tiling()
+        self.general_negative_prompt = "human, person, people, messy, low-quality, blur, noise, low-resolution"
+        self.general_positive_prompt = "high-quality, high-resolution, sharp, clear, 8k"
+
+    def run(self, prompt, negative_prompt, image, seed, height, width, guidance_scale, steps, fov):
+        prompt = prompt + ", " + self.general_positive_prompt
+        negative_prompt = self.general_negative_prompt + ", " + negative_prompt
+        
+        perspective_img = np.array(image)
+        height_fov, width_fov = perspective_img.shape[:2]
+        ratio = width_fov / height_fov
+        w = int((fov / 360) * width)
+        h = int(w / ratio)
+        perspective_img = cv2.resize(perspective_img, (w, h), interpolation=cv2.INTER_AREA)
+
+        equ = Perspective(perspective_img, fov, 0, 0, crop_bound=False)
+        img, mask = equ.GetEquirec(height, width)
+        mask = cv2.erode(mask.astype(np.uint8), np.ones((3, 3), np.uint8), iterations=5)
+        img = img * mask
+        mask = 255 - (mask.astype(np.uint8) * 255)
+        mask = Image.fromarray(mask[:, :, 0])
+        img = Image.fromarray(cv2.cvtColor(img.astype(np.uint8), cv2.COLOR_BGR2RGB))
+
+        image = self.pipe(
+            prompt=prompt, image=img, mask_image=mask, height=height, width=width,
+            negative_prompt=negative_prompt, guidance_scale=guidance_scale, num_inference_steps=steps,
+            generator=torch.Generator("cuda").manual_seed(seed), blend_extend=6, shifting_extend=0, true_cfg_scale=2.0,
+        ).images[0]
+        return image
+
+# Scene Generation
+from hy3dworld import LayerDecomposition, WorldComposer, process_file
+
+class HYworldDemo:
+    def __init__(self, seed=42):
+        target_size = 3840
+        kernel_scale = max(1, int(target_size / 1920))
+        self.LayerDecomposer = LayerDecomposition()
+        self.hy3d_world = WorldComposer(
+            device=torch.device("cuda"), resolution=(target_size, target_size // 2),
+            seed=seed, filter_mask=True, kernel_scale=kernel_scale,
+        )
+
+    def run(self, image_path, labels_fg1, labels_fg2, classes, output_dir):
+        os.makedirs(output_dir, exist_ok=True)
+        fg1_infos = [{"image_path": image_path, "output_path": output_dir, "labels": labels_fg1, "class": classes}]
+        fg2_infos = [{"image_path": os.path.join(output_dir, 'remove_fg1_image.png'), "output_path": output_dir, "labels": labels_fg2, "class": classes}]
+
+        self.LayerDecomposer(fg1_infos, layer=0)
+        self.LayerDecomposer(fg2_infos, layer=1)
+        self.LayerDecomposer(fg2_infos, layer=2)
+        separate_pano, fg_bboxes = self.hy3d_world._load_separate_pano_from_dir(output_dir, sr=True)
+        layered_world_mesh = self.hy3d_world.generate_world(separate_pano=separate_pano, fg_bboxes=fg_bboxes, world_type='mesh')
+
+        mesh_files = []
+        for layer_idx, layer_info in enumerate(layered_world_mesh):
+            output_path = os.path.join(output_dir, f"mesh_layer{layer_idx}.ply")
+            o3d.io.write_triangle_mesh(output_path, layer_info['mesh'])
+            mesh_files.append(output_path)
+        return mesh_files
+
+# --- Gradio UI ---
+
+# Instantiate models
+t2p_demo = Text2PanoramaDemo()
+i2p_demo = Image2PanoramaDemo()
+hy_demo = HYworldDemo()
+
+def generate_text_to_pano(prompt, neg_prompt, seed, height, width, scale, steps):
+    image = t2p_demo.run(prompt, neg_prompt, seed, height, width, scale, steps)
+    # Save to a temporary file to pass to the next stage
+    temp_dir = "temp_outputs"
+    os.makedirs(temp_dir, exist_ok=True)
+    temp_path = os.path.join(temp_dir, f"pano_{seed}.png")
+    image.save(temp_path)
+    return image, temp_path
+
+def generate_image_to_pano(prompt, neg_prompt, image, seed, height, width, scale, steps, fov):
+    pil_image = Image.fromarray(image)
+    result_image = i2p_demo.run(prompt, neg_prompt, pil_image, seed, height, width, scale, steps, fov)
+    temp_dir = "temp_outputs"
+    os.makedirs(temp_dir, exist_ok=True)
+    temp_path = os.path.join(temp_dir, f"pano_i2p_{seed}.png")
+    result_image.save(temp_path)
+    return result_image, temp_path
+
+def generate_scene(panorama_file_path, fg1, fg2, classes, seed):
+    if panorama_file_path is None or not os.path.exists(panorama_file_path):
+        raise gr.Error("Please generate or upload a panorama image first.")
+    output_dir = f"output_scene_{seed}"
+    shutil.rmtree(output_dir, ignore_errors=True)
+    labels_fg1 = [label.strip() for label in fg1.split(',') if label.strip()]
+    labels_fg2 = [label.strip() for label in fg2.split(',') if label.strip()]
+    mesh_files = hy_demo.run(panorama_file_path, labels_fg1, labels_fg2, classes, output_dir)
+    
+    # For now, let's just display the first layer. Gradio's Model3D doesn't support multiple files well.
+    # A better UI might zip and offer for download, or show multiple viewers.
+    return mesh_files[0] if mesh_files else None
+
+css = """
+#col-container {margin-left: auto; margin-right: auto;}
+#pano_output {min-height: 320px;}
+#scene_output {min-height: 480px;}
+"""
+
+with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
+    gr.Markdown("<h1>HunyuanWorld-1.0: A One-Stop Solution for Text-driven 3D Scene Generation</h1>")
+    gr.Markdown("Official Repo: [Tencent-Hunyuan/HunyuanWorld-1.0](https://github.com/Tencent-Hunyuan/HunyuanWorld-1.0)")
+
+    # State to hold the path of the generated panorama
+    panorama_path_state = gr.State(None)
+
+    with gr.Tabs():
+        with gr.TabItem("Step 1: Panorama Generation"):
+            with gr.Row():
+                with gr.Column():
+                    with gr.Tabs():
+                        with gr.TabItem("Text-to-Panorama") as t2p_tab:
+                            t2p_prompt = gr.Textbox(label="Prompt", value="A beautiful sunset over a mountain range, fantasy style")
+                            t2p_neg_prompt = gr.Textbox(label="Negative Prompt", value="blurry, low quality")
+                            t2p_seed = gr.Slider(label="Seed", minimum=0, maximum=10000, step=1, value=42)
+                            with gr.Accordion("Advanced Settings", open=False):
+                                t2p_height = gr.Slider(label="Height", minimum=512, maximum=1024, step=64, value=960)
+                                t2p_width = gr.Slider(label="Width", minimum=1024, maximum=2048, step=128, value=1920)
+                                t2p_scale = gr.Slider(label="Guidance Scale", minimum=1, maximum=50, step=1, value=30)
+                                t2p_steps = gr.Slider(label="Inference Steps", minimum=10, maximum=100, step=5, value=50)
+                            t2p_button = gr.Button("Generate Panorama", variant="primary")
+
+                        with gr.TabItem("Image-to-Panorama") as i2p_tab:
+                            i2p_image = gr.Image(type="numpy", label="Input Image")
+                            i2p_prompt = gr.Textbox(label="Prompt", value="A photo of a room, modern design")
+                            i2p_neg_prompt = gr.Textbox(label="Negative Prompt", value="watermark, text")
+                            i2p_seed = gr.Slider(label="Seed", minimum=0, maximum=10000, step=1, value=100)
+                            with gr.Accordion("Advanced Settings", open=False):
+                                i2p_fov = gr.Slider(label="Field of View (FOV)", minimum=40, maximum=120, step=5, value=80)
+                                i2p_height = gr.Slider(label="Height", minimum=512, maximum=1024, step=64, value=960)
+                                i2p_width = gr.Slider(label="Width", minimum=1024, maximum=2048, step=128, value=1920)
+                                i2p_scale = gr.Slider(label="Guidance Scale", minimum=1, maximum=50, step=1, value=30)
+                                i2p_steps = gr.Slider(label="Inference Steps", minimum=10, maximum=100, step=5, value=50)
+                            i2p_button = gr.Button("Generate Panorama", variant="primary")
+                
+                with gr.Column():
+                    pano_output = gr.Image(label="Panorama Output", elem_id="pano_output")
+                    send_to_scene_btn = gr.Button("Step 2: Send to Scene Generation")
+        
+        with gr.TabItem("Step 2: Scene Generation") as scene_tab:
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Load the panorama generated in Step 1, or upload your own.")
+                    scene_input_image = gr.Image(type="filepath", label="Input Panorama")
+                    scene_classes = gr.Radio(["outdoor", "indoor"], label="Scene Class", value="outdoor")
+                    scene_fg1 = gr.Textbox(label="Foreground Labels (Layer 1)", placeholder="e.g., tree, car, person")
+                    scene_fg2 = gr.Textbox(label="Foreground Labels (Layer 2)", placeholder="e.g., building, mountain")
+                    scene_seed = gr.Slider(label="Seed", minimum=0, maximum=10000, step=1, value=2024)
+                    scene_button = gr.Button("Generate 3D Scene", variant="primary")
+                with gr.Column():
+                    scene_output = gr.Model3D(label="3D Scene Output (.ply)", elem_id="scene_output")
+
+    # Wire up components
+    t2p_button.click(
+        fn=generate_text_to_pano,
+        inputs=[t2p_prompt, t2p_neg_prompt, t2p_seed, t2p_height, t2p_width, t2p_scale, t2p_steps],
+        outputs=[pano_output, panorama_path_state]
+    )
+    i2p_button.click(
+        fn=generate_image_to_pano,
+        inputs=[i2p_prompt, i2p_neg_prompt, i2p_image, i2p_seed, i2p_height, i2p_width, i2p_scale, i2p_steps, i2p_fov],
+        outputs=[pano_output, panorama_path_state]
+    )
+
+    def transfer_to_scene_gen(path):
+        return {scene_input_image: gr.update(value=path)}
+
+    send_to_scene_btn.click(
+        fn=lambda path: path, 
+        inputs=panorama_path_state,
+        outputs=scene_input_image
+    ).then(
+        lambda: gr.Tabs.update(selected=scene_tab),
+        outputs=demo.children[1] # This is a bit of a hack to select the tab
+    )
+
+    scene_button.click(
+        fn=generate_scene,
+        inputs=[scene_input_image, scene_fg1, scene_fg2, scene_classes, scene_seed],
+        outputs=scene_output
+    )
+
+demo.queue().launch(debug=True)

demo_panogen.py

@@ -0,0 +1,223 @@
+# Tencent HunyuanWorld-1.0 is licensed under TENCENT HUNYUANWORLD-1.0 COMMUNITY LICENSE AGREEMENT
+# THIS LICENSE AGREEMENT DOES NOT APPLY IN THE EUROPEAN UNION, UNITED KINGDOM AND SOUTH KOREA AND 
+# IS EXPRESSLY LIMITED TO THE TERRITORY, AS DEFINED BELOW.
+# By clicking to agree or by using, reproducing, modifying, distributing, performing or displaying 
+# any portion or element of the Tencent HunyuanWorld-1.0 Works, including via any Hosted Service, 
+# You will be deemed to have recognized and accepted the content of this Agreement, 
+# which is effective immediately.
+
+# For avoidance of doubts, Tencent HunyuanWorld-1.0 means the 3D generation models 
+# and their software and algorithms, including trained model weights, parameters (including 
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code, 
+# fine-tuning enabling code and other elements of the foregoing made publicly available 
+# by Tencent at [https://github.com/Tencent-Hunyuan/HunyuanWorld-1.0].
+import os
+import torch
+import numpy as np 
+
+import cv2
+from PIL import Image
+
+import argparse
+
+# huanyuan3d text to panorama
+from hy3dworld import Text2PanoramaPipelines
+
+# huanyuan3d image to panorama
+from hy3dworld import Image2PanoramaPipelines
+from hy3dworld import Perspective
+
+
+class Text2PanoramaDemo:
+    def __init__(self):
+        # set default parameters
+        self.height = 960
+        self.width = 1920
+
+        # panorama parameters
+        # these parameters are used to control the panorama generation
+        # you can adjust them according to your needs
+        self.guidance_scale = 30
+        self.shifting_extend = 0
+        self.num_inference_steps = 50
+        self.true_cfg_scale = 0.0
+        self.blend_extend = 6
+
+        # model paths
+        self.lora_path = "tencent/HunyuanWorld-1"
+        self.model_path = "black-forest-labs/FLUX.1-dev"
+        # load the pipeline
+        # use bfloat16 to save some VRAM
+        self.pipe = Text2PanoramaPipelines.from_pretrained(
+            self.model_path,
+            torch_dtype=torch.bfloat16
+        ).to("cuda")
+        # and enable lora weights
+        self.pipe.load_lora_weights(
+            self.lora_path,
+            subfolder="HunyuanWorld-PanoDiT-Text",
+            weight_name="lora.safetensors",
+            torch_dtype=torch.bfloat16
+        )
+        # save some VRAM by offloading the model to CPU
+        self.pipe.enable_model_cpu_offload()
+        self.pipe.enable_vae_tiling()  # and enable vae tiling to save some VRAM
+
+    def run(self, prompt, negative_prompt=None, seed=42, output_path='output_panorama'):
+        # get panorama
+        image = self.pipe(
+            prompt,
+            height=self.height,
+            width=self.width,
+            negative_prompt=negative_prompt,
+            generator=torch.Generator("cpu").manual_seed(seed),
+            num_inference_steps=self.num_inference_steps,
+            guidance_scale=self.guidance_scale,
+            blend_extend=self.blend_extend,
+            true_cfg_scale=self.true_cfg_scale,
+        ).images[0]
+
+        # create output directory if it does not exist
+        os.makedirs(output_path, exist_ok=True)
+        # save the panorama image
+        if not isinstance(image, Image.Image):
+            image = Image.fromarray(image)
+        # save the image to the output path
+        image.save(os.path.join(output_path, 'panorama.png'))
+
+        return image
+
+
+class Image2PanoramaDemo:
+    def __init__(self):
+        # set default parameters
+        self.height, self.width = 960, 1920  # 768, 1536 #
+
+        # panorama parameters
+        # these parameters are used to control the panorama generation
+        # you can adjust them according to your needs
+        self.THETA = 0
+        self.PHI = 0
+        self.FOV = 80
+        self.guidance_scale = 30
+        self.num_inference_steps = 50
+        self.true_cfg_scale = 2.0
+        self.shifting_extend = 0
+        self.blend_extend = 6
+
+        # model paths
+        self.lora_path = "tencent/HunyuanWorld-1"
+        self.model_path = "black-forest-labs/FLUX.1-Fill-dev"
+        # load the pipeline
+        # use bfloat16 to save some VRAM
+        self.pipe = Image2PanoramaPipelines.from_pretrained(
+            self.model_path,
+            torch_dtype=torch.bfloat16
+        ).to("cuda")
+        # and enable lora weights
+        self.pipe.load_lora_weights(
+            self.lora_path,
+            subfolder="HunyuanWorld-PanoDiT-Image",
+            weight_name="lora.safetensors",
+            torch_dtype=torch.bfloat16
+        )
+        # save some VRAM by offloading the model to CPU
+        self.pipe.enable_model_cpu_offload()
+        self.pipe.enable_vae_tiling()  # and enable vae tiling to save some VRAM
+
+        # set general prompts
+        self.general_negative_prompt = (
+            "human, person, people, messy,"
+            "low-quality, blur, noise, low-resolution"
+        )
+        self.general_positive_prompt = "high-quality,  high-resolution, sharp, clear, 8k"
+
+    def run(self, prompt, negative_prompt, image_path, seed=42, output_path='output_panorama'):
+        # preprocess prompt
+        prompt = prompt + ", " + self.general_positive_prompt
+        negative_prompt = self.general_negative_prompt + ", " + negative_prompt
+
+        # read image
+        perspective_img = cv2.imread(image_path)
+        height_fov, width_fov = perspective_img.shape[:2]
+        if width_fov > height_fov:
+            ratio = width_fov / height_fov
+            w = int((self.FOV / 360) * self.width)
+            h = int(w / ratio)
+            perspective_img = cv2.resize(
+                perspective_img, (w, h), interpolation=cv2.INTER_AREA)
+        else:
+            ratio = height_fov / width_fov
+            h = int((self.FOV / 180) * self.height)
+            w = int(h / ratio)
+            perspective_img = cv2.resize(
+                perspective_img, (w, h), interpolation=cv2.INTER_AREA)
+
+        
+        equ = Perspective(perspective_img, self.FOV,
+                          self.THETA, self.PHI, crop_bound=False)
+        img, mask = equ.GetEquirec(self.height, self.width)
+        # erode mask
+        mask = cv2.erode(mask.astype(np.uint8), np.ones(
+            (3, 3), np.uint8), iterations=5)
+
+        img = img * mask
+
+        mask = mask.astype(np.uint8) * 255
+        mask = 255 - mask
+
+        mask = Image.fromarray(mask[:, :, 0])
+        img = cv2.cvtColor(img.astype(np.uint8), cv2.COLOR_BGR2RGB)
+        img = Image.fromarray(img)
+
+        image = self.pipe(
+            prompt=prompt,
+            image=img,
+            mask_image=mask,
+            height=self.height,
+            width=self.width,
+            negative_prompt=negative_prompt,
+            guidance_scale=self.guidance_scale,
+            num_inference_steps=self.num_inference_steps,
+            generator=torch.Generator("cpu").manual_seed(seed),
+            blend_extend=self.blend_extend,
+            shifting_extend=self.shifting_extend,
+            true_cfg_scale=self.true_cfg_scale,
+        ).images[0]
+
+        image.save(os.path.join(output_path, 'panorama.png'))
+
+        return image
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Text/Image to Panorama Demo")
+    parser.add_argument("--prompt", type=str,
+                        default="", help="Prompt for image generation")
+    parser.add_argument("--negative_prompt", type=str,
+                        default="", help="Negative prompt for image generation")
+    parser.add_argument("--image_path", type=str,
+                        default=None, help="Path to the input image")
+    parser.add_argument("--seed", type=int, default=42,
+                        help="Random seed for reproducibility")
+    parser.add_argument("--output_path", type=str, default="results",
+                        help="Path to save the output results")
+
+    args = parser.parse_args()
+
+    os.makedirs(args.output_path, exist_ok=True)
+    print(f"Output will be saved to: {args.output_path}")
+
+    if args.image_path is None:
+        print("No image path provided, using text-to-panorama generation.")
+        demo_T2P = Text2PanoramaDemo()
+        panorama_image = demo_T2P.run(
+            args.prompt, args.negative_prompt, args.seed, args.output_path)
+    else:
+        if not os.path.exists(args.image_path):
+            raise FileNotFoundError(
+                f"Image path {args.image_path} does not exist.")
+        print(f"Using image at {args.image_path} for panorama generation.")
+        demo_I2P = Image2PanoramaDemo()
+        panorama_image = demo_I2P.run(
+            args.prompt, args.negative_prompt, args.image_path, args.seed, args.output_path)

demo_scenegen.py

@@ -0,0 +1,120 @@
+# Tencent HunyuanWorld-1.0 is licensed under TENCENT HUNYUANWORLD-1.0 COMMUNITY LICENSE AGREEMENT
+# THIS LICENSE AGREEMENT DOES NOT APPLY IN THE EUROPEAN UNION, UNITED KINGDOM AND SOUTH KOREA AND 
+# IS EXPRESSLY LIMITED TO THE TERRITORY, AS DEFINED BELOW.
+# By clicking to agree or by using, reproducing, modifying, distributing, performing or displaying 
+# any portion or element of the Tencent HunyuanWorld-1.0 Works, including via any Hosted Service, 
+# You will be deemed to have recognized and accepted the content of this Agreement, 
+# which is effective immediately.
+
+# For avoidance of doubts, Tencent HunyuanWorld-1.0 means the 3D generation models 
+# and their software and algorithms, including trained model weights, parameters (including 
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code, 
+# fine-tuning enabling code and other elements of the foregoing made publicly available 
+# by Tencent at [https://github.com/Tencent-Hunyuan/HunyuanWorld-1.0].
+import os
+import torch
+import open3d as o3d
+
+import argparse
+
+# hunyuan3d sence generation
+from hy3dworld import LayerDecomposition
+from hy3dworld import WorldComposer, process_file
+
+
+class HYworldDemo:
+    def __init__(self, seed=42):
+
+        target_size = 3840
+        kernel_scale = max(1, int(target_size / 1920))
+
+        self.LayerDecomposer = LayerDecomposition()
+
+        self.hy3d_world = WorldComposer(
+            device=torch.device(
+                "cuda" if torch.cuda.is_available() else "cpu"),
+            resolution=(target_size, target_size // 2),
+            seed=seed,
+            filter_mask=True,
+            kernel_scale=kernel_scale,
+        )
+
+    def run(self, image_path, labels_fg1, labels_fg2, classes="outdoor", output_dir='output_hyworld', export_drc=False):
+        # foreground layer information
+        fg1_infos = [
+            {
+                "image_path": image_path,
+                "output_path": output_dir,
+                "labels": labels_fg1,
+                "class": classes,
+            }
+        ]
+        fg2_infos = [
+            {
+                "image_path": os.path.join(output_dir, 'remove_fg1_image.png'),
+                "output_path": output_dir,
+                "labels": labels_fg2,
+                "class": classes,
+            }
+        ]
+
+        # layer decompose
+        self.LayerDecomposer(fg1_infos, layer=0)
+        self.LayerDecomposer(fg2_infos, layer=1)
+        self.LayerDecomposer(fg2_infos, layer=2)
+        separate_pano, fg_bboxes = self.hy3d_world._load_separate_pano_from_dir(
+            output_dir, sr=True
+        )
+
+        # layer-wise reconstruction
+        layered_world_mesh = self.hy3d_world.generate_world(
+            separate_pano=separate_pano, fg_bboxes=fg_bboxes, world_type='mesh'
+        )
+
+        # save results
+        for layer_idx, layer_info in enumerate(layered_world_mesh):
+            # export ply
+            output_path = os.path.join(
+                output_dir, f"mesh_layer{layer_idx}.ply"
+            )
+            o3d.io.write_triangle_mesh(output_path, layer_info['mesh'])
+
+            # export drc
+            if export_drc:
+                output_path_drc = os.path.join(
+                    output_dir, f"mesh_layer{layer_idx}.drc"
+                )
+                process_file(output_path, output_path_drc)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Hunyuan3D World Gen Demo")
+    parser.add_argument("--image_path", type=str,
+                        default=None, help="Path to the Panorama image")
+    parser.add_argument("--labels_fg1", nargs='+', default=[],
+                        help="Labels for foreground objects in layer 1")
+    parser.add_argument("--labels_fg2", nargs='+', default=[],
+                        help="Labels for foreground objects in layer 2")
+    parser.add_argument("--classes", type=str, default="outdoor",
+                        help="Classes for sence generation")
+    parser.add_argument("--seed", type=int, default=42,
+                        help="Random seed for reproducibility")
+    parser.add_argument("--output_path", type=str, default="results",
+                        help="Path to save the output results")
+    parser.add_argument("--export_drc", type=bool, default=False,
+                        help="Whether to export Draco format")
+    
+    args = parser.parse_args()
+
+    os.makedirs(args.output_path, exist_ok=True)
+    print(f"Output will be saved to: {args.output_path}")
+
+    demo_HYworld = HYworldDemo(seed=args.seed)
+    demo_HYworld.run(
+        image_path=args.image_path,
+        labels_fg1=args.labels_fg1,
+        labels_fg2=args.labels_fg2,
+        classes=args.classes,
+        output_dir=args.output_path,
+        export_drc=args.export_drc
+    )

docker/HunyuanWorld.osx-cpu.yaml

@@ -0,0 +1,142 @@
+name: hunyuan_world
+channels:
+  - pytorch
+  - conda-forge
+  - defaults
+dependencies:
+  - python=3.10
+  - pytorch
+  - torchvision
+  - torchaudio
+  - numpy
+  - pillow
+  - pyyaml
+  - requests
+  - ffmpeg
+  - networkx
+  - pip
+  - pip:
+      - absl-py==2.2.2
+      - accelerate==1.6.0
+      - addict==2.4.0
+      - aiohappyeyeballs==2.6.1
+      - aiohttp==3.11.16
+      - aiosignal==1.3.2
+      - albumentations==0.5.2
+      - antlr4-python3-runtime==4.8
+      - asttokens==3.0.0
+      - async-timeout==5.0.1
+      - attrs==25.3.0
+      - av==14.3.0
+      - braceexpand==0.1.7
+      - cloudpickle==3.1.1
+      - colorama==0.4.6
+      - coloredlogs==15.0.1
+      - contourpy==1.3.2
+      - cycler==0.12.1
+      - cython==3.0.11
+      - eva-decord==0.6.1
+      - diffdist==0.1
+      - diffusers==0.32.0
+      - easydict==1.9
+      - einops==0.4.1
+      - executing==2.2.0
+      - facexlib==0.3.0
+      - filterpy==1.4.5
+      - flatbuffers==25.2.10
+      - fonttools==4.57.0
+      - frozenlist==1.6.0
+      - fsspec==2025.3.2
+      - ftfy==6.1.1
+      - future==1.0.0
+      - gfpgan==1.3.8
+      - grpcio==1.71.0
+      - h5py==3.7.0
+      - huggingface-hub==0.30.2
+      - humanfriendly==10.0
+      - hydra-core==1.1.0
+      - icecream==2.1.2
+      - imageio==2.37.0
+      - imageio-ffmpeg==0.4.9
+      - imgaug==0.4.0
+      - importlib-metadata==8.6.1
+      - inflect==5.6.0
+      - joblib==1.4.2
+      - kiwisolver==1.4.8
+      - kornia==0.8.0
+      - kornia-rs==0.1.8
+      - lazy-loader==0.4
+      - lightning-utilities==0.14.3
+      - llvmlite==0.44.0
+      - lmdb==1.6.2
+      - loguru==0.7.3
+      - markdown==3.8
+      - markdown-it-py==3.0.0
+      - matplotlib==3.10.1
+      - mdurl==0.1.2
+      - multidict==6.4.3
+      - natten==0.14.4
+      - numba==0.61.2
+      - omegaconf==2.1.2
+      - onnx==1.17.0
+      - onnxruntime==1.21.1
+      - open-clip-torch==2.30.0
+      - opencv-python==4.11.0.86
+      - opencv-python-headless==4.11.0.86
+      - packaging==24.2
+      - pandas==2.2.3
+      - peft==0.14.0
+      - platformdirs==4.3.7
+      - plyfile==1.1
+      - propcache==0.3.1
+      - protobuf==5.29.3
+      - psutil==7.0.0
+      - py-cpuinfo==9.0.0
+      - py360convert==1.0.3
+      - pygments==2.19.1
+      - pyparsing==3.2.3
+      - python-dateutil==2.9.0.post0
+      - pytorch-lightning==2.4.0
+      - pytz==2025.2
+      - qwen-vl-utils==0.0.8
+      - regex==2022.6.2
+      - rich==14.0.0
+      - safetensors==0.5.3
+      - scikit-image==0.24.0
+      - scikit-learn==1.6.1
+      - scipy==1.15.2
+      - seaborn==0.13.2
+      - segment-anything==1.0
+      - sentencepiece==0.2.0
+      - setuptools==59.5.0
+      - shapely==2.0.7
+      - six==1.17.0
+      - submitit==1.4.2
+      - sympy==1.13.1
+      - tabulate==0.9.0
+      - tb-nightly==2.20.0a20250421
+      - tensorboard-data-server==0.7.2
+      - termcolor==3.0.1
+      - threadpoolctl==3.6.0
+      - tifffile==2025.3.30
+      - timm==1.0.13
+      - tokenizers==0.21.1
+      - tomli==2.2.1
+      - torchmetrics==1.7.1
+      - tqdm==4.67.1
+      - transformers==4.51.0
+      - tzdata==2025.2
+      - ultralytics==8.3.74
+      - ultralytics-thop==2.0.14
+      - wcwidth==0.2.13
+      - webdataset==0.2.100
+      - werkzeug==3.1.3
+      - wldhx-yadisk-direct==0.0.6
+      - yapf==0.43.0
+      - yarl==1.20.0
+      - zipp==3.21.0
+      - open3d>=0.18.0
+      - trimesh>=4.6.1
+      - cmake
+      - pytorch3d @ git+https://github.com/facebookresearch/pytorch3d.git
+      - moge @ git+https://github.com/microsoft/MoGe.git

docker/HunyuanWorld.osx64.yaml

@@ -0,0 +1,247 @@
+name: HunyuanWorld
+channels:
+  - conda-forge
+  - pytorch
+  - nvidia
+  - defaults
+  - https://repo.anaconda.com/pkgs/main
+  - https://repo.anaconda.com/pkgs/r
+dependencies:
+  - _libgcc_mutex=0.1
+  - _openmp_mutex=5.1
+  - blas=1.0
+  - brotli-python=1.0.9
+  - bzip2=1.0.8
+  - ca-certificates=2025.2.25
+  - certifi=2025.1.31
+  - charset-normalizer=3.3.2
+  - cuda-cudart=12.4.127
+  - cuda-cupti=12.4.127
+  - cuda-libraries=12.4.1
+  - cuda-nvrtc=12.4.127
+  - cuda-nvtx=12.4.127
+  - cuda-opencl=12.8.90
+  - cuda-runtime=12.4.1
+  - cuda-version=12.8
+  - ffmpeg=4.3
+  - filelock=3.17.0
+  - freetype=2.13.3
+  - giflib=5.2.2
+  - gmp=6.3.0
+  - gmpy2=2.2.1
+  - gnutls=3.6.15
+  - idna=3.7
+  - intel-openmp=2023.1.0
+  - jinja2=3.1.6
+  - jpeg=9e
+  - lame=3.100
+  - lcms2=2.16
+  - ld_impl_linux-64=2.40
+  - lerc=4.0.0
+  - libcublas=12.4.5.8
+  - libcufft=11.2.1.3
+  - libcufile=1.13.1.3
+  - libcurand=10.3.9.90
+  - libcusolver=11.6.1.9
+  - libcusparse=12.3.1.170
+  - libdeflate=1.22
+  - libffi=3.4.4
+  - libgcc-ng=11.2.0
+  - libgomp=11.2.0
+  - libiconv=1.16
+  - libidn2=2.3.4
+  - libjpeg-turbo=2.0.0
+  - libnpp=12.2.5.30
+  - libnvfatbin=12.8.90
+  - libnvjitlink=12.4.127
+  - libnvjpeg=12.3.1.117
+  - libpng=1.6.39
+  - libstdcxx-ng=11.2.0
+  - libtasn1=4.19.0
+  - libtiff=4.7.0
+  - libunistring=0.9.10
+  - libuuid=1.41.5
+  - libwebp=1.3.2
+  - libwebp-base=1.3.2
+  - llvm-openmp=14.0.6
+  - lz4-c=1.9.4
+  - markupsafe=3.0.2
+  - mkl=2023.1.0
+  - mkl-service=2.4.0
+  - mkl_fft=1.3.11
+  - mkl_random=1.2.8
+  - mpc=1.3.1
+  - mpfr=4.2.1
+  - mpmath=1.3.0
+  - ncurses=6.4
+  - nettle=3.7.3
+  - networkx=3.4.2
+  - ocl-icd=2.3.2
+  - openh264=2.1.1
+  - openjpeg=2.5.2
+  - openssl=3.0.16
+  - pillow=11.1.0
+  - pip=25.0
+  - pysocks=1.7.1
+  - python=3.10.16
+  - pytorch=2.5.0
+  - pytorch-cuda=12.4
+  - pytorch-mutex=1.0
+  - pyyaml=6.0.2
+  - readline=8.2
+  - requests=2.32.3
+  - sqlite=3.45.3
+  - tbb=2021.8.0
+  - tk=8.6.14
+  - torchaudio=2.5.0
+  - torchvision=0.20.0
+  - typing_extensions=4.12.2
+  - urllib3=2.3.0
+  - wheel=0.45.1
+  - xz=5.6.4
+  - yaml=0.2.5
+  - zlib=1.2.13
+  - zstd=1.5.6
+  - pip:
+      - absl-py=
+      - accelerate=
+      - addict=
+      - aiohappyeyeballs=
+      - aiohttp=
+      - aiosignal=
+      - albumentations=
+      - antlr4-python3-runtime=
+      - asttokens=
+      - async-timeout=
+      - attrs=
+      - av=
+      - braceexpand=
+      - cloudpickle=
+      - colorama=
+      - coloredlogs=
+      - contourpy=
+      - cycler=
+      - cython=
+      - decord=
+      - diffdist=
+      - diffusers=
+      - easydict=
+      - einops=
+      - executing=
+      - facexlib=
+      - filterpy=
+      - flash-attn=
+      - flatbuffers=
+      - fonttools=
+      - frozenlist=
+      - fsspec=
+      - ftfy=
+      - future=
+      - gfpgan=
+      - grpcio=
+      - h5py=
+      - huggingface-hub=
+      - humanfriendly=
+      - hydra-core=
+      - icecream=
+      - imageio=
+      - imageio-ffmpeg=
+      - imgaug=
+      - importlib-metadata=
+      - inflect=
+      - joblib=
+      - kiwisolver=
+      - kornia=
+      - kornia-rs=
+      - lazy-loader=
+      - lightning-utilities=
+      - llvmlite=
+      - lmdb=
+      - loguru=
+      - markdown=
+      - markdown-it-py=
+      - matplotlib=
+      - mdurl=
+      - multidict=
+      - natten=
+      - numba=
+      - numpy=
+      - nvidia-cublas-cu12=
+      - nvidia-cuda-cupti-cu12=
+      - nvidia-cuda-nvrtc-cu12=
+      - nvidia-cuda-runtime-cu12=
+      - nvidia-cudnn-cu12=
+      - nvidia-cufft-cu12=
+      - nvidia-curand-cu12=
+      - nvidia-cusolver-cu12=
+      - nvidia-cusparse-cu12=
+      - nvidia-cusparselt-cu12=
+      - nvidia-nccl-cu12=
+      - nvidia-nvjitlink-cu12=
+      - nvidia-nvtx-cu12=
+      - omegaconf=
+      - onnx=
+      - onnxruntime-gpu=
+      - open-clip-torch=
+      - opencv-python=
+      - opencv-python-headless=
+      - packaging=
+      - pandas=
+      - peft=
+      - platformdirs=
+      - plyfile=
+      - propcache=
+      - protobuf=
+      - psutil=
+      - py-cpuinfo=
+      - py360convert=
+      - pygments=
+      - pyparsing=
+      - python-dateutil=
+      - pytorch-lightning=
+      - pytz=
+      - qwen-vl-utils=
+      - regex=
+      - rich=
+      - safetensors=
+      - scikit-image=
+      - scikit-learn=
+      - scipy=
+      - seaborn=
+      - segment-anything=
+      - sentencepiece=
+      - setuptools=
+      - shapely=
+      - six=
+      - submitit=
+      - sympy=
+      - tabulate=
+      - tb-nightly=
+      - tensorboard-data-server=
+      - termcolor=
+      - threadpoolctl=
+      - tifffile=
+      - timm=
+      - tokenizers=
+      - tomli=
+      - torchmetrics=
+      - tqdm=
+      - transformers=
+      - triton=
+      - tzdata=
+      - ultralytics=
+      - ultralytics-thop=
+      - wcwidth=
+      - webdataset=
+      - werkzeug=
+      - wldhx-yadisk-direct=
+      - xformers=
+      - yapf=
+      - yarl=
+      - zipp=
+      - open3d>=0.18.0
+      - trimesh>=4.6.1
+      - cmake
+      - pytorch3d @ git+https://github.com/facebookresearch/pytorch3d.git
+      - moge @ git+https://github.com/microsoft/MoGe.git
+prefix: /opt/conda/envs/HunyuanWorld

docker/HunyuanWorld.yaml

@@ -0,0 +1,246 @@
+name: HunyuanWorld
+channels:
+  - pytorch
+  - nvidia
+  - defaults
+  - https://repo.anaconda.com/pkgs/main
+  - https://repo.anaconda.com/pkgs/r
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - blas=1.0=mkl
+  - brotli-python=1.0.9=py310h6a678d5_9
+  - bzip2=1.0.8=h5eee18b_6
+  - ca-certificates=2025.2.25=h06a4308_0
+  - certifi=2025.1.31=py310h06a4308_0
+  - charset-normalizer=3.3.2=pyhd3eb1b0_0
+  - cuda-cudart=12.4.127=0
+  - cuda-cupti=12.4.127=0
+  - cuda-libraries=12.4.1=0
+  - cuda-nvrtc=12.4.127=0
+  - cuda-nvtx=12.4.127=0
+  - cuda-opencl=12.8.90=0
+  - cuda-runtime=12.4.1=0
+  - cuda-version=12.8=3
+  - ffmpeg=4.3=hf484d3e_0
+  - filelock=3.17.0=py310h06a4308_0
+  - freetype=2.13.3=h4a9f257_0
+  - giflib=5.2.2=h5eee18b_0
+  - gmp=6.3.0=h6a678d5_0
+  - gmpy2=2.2.1=py310h5eee18b_0
+  - gnutls=3.6.15=he1e5248_0
+  - idna=3.7=py310h06a4308_0
+  - intel-openmp=2023.1.0=hdb19cb5_46306
+  - jinja2=3.1.6=py310h06a4308_0
+  - jpeg=9e=h5eee18b_3
+  - lame=3.100=h7b6447c_0
+  - lcms2=2.16=h92b89f2_1
+  - ld_impl_linux-64=2.40=h12ee557_0
+  - lerc=4.0.0=h6a678d5_0
+  - libcublas=12.4.5.8=0
+  - libcufft=11.2.1.3=0
+  - libcufile=1.13.1.3=0
+  - libcurand=10.3.9.90=0
+  - libcusolver=11.6.1.9=0
+  - libcusparse=12.3.1.170=0
+  - libdeflate=1.22=h5eee18b_0
+  - libffi=3.4.4=h6a678d5_1
+  - libgcc-ng=11.2.0=h1234567_1
+  - libgomp=11.2.0=h1234567_1
+  - libiconv=1.16=h5eee18b_3
+  - libidn2=2.3.4=h5eee18b_0
+  - libjpeg-turbo=2.0.0=h9bf148f_0
+  - libnpp=12.2.5.30=0
+  - libnvfatbin=12.8.90=0
+  - libnvjitlink=12.4.127=0
+  - libnvjpeg=12.3.1.117=0
+  - libpng=1.6.39=h5eee18b_0
+  - libstdcxx-ng=11.2.0=h1234567_1
+  - libtasn1=4.19.0=h5eee18b_0
+  - libtiff=4.7.0=hde9077f_0
+  - libunistring=0.9.10=h27cfd23_0
+  - libuuid=1.41.5=h5eee18b_0
+  - libwebp=1.3.2=h9f374a3_1
+  - libwebp-base=1.3.2=h5eee18b_1
+  - llvm-openmp=14.0.6=h9e868ea_0
+  - lz4-c=1.9.4=h6a678d5_1
+  - markupsafe=3.0.2=py310h5eee18b_0
+  - mkl=2023.1.0=h213fc3f_46344
+  - mkl-service=2.4.0=py310h5eee18b_2
+  - mkl_fft=1.3.11=py310h5eee18b_0
+  - mkl_random=1.2.8=py310h1128e8f_0
+  - mpc=1.3.1=h5eee18b_0
+  - mpfr=4.2.1=h5eee18b_0
+  - mpmath=1.3.0=py310h06a4308_0
+  - ncurses=6.4=h6a678d5_0
+  - nettle=3.7.3=hbbd107a_1
+  - networkx=3.4.2=py310h06a4308_0
+  - ocl-icd=2.3.2=h5eee18b_1
+  - openh264=2.1.1=h4ff587b_0
+  - openjpeg=2.5.2=h0d4d230_1
+  - openssl=3.0.16=h5eee18b_0
+  - pillow=11.1.0=py310hac6e08b_1
+  - pip=25.0=py310h06a4308_0
+  - pysocks=1.7.1=py310h06a4308_0
+  - python=3.10.16=he870216_1
+  - pytorch=2.5.0=py3.10_cuda12.4_cudnn9.1.0_0
+  - pytorch-cuda=12.4=hc786d27_7
+  - pytorch-mutex=1.0=cuda
+  - pyyaml=6.0.2=py310h5eee18b_0
+  - readline=8.2=h5eee18b_0
+  - requests=2.32.3=py310h06a4308_1
+  - sqlite=3.45.3=h5eee18b_0
+  - tbb=2021.8.0=hdb19cb5_0
+  - tk=8.6.14=h39e8969_0
+  - torchaudio=2.5.0=py310_cu124
+  - torchvision=0.20.0=py310_cu124
+  - typing_extensions=4.12.2=py310h06a4308_0
+  - urllib3=2.3.0=py310h06a4308_0
+  - wheel=0.45.1=py310h06a4308_0
+  - xz=5.6.4=h5eee18b_1
+  - yaml=0.2.5=h7b6447c_0
+  - zlib=1.2.13=h5eee18b_1
+  - zstd=1.5.6=hc292b87_0
+  - pip:
+      - absl-py==2.2.2
+      - accelerate==1.6.0
+      - addict==2.4.0
+      - aiohappyeyeballs==2.6.1
+      - aiohttp==3.11.16
+      - aiosignal==1.3.2
+      - albumentations==0.5.2
+      - antlr4-python3-runtime==4.8
+      - asttokens==3.0.0
+      - async-timeout==5.0.1
+      - attrs==25.3.0
+      - av==14.3.0
+      - braceexpand==0.1.7
+      - cloudpickle==3.1.1
+      - colorama==0.4.6
+      - coloredlogs==15.0.1
+      - contourpy==1.3.2
+      - cycler==0.12.1
+      - cython==3.0.11
+      - decord==0.6.0
+      - diffdist==0.1
+      - diffusers==0.32.0
+      - easydict==1.9
+      - einops==0.4.1
+      - executing==2.2.0
+      - facexlib==0.3.0
+      - filterpy==1.4.5
+      - flash-attn==2.7.4.post1
+      - flatbuffers==25.2.10
+      - fonttools==4.57.0
+      - frozenlist==1.6.0
+      - fsspec==2025.3.2
+      - ftfy==6.1.1
+      - future==1.0.0
+      - gfpgan==1.3.8
+      - grpcio==1.71.0
+      - h5py==3.7.0
+      - huggingface-hub==0.30.2
+      - humanfriendly==10.0
+      - hydra-core==1.1.0
+      - icecream==2.1.2
+      - imageio==2.37.0
+      - imageio-ffmpeg==0.4.9
+      - imgaug==0.4.0
+      - importlib-metadata==8.6.1
+      - inflect==5.6.0
+      - joblib==1.4.2
+      - kiwisolver==1.4.8
+      - kornia==0.8.0
+      - kornia-rs==0.1.8
+      - lazy-loader==0.4
+      - lightning-utilities==0.14.3
+      - llvmlite==0.44.0
+      - lmdb==1.6.2
+      - loguru==0.7.3
+      - markdown==3.8
+      - markdown-it-py==3.0.0
+      - matplotlib==3.10.1
+      - mdurl==0.1.2
+      - multidict==6.4.3
+      - natten==0.14.4
+      - numba==0.61.2
+      - numpy==1.24.1
+      - nvidia-cublas-cu12==12.4.5.8
+      - nvidia-cuda-cupti-cu12==12.4.127
+      - nvidia-cuda-nvrtc-cu12==12.4.127
+      - nvidia-cuda-runtime-cu12==12.4.127
+      - nvidia-cudnn-cu12==9.1.0.70
+      - nvidia-cufft-cu12==11.2.1.3
+      - nvidia-curand-cu12==10.3.5.147
+      - nvidia-cusolver-cu12==11.6.1.9
+      - nvidia-cusparse-cu12==12.3.1.170
+      - nvidia-cusparselt-cu12==0.6.2
+      - nvidia-nccl-cu12==2.21.5
+      - nvidia-nvjitlink-cu12==12.4.127
+      - nvidia-nvtx-cu12==12.4.127
+      - omegaconf==2.1.2
+      - onnx==1.17.0
+      - onnxruntime-gpu==1.21.1
+      - open-clip-torch==2.30.0
+      - opencv-python==4.11.0.86
+      - opencv-python-headless==4.11.0.86
+      - packaging==24.2
+      - pandas==2.2.3
+      - peft==0.14.0
+      - platformdirs==4.3.7
+      - plyfile==1.1
+      - propcache==0.3.1
+      - protobuf==5.29.3
+      - psutil==7.0.0
+      - py-cpuinfo==9.0.0
+      - py360convert==1.0.3
+      - pygments==2.19.1
+      - pyparsing==3.2.3
+      - python-dateutil==2.9.0.post0
+      - pytorch-lightning==2.4.0
+      - pytz==2025.2
+      - qwen-vl-utils==0.0.8
+      - regex==2022.6.2
+      - rich==14.0.0
+      - safetensors==0.5.3
+      - scikit-image==0.24.0
+      - scikit-learn==1.6.1
+      - scipy==1.15.2
+      - seaborn==0.13.2
+      - segment-anything==1.0
+      - sentencepiece==0.2.0
+      - setuptools==59.5.0
+      - shapely==2.0.7
+      - six==1.17.0
+      - submitit==1.4.2
+      - sympy==1.13.1
+      - tabulate==0.9.0
+      - tb-nightly==2.20.0a20250421
+      - tensorboard-data-server==0.7.2
+      - termcolor==3.0.1
+      - threadpoolctl==3.6.0
+      - tifffile==2025.3.30
+      - timm==1.0.13
+      - tokenizers==0.21.1
+      - tomli==2.2.1
+      - torchmetrics==1.7.1
+      - tqdm==4.67.1
+      - transformers==4.51.0
+      - triton==3.2.0
+      - tzdata==2025.2
+      - ultralytics==8.3.74
+      - ultralytics-thop==2.0.14
+      - wcwidth==0.2.13
+      - webdataset==0.2.100
+      - werkzeug==3.1.3
+      - wldhx-yadisk-direct==0.0.6
+      - xformers==0.0.28.post2
+      - yapf==0.43.0
+      - yarl==1.20.0
+      - zipp==3.21.0
+      - open3d>=0.18.0
+      - trimesh>=4.6.1
+      - cmake
+      - pytorch3d @ git+https://github.com/facebookresearch/pytorch3d.git
+      - moge @ git+https://github.com/microsoft/MoGe.git
+prefix: /opt/conda/envs/HunyuanWorld

docker/HunyuanWorld_mac.yaml

@@ -0,0 +1,186 @@
+name: HunyuanWorld-mac
+channels:
+  - pytorch
+  - conda-forge
+  - defaults
+dependencies:
+  - python=3.10
+  - pytorch
+  - torchvision
+  - torchaudio
+  - ffmpeg
+  - filelock
+  - freetype
+  - gmp
+  - gmpy2
+  - gnutls
+  - idna
+  - jinja2
+  - jpeg
+  - lame
+  - lcms2
+  - lerc
+  - libdeflate
+  - libffi
+  - libiconv
+  - libidn2
+  - libpng
+  - libtasn1
+  - libtiff
+  - libunistring
+  - libuuid
+  - libwebp
+  - llvm-openmp
+  - lz4-c
+  - markupsafe
+  - mpc
+  - mpfr
+  - mpmath
+  - ncurses
+  - nettle
+  - networkx
+  - openh264
+  - openjpeg
+  - openssl
+  - pillow
+  - pip
+  - pysocks
+  - pyyaml
+  - readline
+  - requests
+  - sqlite
+  - tbb
+  - tk
+  - typing_extensions
+  - urllib3
+  - wheel
+  - xz
+  - yaml
+  - zlib
+  - zstd
+  - pip:
+      - absl-py==2.2.2
+      - accelerate==1.6.0
+      - addict==2.4.0
+      - aiohappyeyeballs==2.6.1
+      - aiohttp==3.11.16
+      - aiosignal==1.3.2
+      - albumentations==0.5.2
+      - antlr4-python3-runtime==4.8
+      - asttokens==3.0.0
+      - async-timeout==5.0.1
+      - attrs==25.3.0
+      - av==14.3.0
+      - braceexpand==0.1.7
+      - cloudpickle==3.1.1
+      - colorama==0.4.6
+      - coloredlogs==15.0.1
+      - contourpy==1.3.2
+      - cycler==0.12.1
+      - cython==3.0.11
+      - decord==0.6.0
+      - diffdist==0.1
+      - diffusers==0.32.0
+      - easydict==1.9
+      - einops==0.4.1
+      - executing==2.2.0
+      - facexlib==0.3.0
+      - filterpy==1.4.5
+      - flatbuffers==25.2.10
+      - fonttools==4.57.0
+      - frozenlist==1.6.0
+      - fsspec==2025.3.2
+      - ftfy==6.1.1
+      - future==1.0.0
+      - gfpgan==1.3.8
+      - grpcio==1.71.0
+      - h5py==3.7.0
+      - huggingface-hub==0.30.2
+      - humanfriendly==10.0
+      - hydra-core==1.1.0
+      - icecream==2.1.2
+      - imageio==2.37.0
+      - imageio-ffmpeg==0.4.9
+      - imgaug==0.4.0
+      - importlib-metadata==8.6.1
+      - inflect==5.6.0
+      - joblib==1.4.2
+      - kiwisolver==1.4.8
+      - kornia==0.8.0
+      - kornia-rs==0.1.8
+      - lazy-loader==0.4
+      - lightning-utilities==0.14.3
+      - llvmlite==0.44.0
+      - lmdb==1.6.2
+      - loguru==0.7.3
+      - markdown==3.8
+      - markdown-it-py==3.0.0
+      - matplotlib==3.10.1
+      - mdurl==0.1.2
+      - multidict==6.4.3
+      - natten==0.14.4
+      - numba==0.61.2
+      - numpy==1.24.1
+      - omegaconf==2.1.2
+      - onnx==1.17.0
+      - onnxruntime
+      - open-clip-torch==2.30.0
+      - opencv-python==4.11.0.86
+      - opencv-python-headless==4.11.0.86
+      - packaging==24.2
+      - pandas==2.2.3
+      - peft==0.14.0
+      - platformdirs==4.3.7
+      - plyfile==1.1
+      - propcache==0.3.1
+      - protobuf==5.29.3
+      - psutil==7.0.0
+      - py-cpuinfo==9.0.0
+      - py360convert==1.0.3
+      - pygments==2.19.1
+      - pyparsing==3.2.3
+      - python-dateutil==2.9.0.post0
+      - pytorch-lightning==2.4.0
+      - pytz==2025.2
+      - qwen-vl-utils==0.0.8
+      - regex==2022.6.2
+      - rich==14.0.0
+      - safetensors==0.5.3
+      - scikit-image==0.24.0
+      - scikit-learn==1.6.1
+      - scipy==1.15.2
+      - seaborn==0.13.2
+      - segment-anything==1.0
+      - sentencepiece==0.2.0
+      - setuptools==59.5.0
+      - shapely==2.0.7
+      - six==1.17.0
+      - submitit==1.4.2
+      - sympy==1.13.1
+      - tabulate==0.9.0
+      - tb-nightly==2.20.0a20250421
+      - tensorboard-data-server==0.7.2
+      - termcolor==3.0.1
+      - threadpoolctl==3.6.0
+      - tifffile==2025.3.30
+      - timm==1.0.13
+      - tokenizers==0.21.1
+      - tomli==2.2.1
+      - torchmetrics==1.7.1
+      - tqdm==4.67.1
+      - transformers==4.51.0
+      - tzdata==2025.2
+      - ultralytics==8.3.74
+      - ultralytics-thop==2.0.14
+      - wcwidth==0.2.13
+      - webdataset==0.2.100
+      - werkzeug==3.1.3
+      - wldhx-yadisk-direct==0.0.6
+      - yapf==0.43.0
+      - yarl==1.20.0
+      - zipp==3.21.0
+      - open3d>=0.18.0
+      - trimesh>=4.6.1
+      - cmake
+      - pytorch3d @ git+https://github.com/facebookresearch/pytorch3d.git
+      - moge @ git+https://github.com/microsoft/MoGe.git

examples/case1/classes.txt

@@ -0,0 +1 @@
+outdoor

examples/case2/classes.txt

@@ -0,0 +1 @@
+outdoor

examples/case2/labels_fg1.txt

@@ -0,0 +1 @@
+stones

examples/case2/labels_fg2.txt

@@ -0,0 +1 @@
+trees

examples/case3/classes.txt

@@ -0,0 +1 @@
+outdoor

examples/case4/classes.txt

@@ -0,0 +1 @@
+outdoor

examples/case4/prompt.txt

@@ -0,0 +1 @@
+There is a rocky island on the vast sea surface, with a triangular rock burning red flames in the center of the island. The sea is open and rough, with a green surface. Surrounded by towering peaks in the distance.

examples/case5/classes.txt

@@ -0,0 +1 @@
+outdoor

examples/case6/classes.txt

@@ -0,0 +1 @@
+outdoor

examples/case6/labels_fg1.txt

@@ -0,0 +1 @@
+tent

examples/case7/classes.txt

@@ -0,0 +1 @@
+outdoor

examples/case7/prompt.txt

@@ -0,0 +1 @@
+At the moment of glacier collapse, giant ice walls collapse and create waves, with no wildlife, captured in a disaster documentary

examples/case8/classes.txt

@@ -0,0 +1 @@
+outdoor

examples/case9/classes.txt

@@ -0,0 +1 @@
+outdoor

examples/case9/prompt.txt

@@ -0,0 +1 @@
+A breathtaking volcanic eruption scene. In the center of the screen, one or more volcanoes are erupting violently, with hot orange red lava gushing out from the crater, illuminating the surrounding night sky and landscape. Thick smoke and volcanic ash rose into the sky, forming a huge mushroom cloud like structure. Some of the smoke and dust were reflected in a dark red color by the high temperature of the lava, creating a doomsday atmosphere. In the foreground, a winding lava flow flows through the dark and rough rocks like a fire snake, emitting a dazzling light as if burning the earth. The steep and rugged mountains in the background further emphasize the ferocity and irresistible power of nature. The entire picture has a strong contrast of light and shadow, with red, black, and gray as the main colors, highlighting the visual impact and dramatic tension of volcanic eruptions, making people feel the grandeur and terror of nature.

hy3dworld/__init__.py

@@ -0,0 +1,22 @@
+# Tencent HunyuanWorld-1.0 is licensed under TENCENT HUNYUANWORLD-1.0 COMMUNITY LICENSE AGREEMENT
+# THIS LICENSE AGREEMENT DOES NOT APPLY IN THE EUROPEAN UNION, UNITED KINGDOM AND SOUTH KOREA AND 
+# IS EXPRESSLY LIMITED TO THE TERRITORY, AS DEFINED BELOW.
+# By clicking to agree or by using, reproducing, modifying, distributing, performing or displaying 
+# any portion or element of the Tencent HunyuanWorld-1.0 Works, including via any Hosted Service, 
+# You will be deemed to have recognized and accepted the content of this Agreement, 
+# which is effective immediately.
+
+# For avoidance of doubts, Tencent HunyuanWorld-1.0 means the 3D generation models 
+# and their software and algorithms, including trained model weights, parameters (including 
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code, 
+# fine-tuning enabling code and other elements of the foregoing made publicly available 
+# by Tencent at [https://github.com/Tencent-Hunyuan/HunyuanWorld-1.0].
+# Image to Panorama
+from .models import Image2PanoramaPipelines
+from .utils import Perspective
+# Text to Panorama
+from .models import Text2PanoramaPipelines
+# Sence Generation
+from .models import LayerDecomposition
+from .models import WorldComposer
+from .utils import process_file

hy3dworld/models/__init__.py

@@ -0,0 +1,29 @@
+# Tencent HunyuanWorld-1.0 is licensed under TENCENT HUNYUANWORLD-1.0 COMMUNITY LICENSE AGREEMENT
+# THIS LICENSE AGREEMENT DOES NOT APPLY IN THE EUROPEAN UNION, UNITED KINGDOM AND SOUTH KOREA AND 
+# IS EXPRESSLY LIMITED TO THE TERRITORY, AS DEFINED BELOW.
+# By clicking to agree or by using, reproducing, modifying, distributing, performing or displaying 
+# any portion or element of the Tencent HunyuanWorld-1.0 Works, including via any Hosted Service, 
+# You will be deemed to have recognized and accepted the content of this Agreement, 
+# which is effective immediately.
+
+# For avoidance of doubts, Tencent HunyuanWorld-1.0 means the 3D generation models 
+# and their software and algorithms, including trained model weights, parameters (including 
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code, 
+# fine-tuning enabling code and other elements of the foregoing made publicly available 
+# by Tencent at [https://github.com/Tencent-Hunyuan/HunyuanWorld-1.0].
+
+# Image to Panorama
+from .pano_generator import Image2PanoramaPipelines
+# Text to Panorama
+from .pano_generator import Text2PanoramaPipelines
+
+# Scene Generation
+from .pipelines import FluxPipeline, FluxFillPipeline
+from .layer_decomposer import LayerDecomposition
+from .world_composer import WorldComposer
+
+__all__ = [
+    "Image2PanoramaPipelines", "Text2PanoramaPipelines",
+    "FluxPipeline", "FluxFillPipeline",
+    "LayerDecomposition", "WorldComposer",
+]

hy3dworld/models/adaptive_depth_compression.py

@@ -0,0 +1,474 @@
+# Tencent HunyuanWorld-1.0 is licensed under TENCENT HUNYUANWORLD-1.0 COMMUNITY LICENSE AGREEMENT
+# THIS LICENSE AGREEMENT DOES NOT APPLY IN THE EUROPEAN UNION, UNITED KINGDOM AND SOUTH KOREA AND 
+# IS EXPRESSLY LIMITED TO THE TERRITORY, AS DEFINED BELOW.
+# By clicking to agree or by using, reproducing, modifying, distributing, performing or displaying 
+# any portion or element of the Tencent HunyuanWorld-1.0 Works, including via any Hosted Service, 
+# You will be deemed to have recognized and accepted the content of this Agreement, 
+# which is effective immediately.
+
+# For avoidance of doubts, Tencent HunyuanWorld-1.0 means the 3D generation models 
+# and their software and algorithms, including trained model weights, parameters (including 
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code, 
+# fine-tuning enabling code and other elements of the foregoing made publicly available 
+# by Tencent at [https://github.com/Tencent-Hunyuan/HunyuanWorld-1.0].
+import torch
+from typing import List, Dict, Tuple
+
+
+class AdaptiveDepthCompressor:
+    r"""
+    Adaptive depth compressor to solve the problem of excessive background depth variance
+    in 3D world generation. This class provides methods to compress background and foreground
+    depth values based on statistical analysis of depth distributions, with options for
+    smooth compression and outlier removal.
+    Args:
+        cv_thresholds: Tuple of (low, high) thresholds for coefficient of variation (CV).
+        compression_quantiles: Tuple of (low, medium, high) quantiles for depth compression.
+        fg_bg_depth_margin: Margin factor to ensure foreground depth is greater than background.
+        enable_smooth_compression: Whether to use smooth compression instead of hard truncation.
+        outlier_removal_method: Method for outlier removal, options are "iqr", "quantile", or "none".
+        min_compression_depth: Minimum depth threshold for compression to be applied.
+    """
+
+    def __init__(
+        self,
+        cv_thresholds: Tuple[float, float] = (0.3, 0.8),
+        compression_quantiles: Tuple[float, float, float] = (0.95, 0.92, 0.85),
+        fg_bg_depth_margin: float = 1.1,
+        enable_smooth_compression: bool = True,
+        outlier_removal_method: str = "iqr",
+        min_compression_depth: float = 6.0,
+    ):
+        self.cv_thresholds = cv_thresholds
+        self.compression_quantiles = compression_quantiles
+        self.fg_bg_depth_margin = fg_bg_depth_margin
+        self.enable_smooth_compression = enable_smooth_compression
+        self.outlier_removal_method = outlier_removal_method
+        self.min_compression_depth = min_compression_depth
+
+    def _remove_outliers(self, depth_vals: torch.Tensor) -> torch.Tensor:
+        r"""
+        Remove outliers from depth values
+        based on the specified method (IQR or quantile).
+        Args:
+            depth_vals: Tensor of depth values to process.
+        Returns:
+            Tensor of depth values with outliers removed.
+        """
+        if self.outlier_removal_method == "iqr":
+            q25, q75 = torch.quantile(depth_vals, torch.tensor(
+                [0.25, 0.75], device=depth_vals.device))
+            iqr = q75 - q25
+            lower_bound, upper_bound = q25 - 1.5 * iqr, q75 + 1.5 * iqr
+            valid_mask = (depth_vals >= lower_bound) & (
+                depth_vals <= upper_bound)
+        elif self.outlier_removal_method == "quantile":
+            q05, q95 = torch.quantile(depth_vals, torch.tensor(
+                [0.05, 0.95], device=depth_vals.device))
+            valid_mask = (depth_vals >= q05) & (depth_vals <= q95)
+        else:
+            return depth_vals
+        return depth_vals[valid_mask] if valid_mask.sum() > 0 else depth_vals
+
+    def _collect_foreground_depths(
+        self, 
+        layered_world_depth: List[Dict]
+    ) -> List[torch.Tensor]:
+        r"""
+        Collect depth information of all foreground layers (remove outliers)
+        from the layered world depth representation.
+        Args:
+            layered_world_depth: List of dictionaries containing depth information for each layer.
+        Returns:
+            List of tensors containing cleaned foreground depth values.
+        """
+        fg_depths = []
+        for layer_depth in layered_world_depth:
+            if layer_depth["name"] == "background":
+                continue
+
+            depth_vals = layer_depth["distance"]
+            mask = layer_depth.get("mask", None)
+
+            # Process the depth values within the mask area
+            if mask is not None:
+                if not isinstance(mask, torch.Tensor):
+                    mask = torch.from_numpy(mask).to(depth_vals.device)
+                depth_vals = depth_vals[mask.bool()]
+
+            if depth_vals.numel() > 0:
+                cleaned_depths = self._remove_outliers(depth_vals)
+                if len(cleaned_depths) > 0:
+                    fg_depths.append(cleaned_depths)
+        return fg_depths
+
+    def _get_pixelwise_foreground_max_depth(
+        self, 
+        layered_world_depth: List[Dict], 
+        bg_shape: torch.Size, 
+        bg_device: torch.device
+    ) -> torch.Tensor:
+        r"""
+        Calculate the maximum foreground depth for each pixel position
+        Args:
+            layered_world_depth: List of dictionaries containing depth information for each layer.
+            bg_shape: Shape of the background depth tensor.
+            bg_device: Device where the background depth tensor is located.
+        Returns:
+            Tensor of maximum foreground depth values for each pixel position.
+        """
+        fg_max_depth = torch.zeros(bg_shape, device=bg_device)
+
+        for layer_depth in layered_world_depth:
+            if layer_depth["name"] == "background":
+                continue
+
+            layer_distance = layer_depth["distance"]
+            layer_mask = layer_depth.get("mask", None)
+
+            # Ensure that the tensor is on the correct device
+            if not isinstance(layer_distance, torch.Tensor):
+                layer_distance = torch.from_numpy(layer_distance).to(bg_device)
+            else:
+                layer_distance = layer_distance.to(bg_device)
+
+            # Update the maximum depth of the foreground
+            if layer_mask is not None:
+                if not isinstance(layer_mask, torch.Tensor):
+                    layer_mask = torch.from_numpy(layer_mask).to(bg_device)
+                else:
+                    layer_mask = layer_mask.to(bg_device)
+                fg_max_depth = torch.where(layer_mask.bool(), torch.max(
+                    fg_max_depth, layer_distance), fg_max_depth)
+            else:
+                fg_max_depth = torch.max(fg_max_depth, layer_distance)
+
+        return fg_max_depth
+
+    def _analyze_depth_distribution(self, bg_depth_distance: torch.Tensor) -> Dict:
+        r"""
+        Analyze the distribution characteristics of background depth
+        Args:
+            bg_depth_distance: Tensor of background depth distances.
+        Returns:
+            Dictionary containing statistical properties of the background depth distribution.
+        """
+        bg_mean, bg_std = torch.mean(
+            bg_depth_distance), torch.std(bg_depth_distance)
+        cv = bg_std / bg_mean
+
+        quantiles = torch.quantile(bg_depth_distance,
+                                   torch.tensor([0.5, 0.75, 0.9, 0.95, 0.99], device=bg_depth_distance.device))
+        bg_q50, bg_q75, bg_q90, bg_q95, bg_q99 = quantiles
+
+        return {"mean": bg_mean, "std": bg_std, "cv": cv, "q50": bg_q50,
+                "q75": bg_q75, "q90": bg_q90, "q95": bg_q95, "q99": bg_q99}
+
+    def _determine_compression_strategy(self, cv: float) -> Tuple[str, float]:
+        r"""
+        Determine compression strategy based on coefficient of variation
+        Args:
+            cv: Coefficient of variation of the background depth distribution.
+        Returns:
+            Tuple containing the compression strategy ("gentle", "standard", "aggressive")
+            and the quantile to use for compression.
+        """
+        low_cv_threshold, high_cv_threshold = self.cv_thresholds
+        low_var_quantile, medium_var_quantile, high_var_quantile = self.compression_quantiles
+
+        if cv < low_cv_threshold:
+            return "gentle", low_var_quantile
+        elif cv > high_cv_threshold:
+            return "aggressive", high_var_quantile
+        else:
+            return "standard", medium_var_quantile
+
+    def _smooth_compression(self, depth_values: torch.Tensor, max_depth: torch.Tensor,
+                            mask: torch.Tensor = None, transition_start_ratio: float = 0.95,
+                            transition_range_ratio: float = 0.2, verbose: bool = False) -> torch.Tensor:
+        r"""
+        Use smooth compression function instead of hard truncation
+        Args:
+            depth_values: Tensor of depth values to compress.
+            max_depth: Maximum depth value for compression.
+            mask: Optional mask to apply compression only to certain pixels.
+            transition_start_ratio: Ratio to determine the start of the transition range.
+            transition_range_ratio: Ratio to determine the range of the transition.
+            verbose: Whether to print detailed information about the compression process.
+        Returns:
+            Compressed depth values as a tensor.
+        """
+        if not self.enable_smooth_compression:
+            compressed = depth_values.clone()
+            if mask is not None:
+                compressed[mask] = torch.clamp(
+                    depth_values[mask], max=max_depth)
+            else:
+                compressed = torch.clamp(depth_values, max=max_depth)
+            return compressed
+
+        transition_start = max_depth * transition_start_ratio
+        transition_range = max_depth * transition_range_ratio
+        compressed_depth = depth_values.clone()
+
+        mask_far = depth_values > transition_start
+        if mask is not None:
+            mask_far = mask_far & mask
+
+        if mask_far.sum() > 0:
+            far_depths = depth_values[mask_far]
+            normalized = (far_depths - transition_start) / transition_range
+            compressed_normalized = torch.sigmoid(
+                normalized * 2 - 1) * 0.5 + 0.5
+            compressed_far = transition_start + \
+                compressed_normalized * (max_depth - transition_start)
+            compressed_depth[mask_far] = compressed_far
+            if verbose:
+                print(
+                    f"\t   Applied smooth compression to {mask_far.sum()} pixels beyond {transition_start:.2f}")
+        elif verbose:
+            print(f"\t   No compression needed, all depths within reasonable range")
+
+        return compressed_depth
+
+    def compress_background_depth(self, bg_depth_distance: torch.Tensor, layered_world_depth: List[Dict],
+                                  bg_mask: torch.Tensor, verbose: bool = False) -> torch.Tensor:
+        r"""
+        Adaptive compression of background depth values
+        Args:
+            bg_depth_distance: Tensor of background depth distances.
+            layered_world_depth: List of dictionaries containing depth information for each layer.
+            bg_mask: Tensor or numpy array representing the mask for background depth.
+            verbose: Whether to print detailed information about the compression process.
+        Returns:
+            Compressed background depth values as a tensor.
+        """
+        if verbose:
+            print(f"\t - Applying adaptive depth compression...")
+
+        # Process mask
+        if not isinstance(bg_mask, torch.Tensor):
+            bg_mask = torch.from_numpy(bg_mask).to(bg_depth_distance.device)
+        mask_bool = bg_mask.bool()
+        masked_depths = bg_depth_distance[mask_bool]
+
+        if masked_depths.numel() == 0:
+            if verbose:
+                print(f"\t   No valid depths in mask region, skipping compression")
+            return bg_depth_distance
+
+        # 1. Collect prospect depth information
+        fg_depths = self._collect_foreground_depths(layered_world_depth)
+
+        # 2. Calculate prospect depth statistics
+        if fg_depths:
+            all_fg_depths = torch.cat(fg_depths)
+            fg_max = torch.quantile(all_fg_depths, torch.tensor(
+                0.99, device=all_fg_depths.device))
+            if verbose:
+                print(
+                    f"\t   Foreground depth stats - 99th percentile: {fg_max:.2f}")
+        else:
+            fg_max = torch.quantile(masked_depths, torch.tensor(
+                0.5, device=masked_depths.device))
+            if verbose:
+                print(f"\t   No foreground found, using background stats for reference")
+
+        # 3. Analyze the depth distribution of the background
+        depth_stats = self._analyze_depth_distribution(masked_depths)
+        if verbose:
+            print(
+                f"\t   Background depth stats - mean: {depth_stats['mean']:.2f}, \
+                    std: {depth_stats['std']:.2f}, CV: {depth_stats['cv']:.3f}")
+
+        # 4. Determine compression strategy
+        strategy, compression_quantile = self._determine_compression_strategy(
+            depth_stats['cv'])
+        max_depth = torch.quantile(masked_depths, torch.tensor(
+            compression_quantile, device=masked_depths.device))
+
+        if verbose:
+            print(
+                f"\t   {strategy.capitalize()} compression strategy \
+                    (CV={depth_stats['cv']:.3f}), quantile={compression_quantile}")
+
+        # 5. Pixel level depth constraint
+        if fg_depths:
+            fg_max_depth_pixelwise = self._get_pixelwise_foreground_max_depth(
+                layered_world_depth, bg_depth_distance.shape, bg_depth_distance.device)
+            required_min_bg_depth = fg_max_depth_pixelwise * self.fg_bg_depth_margin
+            pixelwise_violations = (
+                bg_depth_distance < required_min_bg_depth) & mask_bool
+
+            if pixelwise_violations.sum() > 0:
+                violation_ratio = pixelwise_violations.float().sum() / mask_bool.float().sum()
+                violated_required_depths = required_min_bg_depth[pixelwise_violations]
+                pixelwise_min_depth = torch.quantile(violated_required_depths, torch.tensor(
+                    0.99, device=violated_required_depths.device))
+                max_depth = torch.max(max_depth, pixelwise_min_depth)
+                if verbose:
+                    print(
+                        f"\t   Pixelwise constraint violation: {violation_ratio:.1%}, \
+                            adjusted max depth to {max_depth:.2f}")
+            elif verbose:
+                print(f"\t   Pixelwise depth constraints satisfied")
+
+        # 6. Global statistical constraints
+        if fg_depths:
+            min_bg_depth = fg_max * self.fg_bg_depth_margin
+            max_depth = torch.max(max_depth, min_bg_depth)
+            if verbose:
+                print(f"\t   Final max depth: {max_depth:.2f}")
+
+        # 6.5. Depth threshold check: If max_depth is less than the threshold, skip compression
+        if max_depth < self.min_compression_depth:
+            if verbose:
+                print(
+                    f"\t   Max depth {max_depth:.2f} is below threshold \
+                        {self.min_compression_depth:.2f}, skipping compression")
+            return bg_depth_distance
+
+        # 7. Application compression
+        compressed_depth = self._smooth_compression(
+            bg_depth_distance, max_depth, mask_bool, 0.9, 0.2, verbose)
+
+        # 8. Hard truncation of extreme outliers
+        final_max = max_depth * 1.2
+        outliers = (compressed_depth > final_max) & mask_bool
+        if outliers.sum() > 0:
+            compressed_depth[outliers] = final_max
+
+        # 9. statistic
+        compression_ratio = ((bg_depth_distance > max_depth)
+                             & mask_bool).float().sum() / mask_bool.float().sum()
+        if verbose:
+            print(
+                f"\t   Compression summary - max depth: \
+                    {max_depth:.2f}, affected: {compression_ratio:.1%}")
+
+        return compressed_depth
+
+    def compress_foreground_depth(
+        self, 
+        fg_depth_distance: torch.Tensor, 
+        fg_mask: torch.Tensor,
+        verbose: bool = False, 
+        conservative_ratio: float = 0.99,
+        iqr_scale: float = 2
+    ) -> torch.Tensor:
+        r"""
+        Conservatively compress outliers for foreground depth
+        Args:
+            fg_depth_distance: Tensor of foreground depth distances.
+            fg_mask: Tensor or numpy array representing the mask for foreground depth.
+            verbose: Whether to print detailed information about the compression process.
+            conservative_ratio: Ratio to use for conservative compression.
+            iqr_scale: Scale factor for IQR-based upper bound.
+        Returns:
+            Compressed foreground depth values as a tensor.
+        """
+        if verbose:
+            print(f"\t - Applying conservative foreground depth compression...")
+
+        # Process mask
+        if not isinstance(fg_mask, torch.Tensor):
+            fg_mask = torch.from_numpy(fg_mask).to(fg_depth_distance.device)
+        mask_bool = fg_mask.bool()
+        masked_depths = fg_depth_distance[mask_bool]
+
+        if masked_depths.numel() == 0:
+            if verbose:
+                print(f"\t   No valid depths in mask region, skipping compression")
+            return fg_depth_distance
+
+        # Calculate statistical information
+        depth_mean, depth_std = torch.mean(
+            masked_depths), torch.std(masked_depths)
+
+        # Determine the upper bound using IQR and quantile methods
+        q25, q75 = torch.quantile(masked_depths, torch.tensor(
+            [0.25, 0.75], device=masked_depths.device))
+        iqr = q75 - q25
+        upper_bound = q75 + iqr_scale * iqr
+        conservative_max = torch.quantile(masked_depths, torch.tensor(
+            conservative_ratio, device=masked_depths.device))
+        final_max = torch.max(upper_bound, conservative_max)
+
+        # Statistical Outliers
+        outliers = (fg_depth_distance > final_max) & mask_bool
+        outlier_count = outliers.sum().item()
+
+        if verbose:
+            print(
+                f"\t   Depth stats - mean: {depth_mean:.2f}, std: {depth_std:.2f}")
+            print(
+                f"\t   IQR bounds - Q25: {q25:.2f}, Q75: {q75:.2f}, upper: {upper_bound:.2f}")
+            print(
+                f"\t   Conservative max: {conservative_max:.2f}, final max: {final_max:.2f}")
+            print(
+                f"\t   Outliers: {outlier_count} ({(outlier_count/masked_depths.numel()*100):.2f}%)")
+
+        # Depth threshold check: If final_max is less than the threshold, skip compression
+        if final_max < self.min_compression_depth:
+            if verbose:
+                print(
+                    f"\t   Final max depth {final_max:.2f} is below threshold \
+                        {self.min_compression_depth:.2f}, skipping compression")
+            return fg_depth_distance
+
+        # Apply compression
+        if outlier_count > 0:
+            compressed_depth = self._smooth_compression(
+                fg_depth_distance, final_max, mask_bool, 0.99, 0.1, verbose)
+        else:
+            compressed_depth = fg_depth_distance.clone()
+
+        return compressed_depth
+
+
+def create_adaptive_depth_compressor(
+    scene_type: str = "auto",
+    enable_smooth_compression: bool = True,
+    outlier_removal_method: str = "iqr",
+    min_compression_depth: float = 6.0,  # Minimum compression depth threshold
+) -> AdaptiveDepthCompressor:
+    r"""
+    Create adaptive depth compressors suitable for different scene types
+    Args:
+        scene_type: Scenario Type ("indoor", "outdoor", "mixed", "auto")
+        enable_smooth_compression: enable smooth compression or not
+        outlier_removal_method: Outlier removal method ("iqr", "quantile", "none")
+    """
+    common_params = {
+        "enable_smooth_compression": enable_smooth_compression,
+        "outlier_removal_method": outlier_removal_method,
+        "min_compression_depth": min_compression_depth,
+    }
+
+    if scene_type == "indoor":
+        # Indoor scene: Depth variation is relatively small, conservative compression is used
+        return AdaptiveDepthCompressor(
+            cv_thresholds=(0.2, 0.6),
+            compression_quantiles=(1.0, 0.975, 0.95),
+            fg_bg_depth_margin=1.05,
+            **common_params
+        )
+    elif scene_type == "outdoor":
+        # Outdoor scenes: There may be sky, distant mountains, etc., using more aggressive compression
+        return AdaptiveDepthCompressor(
+            cv_thresholds=(0.4, 1.0),
+            compression_quantiles=(0.98, 0.955, 0.93),
+            fg_bg_depth_margin=1.15,
+            **common_params
+        )
+    elif scene_type == "mixed":
+        # Mixed Scene: Balanced Settings
+        return AdaptiveDepthCompressor(
+            cv_thresholds=(0.3, 0.8),
+            compression_quantiles=(0.99, 0.97, 0.95),
+            fg_bg_depth_margin=1.1,
+            **common_params
+        )
+    else:  # auto
+        # Automatic mode: Use default settings
+        return AdaptiveDepthCompressor(**common_params)

hy3dworld/models/layer_decomposer.py

@@ -0,0 +1,155 @@
+import os
+import json
+import torch
+from ..utils import sr_utils, seg_utils, inpaint_utils, layer_utils
+
+
+class LayerDecomposition():
+    r"""LayerDecomposition is responsible for generating layers in a scene based on input images and masks.
+    It processes foreground objects, background layers, and sky regions using various models.
+    Args:
+        seed (int): Random seed for reproducibility.
+        strength (float): Strength of the layer generation.
+        threshold (int): Threshold for object detection.
+        ratio (float): Ratio for scaling objects.
+        grounding_model (str): Path to the grounding model for object detection.
+        zim_model_config (str): Configuration for the ZIM model.
+        zim_checkpoint (str): Path to the ZIM model checkpoint.
+        inpaint_model (str): Path to the inpainting model.
+        inpaint_fg_lora (str): Path to the LoRA weights for foreground inpainting.
+        inpaint_sky_lora (str): Path to the LoRA weights for sky inpainting.
+        scale (int): Scale factor for super-resolution.
+        device (str): Device to run the model on, either "cuda" or "cpu".
+        dilation_size (int): Size of the dilation for mask processing.
+        cfg_scale (float): Configuration scale for the model.
+        prompt_config (dict): Configuration for prompts used in the model.
+    """
+    def __init__(self):
+        r"""Initialize the LayerDecomposition class with model paths and parameters."""
+        self.seed = 25
+        self.strength = 1.0
+        self.threshold = 20000
+        self.ratio = 1.5
+        self.grounding_model = "IDEA-Research/grounding-dino-tiny"
+        self.zim_model_config = "vit_l"
+        self.zim_checkpoint = "./ZIM/zim_vit_l_2092"  # Add zim anything ckpt here
+        self.inpaint_model = "black-forest-labs/FLUX.1-Fill-dev"
+        self.inpaint_fg_lora = "tencent/HunyuanWorld-1"
+        self.inpaint_sky_lora = "tencent/HunyuanWorld-1"
+        self.scale = 2
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.dilation_size = 80
+        self.cfg_scale = 5.0
+        self.prompt_config = {
+            "indoor": {
+                "positive_prompt": "",
+                "negative_prompt": (
+                    "object, table, chair, seat, shelf, sofa, bed, bath, sink,"
+                    "ceramic, wood, plant, tree, light, lamp, candle, television, electronics,"
+                    "oven, fire, low-resolution, blur, mosaic, people")
+            },
+            "outdoor": {
+                "positive_prompt": "",
+                "negative_prompt": (
+                    "object, chair, tree, plant, flower, grass, stone, rock," 
+                    "building, hill, house, tower, light, lamp, low-resolution, blur, mosaic, people")
+            }
+        }
+
+        # Load models
+        print("=============  now loading models ===============")
+        # super-resolution model
+        self.sr_model = sr_utils.build_sr_model(scale=self.scale, gpu_id=0)
+        print("=============  load Super-Resolution models done ")
+        # segmentation model
+        self.zim_predictor = seg_utils.build_zim_model(
+            self.zim_model_config, self.zim_checkpoint, device='cuda:0')
+        self.gd_processor, self.gd_model = seg_utils.build_gd_model(
+            self.grounding_model, device='cuda:0')
+        print("=============  load Segmentation models done ====")
+        # panorama inpaint model
+        self.inpaint_fg_model = inpaint_utils.build_inpaint_model(
+            self.inpaint_model,
+            self.inpaint_fg_lora,
+            subfolder="HunyuanWorld-PanoInpaint-Scene",
+            device=0
+        )
+        self.inpaint_sky_model = inpaint_utils.build_inpaint_model(
+            self.inpaint_model,
+            self.inpaint_sky_lora,
+            subfolder="HunyuanWorld-PanoInpaint-Sky",
+            device=0
+        )
+        print("=============  load panorama inpaint models done =")
+
+    def __call__(self, input, layer):
+        r"""Generate layers based on the input images and masks.
+        Args:
+            input (str or list): Path to the input JSON file or a list of image information.
+            layer (int): Layer index to process (0 for foreground1, 1 for foreground2,
+                         2 for sky).
+        Raises:
+            FileNotFoundError: If the input file does not exist.
+            ValueError: If the input file is not a JSON file or if the layer index is invalid.
+            TypeError: If the input is neither a string nor a list.
+        """
+        torch.autocast(device_type=self.device,
+                       dtype=torch.bfloat16).__enter__()
+
+        # Input handling and validation
+        if isinstance(input, str):
+            if not os.path.exists(input):
+                raise FileNotFoundError(f"Input file {input} does not exist.")
+            if not input.endswith('.json'):
+                raise ValueError("Input file must be a JSON file.")
+            with open(input, "r") as f:
+                img_infos = json.load(f)
+                img_infos = img_infos["output"]
+        elif isinstance(input, list):
+            img_infos = input
+        else:
+            raise TypeError("Input must be a JSON file path or a list.")
+
+        # Processing parameters
+        params = {
+            'scale': self.scale,
+            'seed': self.seed,
+            'threshold': self.threshold,
+            'ratio': self.ratio,
+            'strength': self.strength,
+            'dilation_size': self.dilation_size,
+            'cfg_scale': self.cfg_scale,
+            'prompt_config': self.prompt_config
+        }
+
+        # Layer-specific processing pipelines
+        if layer == 0:
+            layer_utils.remove_fg1_pipeline(
+                img_infos=img_infos,
+                sr_model=self.sr_model,
+                zim_predictor=self.zim_predictor,
+                gd_processor=self.gd_processor,
+                gd_model=self.gd_model,
+                inpaint_model=self.inpaint_fg_model,
+                params=params
+            )
+        elif layer == 1:
+            layer_utils.remove_fg2_pipeline(
+                img_infos=img_infos,
+                sr_model=self.sr_model,
+                zim_predictor=self.zim_predictor,
+                gd_processor=self.gd_processor,
+                gd_model=self.gd_model,
+                inpaint_model=self.inpaint_fg_model,
+                params=params
+            )
+        else:
+            layer_utils.sky_pipeline(
+                img_infos=img_infos,
+                sr_model=self.sr_model,
+                zim_predictor=self.zim_predictor,
+                gd_processor=self.gd_processor,
+                gd_model=self.gd_model,
+                inpaint_model=self.inpaint_sky_model,
+                params=params
+            )

hy3dworld/models/pano_generator.py

@@ -0,0 +1,236 @@
+# Tencent HunyuanWorld-1.0 is licensed under TENCENT HUNYUANWORLD-1.0 COMMUNITY LICENSE AGREEMENT
+# THIS LICENSE AGREEMENT DOES NOT APPLY IN THE EUROPEAN UNION, UNITED KINGDOM AND SOUTH KOREA AND 
+# IS EXPRESSLY LIMITED TO THE TERRITORY, AS DEFINED BELOW.
+# By clicking to agree or by using, reproducing, modifying, distributing, performing or displaying 
+# any portion or element of the Tencent HunyuanWorld-1.0 Works, including via any Hosted Service, 
+# You will be deemed to have recognized and accepted the content of this Agreement, 
+# which is effective immediately.
+
+# For avoidance of doubts, Tencent HunyuanWorld-1.0 means the 3D generation models 
+# and their software and algorithms, including trained model weights, parameters (including 
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code, 
+# fine-tuning enabling code and other elements of the foregoing made publicly available 
+# by Tencent at [https://github.com/Tencent-Hunyuan/HunyuanWorld-1.0].
+
+import torch
+from transformers import (
+    CLIPTextModel,
+    CLIPTokenizer,
+    T5EncoderModel,
+    T5TokenizerFast,
+)
+
+from diffusers.image_processor import VaeImageProcessor
+from diffusers.models.autoencoders import AutoencoderKL
+
+from diffusers.models.transformers import FluxTransformer2DModel
+from diffusers.schedulers import FlowMatchEulerDiscreteScheduler
+
+from diffusers.utils.torch_utils import randn_tensor
+
+from .pipelines import FluxPipeline, FluxFillPipeline
+
+class Text2PanoramaPipelines(FluxPipeline):
+    @torch.no_grad()
+    def __call__(self, prompt, **kwargs):
+        """Main inpainting call."""
+        return self._call_shared(prompt=prompt, is_inpainting=False, early_steps=3, **kwargs)
+
+
+class Image2PanoramaPipelines(FluxFillPipeline):
+    def __init__(
+        self,
+        scheduler: FlowMatchEulerDiscreteScheduler,
+        vae: AutoencoderKL,
+        text_encoder: CLIPTextModel,
+        tokenizer: CLIPTokenizer,
+        text_encoder_2: T5EncoderModel,
+        tokenizer_2: T5TokenizerFast,
+        transformer: FluxTransformer2DModel,
+    ):
+        # Initilization from FluxFillPipeline
+        super().__init__(
+            scheduler=scheduler,
+            vae=vae,
+            text_encoder=text_encoder,
+            tokenizer=tokenizer,
+            text_encoder_2=text_encoder_2,
+            tokenizer_2=tokenizer_2,
+            transformer=transformer,
+        )
+
+        # change some part of initilization
+        self.latent_channels = self.vae.config.latent_channels if getattr(
+            self, "vae", None) else 16
+        
+        self.mask_processor = VaeImageProcessor(
+            vae_scale_factor=self.vae_scale_factor * 2,
+            vae_latent_channels=self.latent_channels,
+            do_normalize=False,
+            do_binarize=True,
+            do_convert_grayscale=True,
+        )
+
+    def get_timesteps(self, num_inference_steps, strength, device):
+        # get the original timestep using init_timestep
+        init_timestep = min(num_inference_steps *
+                            strength, num_inference_steps)
+
+        t_start = int(max(num_inference_steps - init_timestep, 0))
+        timesteps = self.scheduler.timesteps[t_start * self.scheduler.order:]
+        if hasattr(self.scheduler, "set_begin_index"):
+            self.scheduler.set_begin_index(t_start * self.scheduler.order)
+
+        return timesteps, num_inference_steps - t_start
+
+    def prepare_inpainting_latents(
+        self,
+        batch_size,
+        num_channels_latents,
+        height,
+        width,
+        dtype,
+        device,
+        generator,
+        latents=None,
+        image=None,
+        is_strength_max=True,
+        timestep=None,
+    ):
+        r"""
+        Prepares the latents for the Image2PanoramaPipelines.
+        """
+        if isinstance(generator, list) and len(generator) != batch_size:
+            raise ValueError(
+                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
+            )
+
+        # VAE applies 8x compression on images but we must also account for packing which requires
+        # latent height and width to be divisible by 2.
+        height = 2 * (int(height) // (self.vae_scale_factor * 2))
+        width = 2 * (int(width) // (self.vae_scale_factor * 2))
+        shape = (batch_size, num_channels_latents, height, width)
+
+        # Return the latents if they are already provided
+        if latents is not None:
+            return latents.to(device=device, dtype=dtype), latent_image_ids
+
+        # If no latents are provided, we need to encode the image
+        image = image.to(device=device, dtype=dtype)
+        if image.shape[1] != self.latent_channels:
+            image_latents = self._encode_vae_image(
+                image=image, generator=generator)
+        else:
+            image_latents = image
+        
+        # Ensure image_latents has the correct shape
+        if batch_size > image_latents.shape[0] and batch_size % image_latents.shape[0] == 0:
+            # expand init_latents for batch_size
+            additional_image_per_prompt = batch_size // image_latents.shape[0]
+            image_latents = torch.cat(
+                [image_latents] * additional_image_per_prompt, dim=0)
+        elif batch_size > image_latents.shape[0] and batch_size % image_latents.shape[0] != 0:
+            raise ValueError(
+                f"Cannot duplicate `image` of batch size {image_latents.shape[0]} to {batch_size} text prompts."
+            )
+        else:
+            image_latents = torch.cat([image_latents], dim=0)
+        # Add noise to the latents
+        noise = randn_tensor(shape, generator=generator,
+                             device=device, dtype=dtype)
+        latents = self.scheduler.scale_noise(image_latents, timestep, noise)
+        
+        # prepare blended latents
+        latents = torch.cat(
+            [latents, latents[:, :, :, :self.blend_extend]], dim=-1)
+        width_new_blended = latents.shape[-1]
+        latents = self._pack_latents(
+            latents, batch_size, num_channels_latents, height, width_new_blended)
+        # prepare latent image ids
+        latent_image_ids = self._prepare_latent_image_ids(
+            batch_size, height // 2, width_new_blended // 2, device, dtype)
+
+        return latents, latent_image_ids, width_new_blended
+
+    def prepare_blending_latent(
+        self, latents, height, width, batch_size, num_channels_latents, width_new_blended=None
+    ):
+        return latents, width_new_blended
+    
+    def _apply_blending(
+        self,
+        latents: torch.Tensor,
+        height: int,
+        width_new_blended: int,
+        num_channels_latents: int,
+        batch_size: int,
+        **karwgs,
+    ) -> torch.Tensor:
+        r"""Apply horizontal blending to latents."""
+        # Unpack latents for processing
+        latents_unpack = self._unpack_latents(
+            latents, height, width_new_blended*self.vae_scale_factor, self.vae_scale_factor
+        )
+        # Apply blending
+        latents_unpack = self.blend_h(latents_unpack, latents_unpack, self.blend_extend)
+        
+        latent_height = 2 * \
+            (int(height) // (self.vae_scale_factor * 2))
+
+        shifting_extend = karwgs.get("shifting_extend", None)
+        if shifting_extend is None:
+            shifting_extend = latents_unpack.size()[-1]//4
+        
+        latents_unpack = torch.roll(
+            latents_unpack, shifting_extend, -1)
+        
+        # Repack latents after blending
+        latents = self._pack_latents(
+            latents_unpack, batch_size, num_channels_latents, latent_height, width_new_blended)
+        return latents
+
+    def _apply_blending_mask(
+        self,
+        latents: torch.Tensor,
+        height: int,
+        width_new_blended: int,
+        num_channels_latents: int,
+        batch_size: int,
+        **kwargs
+    ) -> torch.Tensor:
+        r"""Apply horizontal blending to mask latents."""
+        return self._apply_blending(
+            latents, height, width_new_blended, 80, batch_size, **kwargs
+        )
+
+    def _final_process_latents(
+        self,
+        latents: torch.Tensor,
+        height: int,
+        width_new_blended: int,
+        width: int
+    ) -> torch.Tensor:
+        """Final processing of latents before decoding."""
+        # Unpack and crop to target width
+        latents_unpack = self._unpack_latents(
+            latents, height, width_new_blended * self.vae_scale_factor, self.vae_scale_factor
+        )
+        latents_unpack = self.blend_h(
+            latents_unpack, latents_unpack, self.blend_extend
+        )
+        latents_unpack = latents_unpack[:, :, :, :width // self.vae_scale_factor]
+        
+        # Repack for final output
+        return self._pack_latents(
+            latents_unpack,
+            latents.shape[0],  # batch size
+            latents.shape[2] // 4,  # num_channels_latents
+            height // self.vae_scale_factor,
+            width // self.vae_scale_factor
+        )
+
+    @torch.no_grad()
+    def __call__(self, **kwargs):
+        """Main inpainting call."""
+        return self._call_shared(is_inpainting=True, early_steps=3, blend_extra_chanel=True, **kwargs)