change workflow

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+# Require review for all changes
+* @MrNeRF

.github/workflows/validate-and-build.yml → .github/workflows/generate-html.yml

@@ -1,22 +1,19 @@
-name: Validate YAML and Generate HTML
+name: Generate HTML on Main
 
 on:
-  pull_request:
+  push:
     branches: [ main ]
     paths:
       - 'awesome_3dgs_papers.yaml'
 
 jobs:
-  validate-and-build:
+  build:
     runs-on: ubuntu-latest
     permissions:
       contents: write
-      pull-requests: write
 
     steps:
     - uses: actions/checkout@v3
-      with:
-        fetch-depth: 0  # Fetch all history for PR comparison
 
     - name: Set up Python
       uses: actions/setup-python@v4
@@ -28,30 +25,13 @@ jobs:
         python -m pip install --upgrade pip
         pip install -r requirements.txt
 
-    - name: Validate Changed YAML entries
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        PR_NUMBER: ${{ github.event.pull_request.number }}
-        REPO: ${{ github.repository }}
-      run: |
-        python src/validate_yaml.py
-
     - name: Generate HTML
       run: |
         python src/generate.py awesome_3dgs_papers.yaml index.html
 
     - name: Commit and push if changed
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       run: |
         git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
         git config --local user.name "github-actions[bot]"
-        git fetch origin
-        git checkout ${{ github.head_ref }}
         git add index.html
-        if git diff --staged --quiet; then
-          echo "No changes to commit"
-        else
-          git commit -m "Update index.html"
-          git push origin ${{ github.head_ref }}
-        fi
+        git diff --staged --quiet || (git commit -m "Update index.html" && git push)

.github/workflows/validate-pr.yml

@@ -0,0 +1,41 @@
+name: Validate PR Changes
+
+on:
+  pull_request:
+    branches: [ main ]
+    paths:
+      - 'awesome_3dgs_papers.yaml'
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: read
+      contents: read
+
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.10'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+
+    - name: Validate Changed YAML entries
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        PR_NUMBER: ${{ github.event.pull_request.number }}
+        REPO: ${{ github.repository }}
+      run: |
+        python src/validate_yaml.py
+
+    - name: Generate HTML (validation only)
+      run: |
+        python src/generate.py awesome_3dgs_papers.yaml index.html

awesome_3dgs_papers.yaml

@@ -1191,6 +1191,51 @@
   - Robotics
   thumbnail: assets/thumbnails/zubair2024neural.jpg
   publication_date: '2024-10-26T16:26:41+00:00'
+- id: fan2024large
+  title: 'Large Spatial Model: End-to-end Unposed Images to Semantic 3D'
+  authors: Zhiwen Fan, Jian Zhang, Wenyan Cong, Peihao Wang, Renjie Li, Kairun Wen,
+    Shijie Zhou, Achuta Kadambi, Zhangyang Wang, Danfei Xu, Boris Ivanovic, Marco
+    Pavone, Yue Wang
+  year: '2024'
+  abstract: 'Reconstructing and understanding 3D structures from a limited number
+    of images is a well-established problem in computer vision. Traditional methods
+    usually break this task into multiple subtasks, each requiring complex transformations
+    between different data representations. For instance, dense reconstruction through
+    Structure-from-Motion (SfM) involves converting images into key points, optimizing
+    camera parameters, and estimating structures. Afterward, accurate sparse reconstructions
+    are required for further dense modeling, which is subsequently fed into task-specific
+    neural networks. This multi-step process results in considerable processing time
+    and increased engineering complexity. In this work, we present the Large Spatial
+    Model (LSM), which processes unposed RGB images directly into semantic radiance
+    fields. LSM simultaneously estimates geometry, appearance, and semantics in a
+    single feed-forward operation, and it can generate versatile label maps by interacting
+    with language at novel viewpoints. Leveraging a Transformer-based architecture,
+    LSM integrates global geometry through pixel-aligned point maps. To enhance spatial
+    attribute regression, we incorporate local context aggregation with multi-scale
+    fusion, improving the accuracy of fine local details. To tackle the scarcity of
+    labeled 3D semantic data and enable natural language-driven scene manipulation,
+    we incorporate a pre-trained 2D language-based segmentation model into a 3D-consistent
+    semantic feature field. An efficient decoder then parameterizes a set of semantic
+    anisotropic Gaussians, facilitating supervised end-to-end learning. Extensive
+    experiments across various tasks show that LSM unifies multiple 3D vision tasks
+    directly from unposed images, achieving real-time semantic 3D reconstruction for
+    the first time.
+
+    '
+  project_page: https://largespatialmodel.github.io/
+  paper: https://arxiv.org/pdf/2410.18956.pdf
+  code: https://github.com/NVlabs/LSM
+  video: https://largespatialmodel.github.io/static/videos/LSM_demo1.mp4
+  tags:
+  - Code
+  - Feed-Forward
+  - Poses
+  - Project
+  - Segmentation
+  - Video
+  thumbnail: assets/thumbnails/fan2024large.jpg
+  publication_date: '2024-10-24T17:54:42+00:00'
+  date_source: arxiv
 - id: lee2024fully
   title: Fully Explicit Dynamic Gaussian Splatting
   authors: Junoh Lee, Changyeon Won, HyunJun Jung, Inhwan Bae, Hae-Gon Jeon

src/yaml_editor.py

@@ -1,4 +1,5 @@
 import sys
