add README and dataloader

README.md

@@ -1,3 +1,167 @@
----
-license: apache-2.0
----
+# DeepFurniture Dataset
+
+A large-scale dataset for furniture understanding, featuring **photo-realistic rendered indoor scenes** with **high-quality 3D furniture models**. The dataset contains about 24k indoor images, 170k furniture instances, and 20k unique furniture identities, all rendered by the leading industry-level rendering engines in [Kujiale](https://coohom.com).
+
+## Key Features
+
+- **Photo-Realistic Rendering**: All indoor scenes are rendered using professional rendering engines, providing realistic lighting, shadows, and textures
+- **High-Quality 3D Models**: Each furniture identity is derived from a professional 3D model, ensuring accurate geometry and material representation
+- **Rich Annotations**: Hierarchical annotations at image, instance, and identity levels
+
+
+## Dataset Overview
+
+DeepFurniture provides hierarchical annotations at three levels:
+- **Image Level**: Professional rendered indoor scenes with scene category and depth map
+- **Instance Level**: Bounding boxes and per-pixel masks for furniture instances in scenes
+- **Identity Level**: High-quality rendered previews of 3D furniture models.
+
+### Statistics
+- Total scenes: ~24,000 photo-realistic rendered images
+- Total furniture instances: ~170,000 annotated instances in scenes
+- Unique furniture identities: ~20,000 3D models with preview renderings
+- Categories: 11 furniture types
+- Style tags: 11 different styles
+
+### Categories
+1. Cabinet/Shelf
+2. Table
+3. Chair/Stool
+4. Lamp
+5. Door
+6. Bed
+7. Sofa
+8. Plant
+9. Decoration
+10. Curtain
+11. Home Appliance
+
+### Style Tags
+1. Modern
+2. Country
+3. European/American
+4. Chinese
+5. Japanese
+6. Mediterranean
+7. Southeast-Asian
+8. Nordic
+9. Industrial
+10. Eclectic
+11. Other
+
+## Dataset Structure
+
+The dataset is organized in chunks for efficient distribution:
+
+```
+data/
+├── scenes/           # Photo-realistic rendered indoor scenes
+├── furnitures/       # High-quality 3D model preview renders
+├── queries/          # Query instance images from scenes
+└── metadata/         # Dataset information and indices
+    ├── categories.json       # Furniture category definitions
+    ├── styles.json          # Style tag definitions
+    ├── dataset_info.json    # Dataset statistics and information
+    ├── furnitures.jsonl     # Furniture metadata
+    └── *_index.json        # Chunk index files
+```
+
+## Using the Dataset
+
+### 1. Download and Extraction
+
+```bash
+# Clone the repository
+git lfs install  # Make sure Git LFS is installed
+git clone https://huggingface.co/datasets/byliu/DeepFurniture
+
+# [optional] Extract the dataset (or load the dataset using the compressed files, TBD) 
+./uncompress_dataset.sh -s ./DeepFurniture/data -t ./regular_dataset
+```
+
+### 2. Data Format
+
+#### Scene Data
+- **Image**: RGB images in JPG format
+- **Depth**: Depth maps in PNG format
+- **Annotation**: JSON files containing:
+  ```json
+  {
+    "instances": [
+      {
+        "numberID": 1,
+        "boundingBox": {
+          "xMin": int,
+          "xMax": int,
+          "yMin": int,
+          "yMax": int
+        },
+        "styleIDs": [int],
+        "styleNames": [str],
+        "segmentation": [int], # COCO format RLE encoding
+        "identityID": int,
+        "categoryID": int,
+        "categoryName": str
+      }
+    ]
+  }
+  ```
+
+#### Furniture Data
+- Preview images of 3D models in JPG format
+- Metadata in JSONL format containing category and style information
+
+#### Query Data
+- Cropped furniture instances from scenes
+- Filename format: `[furnitureID]_[instanceIndex]_[sceneID].jpg`
+
+### 3. Loading the Dataset
+
+```python
+from deepfurniture import DeepFurnitureDataset
+
+# Initialize dataset
+dataset = DeepFurnitureDataset("path/to/regular_dataset")
+
+# Access a scene
+scene = dataset[0]
+print(f"Scene ID: {scene['scene_id']}")
+print(f"Number of instances: {len(scene['instances'])}")
+
+# Access furniture instances
+for instance in scene['instances']:
+    print(f"Category: {instance['category_name']}")
+    print(f"Style(s): {instance['style_names']}")
+```
+
+## Benchmarks
+
+This dataset supports three main benchmarks:
+1. Furniture Detection/Segmentation
+2. Furniture Instance Retrieval 
+3. Furniture Retrieval
+
+For benchmark details and baselines, please refer to our paper.
+
+## Paper
+This dataset is introduced in our paper:
+[Furnishing Your Room by What You See: An End-to-End Furniture Set Retrieval Framework with Rich Annotated Benchmark Dataset](https://arxiv.org/abs/1911.09299)
+
+If you use this dataset, please cite:
+```bibtex
+@article{liu2024deepfurniture,
+  title={Furnishing Your Room by What You See: An End-to-End Furniture Set Retrieval Framework with Rich Annotated Benchmark Dataset},
+  author={Liu, Bingyuan and Zhang, Jiantao and Zhang, Xiaoting and Zhang, Wei and Yu, Chuanhui and Zhou, Yuan},
+  journal={arXiv preprint arXiv:1911.09299},
+  year={2020}
+}
+```
+
+## License
+Apache-2.0
+
+## Acknowledgments
+
+- Dataset created by [Kujiale](https://coohom.com)
+- Rendered using the leading interior design platform in [Kujiale](https://coohom.com)
+- Thanks to millions of designers and artists who contributed to the 3D models and designs

deepfurniture.py

@@ -0,0 +1,115 @@
+import json
+from pathlib import Path
+from PIL import Image
+from typing import Dict
+
+
+class DeepFurnitureDataset:
+    """A simple dataset loader for DeepFurniture dataset."""
+    
+    def __init__(self, data_dir: str):
+        """Initialize the dataset loader.
+        
+        Args:
+            data_dir: Path to the dataset directory
+        """
+        self.data_dir = Path(data_dir)
+        
+        # Load metadata
+        with open(self.data_dir / "metadata" / "categories.json") as f:
+            self.categories = json.load(f)
+        with open(self.data_dir / "metadata" / "styles.json") as f:
+            self.styles = json.load(f)
+        
+        # Get scene directories
+        self.scene_dirs = sorted(p for p in (self.data_dir / "scenes").iterdir() if p.is_dir())
+    
+    def __len__(self) -> int:
+        """Get number of scenes in dataset."""
+        return len(self.scene_dirs)
+    
+    def __getitem__(self, idx: int) -> Dict:
+        """Get a single scene with its annotations and related data.
+        
+        Returns:
+            Dict containing:
+            - scene_id (str): Scene identifier
+            - image (PIL.Image): Scene image
+            - depth (PIL.Image or None): Depth map if available
+            - has_depth (bool): Whether depth map is available
+            - instances (List[Dict]): List of furniture instances with:
+                - category_id: Category identifier
+                - category_name: Category name
+                - identity_id: Furniture identity identifier
+                - style_ids: List of style identifiers
+                - style_names: List of style names
+                - bounding_box: Dict with xmin, ymin, xmax, ymax
+                - segmentation: Segmentation mask
+            - furniture_previews (Dict[str, PIL.Image]): Mapping of furniture IDs to preview images
+        """
+        # Get scene directory
+        scene_dir = self.scene_dirs[idx]
+        scene_id = scene_dir.name
+        
+        # Load image
+        image = Image.open(scene_dir / "image.jpg")
+        
+        # Load depth if available
+        depth = None
+        has_depth = False
+        depth_path = scene_dir / "depth.png"
+        if depth_path.exists():
+            try:
+                depth = Image.open(depth_path)
+                has_depth = True
+            except Exception as e:
+                print(f"Warning: Failed to load depth map for scene {scene_id}: {e}")
+        
+        # Load annotation
+        with open(scene_dir / "annotation.json") as f:
+            annotation = json.load(f)
+        
+        # Process instances
+        instances = []
+        furniture_ids = set()
+        for inst in annotation["instances"]:
+            instance_data = {
+                "category_id": inst["categoryID"],
+                "category_name": inst["categoryName"],
+                "identity_id": inst["identityID"],
+                "style_ids": inst["styleIDs"],
+                "style_names": inst["styleNames"],
+                "bounding_box": {
+                    "xmin": inst["boundingBox"]["xMin"],
+                    "ymin": inst["boundingBox"]["yMin"],
+                    "xmax": inst["boundingBox"]["xMax"],
+                    "ymax": inst["boundingBox"]["yMax"],
+                },
+                "segmentation": inst["segmentation"] if "segmentation" in inst else None,
+            }
+            instances.append(instance_data)
+            furniture_ids.add(str(inst["identityID"]))
+        
+        # Load furniture previews
+        furniture_previews = {}
+        for furniture_id in furniture_ids:
+            furniture_path = self.data_dir / "furnitures" / f"{furniture_id}.jpg"
+            if furniture_path.exists():
+                try:
+                    furniture_previews[furniture_id] = Image.open(furniture_path)
+                except Exception as e:
+                    print(f"Warning: Failed to load furniture preview {furniture_id}: {e}")
+        
+        return {
+            "scene_id": scene_id,
+            "image": image,
+            "depth": depth,
+            "has_depth": has_depth,
+            "instances": instances,
+            "furniture_previews": furniture_previews
+        }
+    
+    def __iter__(self):
+        """Iterate through all scenes."""
+        for i in range(len(self)):
+            yield self[i]

uncompress_dataset.sh

@@ -0,0 +1,129 @@
+#!/bin/bash
+
+# Usage function
+usage() {
+    echo "Usage: $0 -s SOURCE_DIR -t TARGET_DIR [-c CHUNK_TYPE] [-h]"
+    echo "Uncompress chunked DeepFurniture dataset"
+    echo ""
+    echo "Required arguments:"
+    echo "  -s SOURCE_DIR   Source directory containing the chunked dataset"
+    echo "  -t TARGET_DIR   Target directory for the uncompressed dataset"
+    echo ""
+    echo "Optional arguments:"
+    echo "  -c CHUNK_TYPE   Specific chunk type to process (scenes, furnitures, queries)"
+    echo "                  If not specified, all chunk types will be processed"
+    echo "  -h             Show this help message"
+    exit 1
+}
+
+# Process command line arguments
+while getopts "s:t:c:h" opt; do
+    case $opt in
+        s) SOURCE_DIR="$OPTARG";;
+        t) TARGET_DIR="$OPTARG";;
+        c) CHUNK_TYPE="$OPTARG";;
+        h) usage;;
+        ?) usage;;
+    esac
+done
+
+# Check required arguments
+if [ -z "$SOURCE_DIR" ] || [ -z "$TARGET_DIR" ]; then
+    echo "Error: Source and target directories are required"
+    usage
+fi
+
+# Validate source directory
+if [ ! -d "$SOURCE_DIR" ]; then
+    echo "Error: Source directory does not exist: $SOURCE_DIR"
+    exit 1
+fi
+
+# Create target directory structure
+mkdir -p "$TARGET_DIR"/{metadata,scenes,furnitures,queries}
+
+# Copy metadata files (excluding index files)
+echo "Copying metadata files..."
+for file in "$SOURCE_DIR"/metadata/*.json*; do
+    if [[ ! $file =~ _index.json$ ]]; then
+        cp "$file" "$TARGET_DIR/metadata/"
+    fi
+done
+
+# Function to process chunks of a specific type
+process_chunks() {
+    local type=$1
+    local src_dir="$SOURCE_DIR/$type"
+    local target_dir="$TARGET_DIR/$type"
+    
+    echo "Processing $type chunks..."
+    
+    # Check if source directory exists
+    if [ ! -d "$src_dir" ]; then
+        echo "Warning: Directory not found: $src_dir"
+        return
+    }
+    
+    # Count total chunks for progress
+    total_chunks=$(ls "$src_dir"/*.tar.gz 2>/dev/null | wc -l)
+    if [ "$total_chunks" -eq 0 ]; then
+        echo "No chunks found in $src_dir"
+        return
+    }
+    
+    # Process each chunk
+    current=0
+    for chunk in "$src_dir"/*.tar.gz; do
+        current=$((current + 1))
+        chunk_name=$(basename "$chunk")
+        printf "Extracting %s (%d/%d)..." "$chunk_name" "$current" "$total_chunks"
+        
+        if tar -xzf "$chunk" -C "$target_dir" 2>/dev/null; then
+            echo " done"
+        else
+            echo " failed"
+            echo "Warning: Failed to extract $chunk_name"
+        fi
+    done
+}
+
+# Process chunks based on input
+if [ -n "$CHUNK_TYPE" ]; then
+    case "$CHUNK_TYPE" in
+        scenes|furnitures|queries)
+            process_chunks "$CHUNK_TYPE"
+            ;;
+        *)
+            echo "Error: Invalid chunk type: $CHUNK_TYPE"
+            echo "Valid types are: scenes, furnitures, queries"
+            exit 1
+            ;;
+    esac
+else
+    # Process all chunk types
+    for type in scenes furnitures queries; do
+        process_chunks "$type"
+    done
+fi
+
+# Basic validation
+echo -e "\nValidating extracted files..."
+
+# Check scenes
+if [ -z "$CHUNK_TYPE" ] || [ "$CHUNK_TYPE" = "scenes" ]; then
+    missing_files=0
+    for scene_dir in "$TARGET_DIR"/scenes/*; do
+        if [ -d "$scene_dir" ]; then
+            for required in "image.jpg" "annotation.json"; do
+                if [ ! -f "$scene_dir/$required" ]; then
+                    echo "Warning: Missing $required in $(basename "$scene_dir")"
+                    missing_files=$((missing_files + 1))
+                fi
+            done
+        fi
+    done
+    echo "Scene validation complete. Missing files: $missing_files"
+fi
+
+echo "Dataset uncompression completed!"
+echo "Output directory: $TARGET_DIR"