+from src.fix_date import YAMLUpdater
 import yaml
 import webbrowser
 from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
@@ -16,6 +17,7 @@
 class YAMLEditor(QMainWindow):
     def __init__(self):
         super().__init__()
+        self.yaml_updater = YAMLUpdater() 
         self.setWindowTitle("3D Gaussian Splatting Paper Editor")
         self.setMinimumSize(1200, 800)
 
@@ -249,7 +251,7 @@ def setup_ui(self):
         main_layout.addLayout(content_layout)
 
     def auto_save(self):
-        """Automatically save changes"""
+        """Automatically save changes with date updating"""
         entry = self.data[self.current_index]
 
         # Update basic fields
@@ -273,11 +275,26 @@ def auto_save(self):
         # Update tags
         entry['tags'] = sorted([tag for tag, btn in self.tag_buttons.items() if btn.isChecked()])
 
+        # Process date information if needed
+        if 'publication_date' not in entry:
+            updated_entry, success = self.yaml_updater.process_paper(entry)
+            if success:
+                entry.update(updated_entry)
+
         try:
+            # Sort data before saving
+            self.data.sort(key=self.yaml_updater.safe_sort_key, reverse=True)
+
+            # Find the new index of the current entry after sorting
+            current_entry_id = entry['id']
+            self.current_index = next(i for i, e in enumerate(self.data) if e['id'] == current_entry_id)
+
             with open("awesome_3dgs_papers.yaml", 'w', encoding='utf-8') as file:
                 yaml.dump(self.data, file, sort_keys=False, allow_unicode=True)
+
             self.show_save_feedback(True)
             self.original_entry_state = self.get_entry_state(entry)
+            self.entry_counter.setText(f"Entry {self.current_index + 1} of {len(self.data)}")
             return True
         except Exception as e:
             self.show_save_feedback(False)
@@ -463,31 +480,73 @@ def add_arxiv_button(self):
         self.arxiv_button = QPushButton("Add from arXiv")
         self.arxiv_button.clicked.connect(self.show_arxiv_dialog)
         self.nav_layout.addWidget(self.arxiv_button)
-        
+
     def refresh_ui(self):
-        """Force a complete UI refresh"""
-        print("Starting refresh_ui")  # Debug print
-        old_len = len(self.data)  # Store old length
+        """Force a complete UI refresh with correct positioning"""
+        print("Starting refresh_ui")
+        old_index = self.current_index
+        old_id = self.data[old_index]['id'] if self.data else None
+
         self.load_yaml()
-        new_len = len(self.data)  # New length
-        print(f"Data length before: {old_len}, after: {new_len}")  # Debug print
+
+        # Find the index of the entry with the same ID
+        if old_id:
+            try:
+                self.current_index = next(i for i, entry in enumerate(self.data) if entry['id'] == old_id)
+            except StopIteration:
+                self.current_index = 0
+
         self.show_current_entry()
         self.clear_search_results()
         self.entry_counter.setText(f"Entry {self.current_index + 1} of {len(self.data)}")
-        QApplication.processEvents()  # Force Qt to process pending events
-        print("Finished refresh_ui")  # Debug print
+        QApplication.processEvents()
+        print(f"Finished refresh_ui at index {self.current_index}")
 
     def show_arxiv_dialog(self):
         print("Opening arXiv dialog")
         dialog = ArxivAddDialog(self)
         result = dialog.exec()
         print(f"Dialog result: {result}")
         if result == 1:
-            print("Dialog accepted, about to refresh")
-            self.refresh_ui()  # First refresh to get new data
-            self.current_index = len(self.data) - 1  # Then set to last entry
-            self.show_current_entry()  # Show the new entry
-            print(f"Refresh complete, showing entry {self.current_index + 1} of {len(self.data)}")
+            print("Dialog accepted, getting newly added entry")
+
+            # Read the current YAML file
+            with open("awesome_3dgs_papers.yaml", 'r', encoding='utf-8') as file:
+                current_data = yaml.safe_load(file)
+
+            # Get the newest entry and its ID before any modifications
+            new_entry = current_data[-1]
+            new_entry_id = new_entry['id']
+            print(f"New entry ID: {new_entry_id}")
+
+            # Update date information
+            updated_entry, success = self.yaml_updater.process_paper(new_entry)
+            if success:
+                current_data[-1] = updated_entry
+
+                # Sort the data
+                current_data.sort(key=self.yaml_updater.safe_sort_key, reverse=True)
+
+                # Save the updated and sorted data
+                with open("awesome_3dgs_papers.yaml", 'w', encoding='utf-8') as file:
+                    yaml.dump(current_data, file, sort_keys=False, allow_unicode=True)
+
+            # Reload the data
+            self.load_yaml()
+
+            # Find the index of the new entry in the sorted data
+            try:
+                self.current_index = next(i for i, e in enumerate(self.data) if e['id'] == new_entry_id)
+                print(f"Found new entry at index {self.current_index}")
+            except StopIteration:
+                print(f"Warning: Could not find entry with ID {new_entry_id}")
+                self.current_index = 0
+
+            # Show the entry
+            self.show_current_entry()
+            self.clear_search_results()
+            self.entry_counter.setText(f"Entry {self.current_index + 1} of {len(self.data)}")
+            print(f"Now showing entry {self.current_index + 1} of {len(self.data)}")
 
 def main():
     app = QApplication(sys.argv)