dataset-toolkit 0.1.0__py3-none-any.whl

dataset_toolkit/__init__.py

@@ -0,0 +1,79 @@
+"""
+Dataset Toolkit - 计算机视觉数据集处理工具包
+
+这个工具包提供了一套完整的解决方案，用于加载、处理和导出计算机视觉数据集。
+
+主要功能：
+- 加载多种格式的数据集（YOLO、COCO等）
+- 合并和转换数据集
+- 导出为标准格式
+- 坐标转换等工具函数
+
+基本用法：
+    >>> from dataset_toolkit import load_yolo_from_local, export_to_coco
+    >>> dataset = load_yolo_from_local("/path/to/dataset", {0: 'cat'})
+    >>> export_to_coco(dataset, "output.json")
+"""
+
+__version__ = "0.1.0"
+__author__ = "Your Name"
+__email__ = "your.email@example.com"
+
+# 导入核心类和函数，提供简洁的顶层API
+from dataset_toolkit.models import (
+    Dataset,
+    ImageAnnotation,
+    Annotation
+)
+
+from dataset_toolkit.loaders.local_loader import (
+    load_yolo_from_local
+)
+
+from dataset_toolkit.processors.merger import (
+    merge_datasets
+)
+
+from dataset_toolkit.exporters.coco_exporter import (
+    export_to_coco
+)
+
+from dataset_toolkit.exporters.txt_exporter import (
+    export_to_txt
+)
+
+from dataset_toolkit.utils.coords import (
+    yolo_to_absolute_bbox
+)
+
+from dataset_toolkit.pipeline import (
+    DatasetPipeline
+)
+
+# 定义公共API
+__all__ = [
+    # 版本信息
+    "__version__",
+    
+    # 数据模型
+    "Dataset",
+    "ImageAnnotation",
+    "Annotation",
+    
+    # 加载器
+    "load_yolo_from_local",
+    
+    # 处理器
+    "merge_datasets",
+    
+    # 导出器
+    "export_to_coco",
+    "export_to_txt",
+    
+    # 工具函数
+    "yolo_to_absolute_bbox",
+    
+    # 管道API
+    "DatasetPipeline",
+]
+

dataset_toolkit/exporters/coco_exporter.py

@@ -0,0 +1,64 @@
+# dataset_toolkit/exporters/coco_exporter.py
+import json
+import datetime
+from dataset_toolkit.models import Dataset
+
+def export_to_coco(dataset: Dataset, output_path: str):
+    """
+    将数据集对象导出为COCO JSON格式。
+
+    Args:
+        dataset (Dataset): 内部标准数据集对象。
+        output_path (str): .json文件的输出路径。
+    """
+    coco_format = {
+        "info": {
+            "description": f"Exported from dataset_toolkit: {dataset.name}",
+            "date_created": datetime.datetime.utcnow().isoformat()
+        },
+        "licenses": [],
+        "images": [],
+        "annotations": [],
+        "categories": []
+    }
+
+    # 1. 填充 categories
+    for cat_id, cat_name in dataset.categories.items():
+        coco_format["categories"].append({
+            "id": cat_id,
+            "name": cat_name,
+            "supercategory": "none"
+        })
+
+    # 2. 遍历图片和标注，填充 images 和 annotations
+    annotation_id_counter = 1
+    for image_id_counter, image_ann in enumerate(dataset.images, 1):
+        # 添加 image 条目
+        coco_format["images"].append({
+            "id": image_id_counter,
+            "file_name": image_ann.image_id, # 使用原始文件名
+            "width": image_ann.width,
+            "height": image_ann.height
+        })
+
+        # 添加 annotation 条目
+        for ann in image_ann.annotations:
+            x_min, y_min, width, height = ann.bbox
+            area = width * height
+            
+            coco_format["annotations"].append({
+                "id": annotation_id_counter,
+                "image_id": image_id_counter,
+                "category_id": ann.category_id,
+                "bbox": [round(c, 2) for c in ann.bbox],
+                "area": round(area, 2),
+                "iscrowd": 0,
+                "segmentation": [] # 对于bbox，segmentation通常为空
+            })
+            annotation_id_counter += 1
+    
+    # 3. 写入JSON文件
+    with open(output_path, 'w') as f:
+        json.dump(coco_format, f, indent=4)
+    
+    print(f"成功将数据集导出为COCO格式: {output_path}")

dataset_toolkit/exporters/txt_exporter.py

@@ -0,0 +1,32 @@
+# dataset_toolkit/exporters/txt_exporter.py
+import os
+from dataset_toolkit.models import Dataset
+
+def export_to_txt(dataset: Dataset, output_path: str, use_relative_paths: bool = False, base_path: str = None):
+    """
+    将数据集导出为每行一条记录的TXT文件。
+    格式: image_path class_id,x_min,y_min,x_max,y_max class_id,x_min,y_min,x_max,y_max ...
+
+    Args:
+        dataset (Dataset): 内部标准数据集对象。
+        output_path (str): .txt文件的输出路径。
+        use_relative_paths (bool): 是否使用相对路径。
+        base_path (str): 计算相对路径时的基准目录。如果为None，则使用当前工作目录。
+    """
+    lines = []
+    for image_ann in dataset.images:
+        path = image_ann.path
+        if use_relative_paths:
+            try:
+                path = os.path.relpath(path, start=base_path)
+            except ValueError:
+                # 在Windows上，如果路径在不同磁盘驱动器上，会引发ValueError
+                pass # 保持绝对路径
+        
+        line = f"{path}"
+        lines.append(line)
+
+    with open(output_path, 'w') as f:
+        f.write('\n'.join(lines))
+        
+    print(f"成功将数据集导出为TXT格式: {output_path}")

dataset_toolkit/loaders/local_loader.py

@@ -0,0 +1,64 @@
+# dataset_toolkit/loaders/local_loader.py
+from pathlib import Path
+from typing import Dict
+from PIL import Image
+
+# 从我们自己的包中导入模块
+from dataset_toolkit.models import Dataset, ImageAnnotation, Annotation
+from dataset_toolkit.utils.coords import yolo_to_absolute_bbox
+
+def load_yolo_from_local(dataset_path: str, categories: Dict[int, str]) -> Dataset:
+    """
+    从本地文件系统加载YOLO格式的数据集。
+    """
+    root_path = Path(dataset_path)
+    image_dir = root_path / 'images'
+    label_dir = root_path / 'labels'
+    
+    if not image_dir.is_dir():
+        raise FileNotFoundError(f"图片目录不存在: {image_dir}")
+    if not label_dir.is_dir():
+        raise FileNotFoundError(f"标注目录不存在: {label_dir}")
+
+    dataset = Dataset(name=root_path.name, categories=categories)
+    supported_extensions = ['.jpg', '.jpeg', '.png']
+    
+    print(f"开始加载数据集: {root_path.name}...")
+    
+    for image_path in image_dir.iterdir():
+        if image_path.suffix.lower() not in supported_extensions:
+            continue
+
+        try:
+            with Image.open(image_path) as img:
+                img_width, img_height = img.size
+        except IOError:
+            print(f"警告: 无法打开图片，已跳过: {image_path}")
+            continue
+        image_annotation = ImageAnnotation(
+            image_id=image_path.name,
+            path=str(image_path.resolve()),
+            width=img_width,
+            height=img_height
+        )
+        
+        label_path = label_dir / (image_path.stem + '.txt')
+        if label_path.exists():
+            with open(label_path, 'r') as f:
+                for line in f:
+                    try:
+                        parts = [float(p) for p in line.strip().split()]
+                        if len(parts) != 5: continue
+                        
+                        cls_id, yolo_box = int(parts[0]), parts[1:]
+                        abs_bbox = yolo_to_absolute_bbox(tuple(yolo_box), img_width, img_height)
+                        
+                        annotation = Annotation(category_id=cls_id, bbox=abs_bbox)
+                        image_annotation.annotations.append(annotation)
+                    except (ValueError, IndexError):
+                        print(f"警告: 无法解析行，已跳过: {label_path} -> '{line.strip()}'")
+
+        dataset.images.append(image_annotation)
+
+    print(f"加载完成. 共找到 {len(dataset.images)} 张图片.")
+    return dataset

dataset_toolkit/models.py

@@ -0,0 +1,26 @@
+# dataset_toolkit/models.py
+from dataclasses import dataclass, field
+from typing import List, Dict
+
+@dataclass
+class Annotation:
+    """代表一个边界框标注."""
+    category_id: int
+    # 存储格式为 [x_min, y_min, width, height]，单位是绝对像素值
+    bbox: List[float]
+
+@dataclass
+class ImageAnnotation:
+    """代表一张图片及其所有相关的标注信息."""
+    image_id: str
+    path: str
+    width: int
+    height: int
+    annotations: List[Annotation] = field(default_factory=list)
+
+@dataclass
+class Dataset:
+    """代表一个完整的数据集对象，作为系统内部的标准化表示."""
+    name: str
+    images: List[ImageAnnotation] = field(default_factory=list)
+    categories: Dict[int, str] = field(default_factory=dict)

dataset_toolkit/pipeline.py

@@ -0,0 +1,176 @@
+# dataset_toolkit/pipeline.py
+"""
+提供链式API，让数据集处理更加流畅和优雅
+"""
+from typing import Dict, List, Optional
+from pathlib import Path
+from dataset_toolkit.models import Dataset
+from dataset_toolkit.loaders.local_loader import load_yolo_from_local
+from dataset_toolkit.processors.merger import merge_datasets
+from dataset_toolkit.exporters.coco_exporter import export_to_coco
+from dataset_toolkit.exporters.txt_exporter import export_to_txt
+
+
+class DatasetPipeline:
+    """
+    数据集处理管道，支持链式调用
+    
+    示例:
+        >>> pipeline = DatasetPipeline()
+        >>> result = (pipeline
+        ...     .load_yolo("/path/to/dataset1", {0: 'cat'})
+        ...     .load_yolo("/path/to/dataset2", {0: 'dog'})
+        ...     .merge(
+        ...         category_mapping={'cat': 'animal', 'dog': 'animal'},
+        ...         final_categories={0: 'animal'}
+        ...     )
+        ...     .export_coco("output.json")
+        ...     .get_result())
+    """
+    
+    def __init__(self):
+        self._datasets: List[Dataset] = []
+        self._current_dataset: Optional[Dataset] = None
+        self._operations = []
+    
+    def load_yolo(self, dataset_path: str, categories: Dict[int, str]) -> 'DatasetPipeline':
+        """
+        加载YOLO格式数据集
+        
+        Args:
+            dataset_path: 数据集路径
+            categories: 类别映射
+            
+        Returns:
+            self: 返回自身以支持链式调用
+        """
+        dataset = load_yolo_from_local(dataset_path, categories)
+        self._datasets.append(dataset)
+        self._current_dataset = dataset
+        self._operations.append(f"加载数据集: {dataset_path}")
+        return self
+    
+    def merge(
+        self,
+        category_mapping: Dict[str, str],
+        final_categories: Dict[int, str],
+        new_dataset_name: str = "merged_dataset"
+    ) -> 'DatasetPipeline':
+        """
+        合并已加载的所有数据集
+        
+        Args:
+            category_mapping: 类别映射规则
+            final_categories: 最终类别体系
+            new_dataset_name: 合并后的数据集名称
+            
+        Returns:
+            self: 返回自身以支持链式调用
+        """
+        if len(self._datasets) < 1:
+            raise ValueError("至少需要一个数据集才能执行合并操作")
+        
+        self._current_dataset = merge_datasets(
+            datasets=self._datasets,
+            category_mapping=category_mapping,
+            final_categories=final_categories,
+            new_dataset_name=new_dataset_name
+        )
+        self._operations.append(f"合并 {len(self._datasets)} 个数据集")
+        return self
+    
+    def export_coco(self, output_path: str) -> 'DatasetPipeline':
+        """
+        导出为COCO格式
+        
+        Args:
+            output_path: 输出文件路径
+            
+        Returns:
+            self: 返回自身以支持链式调用
+        """
+        if self._current_dataset is None:
+            raise ValueError("没有可导出的数据集")
+        
+        export_to_coco(self._current_dataset, output_path)
+        self._operations.append(f"导出COCO格式: {output_path}")
+        return self
+    
+    def export_txt(
+        self,
+        output_path: str,
+        use_relative_paths: bool = False,
+        base_path: Optional[str] = None
+    ) -> 'DatasetPipeline':
+        """
+        导出为TXT格式
+        
+        Args:
+            output_path: 输出文件路径
+            use_relative_paths: 是否使用相对路径
+            base_path: 相对路径的基准目录
+            
+        Returns:
+            self: 返回自身以支持链式调用
+        """
+        if self._current_dataset is None:
+            raise ValueError("没有可导出的数据集")
+        
+        export_to_txt(self._current_dataset, output_path, use_relative_paths, base_path)
+        self._operations.append(f"导出TXT格式: {output_path}")
+        return self
+    
+    def filter_by_category(self, category_ids: List[int]) -> 'DatasetPipeline':
+        """
+        按类别过滤数据集（未来功能）
+        
+        Args:
+            category_ids: 要保留的类别ID列表
+            
+        Returns:
+            self: 返回自身以支持链式调用
+        """
+        # TODO: 实现类别过滤功能
+        raise NotImplementedError("此功能尚未实现")
+    
+    def get_result(self) -> Dataset:
+        """
+        获取当前处理结果
+        
+        Returns:
+            Dataset: 当前的数据集对象
+        """
+        if self._current_dataset is None:
+            raise ValueError("管道中没有任何数据集")
+        return self._current_dataset
+    
+    def get_summary(self) -> str:
+        """
+        获取管道操作摘要
+        
+        Returns:
+            str: 操作摘要信息
+        """
+        summary = "数据集处理管道操作摘要:\n"
+        summary += "\n".join(f"{i+1}. {op}" for i, op in enumerate(self._operations))
+        
+        if self._current_dataset:
+            summary += f"\n\n最终结果:"
+            summary += f"\n  - 数据集名称: {self._current_dataset.name}"
+            summary += f"\n  - 图片数量: {len(self._current_dataset.images)}"
+            summary += f"\n  - 类别: {self._current_dataset.categories}"
+        
+        return summary
+    
+    def reset(self) -> 'DatasetPipeline':
+        """
+        重置管道状态
+        
+        Returns:
+            self: 返回自身以支持链式调用
+        """
+        self._datasets = []
+        self._current_dataset = None
+        self._operations = []
+        return self
+

dataset_toolkit/processors/merger.py

@@ -0,0 +1,62 @@
+# dataset_toolkit/processors/merger.py
+import copy
+from typing import List, Dict
+from dataset_toolkit.models import Dataset
+
+def merge_datasets(
+    datasets: List[Dataset],
+    category_mapping: Dict[str, str],
+    final_categories: Dict[int, str],
+    new_dataset_name: str = "merged_dataset"
+) -> Dataset:
+    """
+    基于一个确定的最终类别体系，合并多个数据集。
+
+    Args:
+        datasets (List[Dataset]): 需要合并的数据集对象列表。
+        category_mapping (Dict[str, str]): 从旧类别名到新类别名的映射规则。
+            例如: {'cat': 'animal', 'dog': 'animal', 'car': 'vehicle'}
+        final_categories (Dict[int, str]): 最终的、目标类别体系。
+            例如: {0: 'animal', 1: 'vehicle', 2: 'bicycle'}
+        new_dataset_name (str): 新合并数据集的名称。
+
+    Returns:
+        Dataset: 一个全新的、合并后的数据集对象。
+    """
+    if not datasets:
+        return Dataset(name=new_dataset_name)
+
+    # 1. 创建新数据集的框架，并为最终类别创建名称->ID的反向映射以便快速查找
+    merged_dataset = Dataset(name=new_dataset_name, categories=final_categories)
+    final_name_to_id = {name: id for id, name in final_categories.items()}
+
+    # 2. 遍历每个待合并的数据集
+    for ds in datasets:
+        # 为当前数据集构建一个从 旧ID -> 最终ID 的映射表
+        id_remap_table = {}
+        for old_id, old_name in ds.categories.items():
+            # 查找旧类别名对应的新类别名
+            final_name = category_mapping.get(old_name, old_name)
+            # 如果这个新类别名存在于我们最终的类别体系中，则记录ID映射关系
+            if final_name in final_name_to_id:
+                id_remap_table[old_id] = final_name_to_id[final_name]
+        
+        # 3. 遍历并处理图片和标注
+        for image_ann in ds.images:
+            # 深拷贝以避免修改原始数据，确保函数无副作用
+            new_image_ann = copy.deepcopy(image_ann)
+            
+            # 基于上面生成的id_remap_table，更新标注的category_id
+            updated_annotations = []
+            for ann in new_image_ann.annotations:
+                # 只有当一个标注的旧ID可以在重映射表中找到时，它才会被保留
+                if ann.category_id in id_remap_table:
+                    ann.category_id = id_remap_table[ann.category_id]
+                    updated_annotations.append(ann)
+            
+            new_image_ann.annotations = updated_annotations
+            merged_dataset.images.append(new_image_ann)
+
+    print(f"合并完成. 新数据集 '{merged_dataset.name}' 包含 {len(merged_dataset.images)} 张图片。")
+    print(f"最终类别体系: {merged_dataset.categories}")
+    return merged_dataset

dataset_toolkit/utils/coords.py

@@ -0,0 +1,15 @@
+# dataset_toolkit/utils/coords.py
+from typing import Tuple, List
+
+def yolo_to_absolute_bbox(yolo_bbox: Tuple[float, ...], img_width: int, img_height: int) -> List[float]:
+    """
+    将YOLO的相对坐标 (x_center, y_center, width, height) 转换为绝对像素坐标 (x_min, y_min, width, height)。
+    """
+    x_center, y_center, rel_width, rel_height = yolo_bbox
+    
+    abs_width = rel_width * img_width
+    abs_height = rel_height * img_height
+    x_min = (x_center * img_width) - (abs_width / 2)
+    y_min = (y_center * img_height) - (abs_height / 2)
+    
+    return [x_min, y_min, abs_width, abs_height]

dataset_toolkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,273 @@
+Metadata-Version: 2.4
+Name: dataset-toolkit
+Version: 0.1.0
+Summary: 一个用于加载、处理和导出计算机视觉数据集的工具包
+Home-page: https://github.com/yourusername/dataset-toolkit
+Author: Your Name
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/dataset-toolkit
+Project-URL: Documentation, https://dataset-toolkit.readthedocs.io
+Project-URL: Repository, https://github.com/yourusername/dataset-toolkit
+Project-URL: Bug Tracker, https://github.com/yourusername/dataset-toolkit/issues
+Keywords: computer vision,dataset,yolo,coco,machine learning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=8.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.0; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: flake8>=3.9; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Dataset Toolkit
+
+一个功能强大、易于使用的 Python 工具包，用于处理计算机视觉数据集。支持多种数据格式的加载、合并、转换和导出。
+
+## ✨ 特性
+
+- 🔄 **多格式支持**：支持 YOLO、COCO 等常见格式
+- 🔗 **数据集合并**：轻松合并多个数据集，支持类别重映射
+- 📤 **灵活导出**：导出为 COCO JSON、TXT 等多种格式
+- 🛠️ **工具函数**：提供坐标转换等实用工具
+- 📦 **标准化数据模型**：统一的内部数据表示，方便扩展
+
+## 📦 安装
+
+### 从 PyPI 安装（推荐）
+
+```bash
+pip install dataset-toolkit
+```
+
+### 从源码安装
+
+```bash
+git clone https://github.com/yourusername/dataset-toolkit.git
+cd dataset-toolkit
+pip install -e .
+```
+
+### 开发模式安装
+
+```bash
+pip install -e ".[dev]"
+```
+
+## 🚀 快速开始
+
+### 基本用法
+
+```python
+from dataset_toolkit import load_yolo_from_local, merge_datasets, export_to_coco
+
+# 1. 加载 YOLO 格式数据集
+dataset1 = load_yolo_from_local(
+    "/path/to/dataset1",
+    categories={0: 'cat', 1: 'dog'}
+)
+
+dataset2 = load_yolo_from_local(
+    "/path/to/dataset2",
+    categories={0: 'car', 1: 'bicycle'}
+)
+
+# 2. 合并数据集（带类别重映射）
+final_categories = {0: 'animal', 1: 'vehicle'}
+category_mapping = {
+    'cat': 'animal',
+    'dog': 'animal',
+    'car': 'vehicle',
+    'bicycle': 'vehicle'
+}
+
+merged = merge_datasets(
+    datasets=[dataset1, dataset2],
+    category_mapping=category_mapping,
+    final_categories=final_categories,
+    new_dataset_name="merged_dataset"
+)
+
+# 3. 导出为 COCO 格式
+export_to_coco(merged, "output/merged.json")
+```
+
+### 链式 API 用法
+
+```python
+from dataset_toolkit import DatasetPipeline
+
+# 使用管道模式处理数据集
+pipeline = DatasetPipeline()
+result = (pipeline
+    .load_yolo("/path/to/dataset1", {0: 'cat', 1: 'dog'})
+    .load_yolo("/path/to/dataset2", {0: 'car'})
+    .merge(
+        category_mapping={'cat': 'animal', 'dog': 'animal', 'car': 'vehicle'},
+        final_categories={0: 'animal', 1: 'vehicle'}
+    )
+    .export_coco("output/merged.json")
+    .execute())
+```
+
+## 📚 API 文档
+
+### 数据加载器
+
+#### `load_yolo_from_local(dataset_path, categories)`
+
+从本地文件系统加载 YOLO 格式的数据集。
+
+**参数：**
+- `dataset_path` (str): 数据集根目录路径，应包含 `images/` 和 `labels/` 子目录
+- `categories` (Dict[int, str]): 类别ID到类别名的映射
+
+**返回：**
+- `Dataset`: 标准化的数据集对象
+
+**示例：**
+```python
+dataset = load_yolo_from_local(
+    "/data/my_dataset",
+    categories={0: 'person', 1: 'car'}
+)
+```
+
+### 数据处理器
+
+#### `merge_datasets(datasets, category_mapping, final_categories, new_dataset_name)`
+
+合并多个数据集，支持类别重映射。
+
+**参数：**
+- `datasets` (List[Dataset]): 要合并的数据集列表
+- `category_mapping` (Dict[str, str]): 旧类别名到新类别名的映射
+- `final_categories` (Dict[int, str]): 最终的类别体系
+- `new_dataset_name` (str, optional): 合并后数据集的名称
+
+**返回：**
+- `Dataset`: 合并后的数据集对象
+
+### 数据导出器
+
+#### `export_to_coco(dataset, output_path)`
+
+导出为 COCO JSON 格式。
+
+**参数：**
+- `dataset` (Dataset): 要导出的数据集
+- `output_path` (str): 输出文件路径
+
+#### `export_to_txt(dataset, output_path, use_relative_paths, base_path)`
+
+导出为 TXT 格式。
+
+**参数：**
+- `dataset` (Dataset): 要导出的数据集
+- `output_path` (str): 输出文件路径
+- `use_relative_paths` (bool, optional): 是否使用相对路径
+- `base_path` (str, optional): 相对路径的基准目录
+
+## 🏗️ 架构设计
+
+```
+dataset_toolkit/
+├── models.py              # 数据模型定义
+├── loaders/              # 数据加载器
+│   ├── local_loader.py   # 本地文件系统加载器
+│   └── remote_loader.py  # 远程数据源加载器（待开发）
+├── processors/           # 数据处理器
+│   ├── merger.py         # 数据集合并
+│   └── filter.py         # 数据过滤（待开发）
+├── exporters/            # 数据导出器
+│   ├── coco_exporter.py  # COCO格式导出
+│   └── txt_exporter.py   # TXT格式导出
+└── utils/                # 工具函数
+    └── coords.py         # 坐标转换
+```
+
+## 🔧 高级用法
+
+### 自定义数据加载器
+
+```python
+from dataset_toolkit.models import Dataset, ImageAnnotation
+from dataset_toolkit.loaders import BaseLoader
+
+class CustomLoader(BaseLoader):
+    def load(self, path, **kwargs):
+        # 实现你的自定义加载逻辑
+        dataset = Dataset(name="custom")
+        # ... 加载数据 ...
+        return dataset
+```
+
+### 批量处理
+
+```python
+from pathlib import Path
+from dataset_toolkit import load_yolo_from_local, export_to_coco
+
+# 批量处理多个数据集
+dataset_dirs = [
+    "/data/dataset1",
+    "/data/dataset2",
+    "/data/dataset3"
+]
+
+categories = {0: 'object'}
+
+for dataset_dir in dataset_dirs:
+    ds = load_yolo_from_local(dataset_dir, categories)
+    output_name = Path(dataset_dir).name + ".json"
+    export_to_coco(ds, f"output/{output_name}")
+```
+
+## 🧪 测试
+
+运行测试：
+
+```bash
+pytest
+```
+
+生成测试覆盖率报告：
+
+```bash
+pytest --cov=dataset_toolkit --cov-report=html
+```
+
+## 📝 开发计划
+
+- [ ] 支持更多数据格式（Pascal VOC、YOLO v8等）
+- [ ] 添加数据增强功能
+- [ ] 支持远程数据源（S3、HTTP等）
+- [ ] 添加数据统计和可视化功能
+- [ ] 提供命令行工具
+- [ ] 支持视频数据集
+
+## 🤝 贡献
+
+欢迎提交 Issue 和 Pull Request！
+
+## 📄 许可证
+
+MIT License
+
+## 📧 联系方式
+
+如有问题，请通过以下方式联系：
+- Email: your.email@example.com
+- GitHub Issues: https://github.com/yourusername/dataset-toolkit/issues
+

dataset_toolkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+dataset_toolkit/__init__.py,sha256=yMm1ajpItXWlKdiqEmY3kRXDI9F0Voreg4hEH0xxM1s,1604
+dataset_toolkit/models.py,sha256=uVtTbVYdHMECPL_waDhEebLvL_VwqSEm9XFC5QYIB10,767
+dataset_toolkit/pipeline.py,sha256=iBJD7SemEVFTwzHxRQrjpUIQQcVdPSZnD4sB_y56Md0,5697
+dataset_toolkit/exporters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataset_toolkit/exporters/coco_exporter.py,sha256=l5sfj7rOcvcMC0-4LNOEJ4PeklGQORDflU_um5GGnxA,2120
+dataset_toolkit/exporters/txt_exporter.py,sha256=9nTWs6M89MdKJhlODtmfzeZqWkliXac9NMWPgVUrE7c,1246
+dataset_toolkit/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataset_toolkit/loaders/local_loader.py,sha256=Wy_hXY2B-SDxAmJGBYQpqBUe3cjz-k_McYhYf7cLgCk,2501
+dataset_toolkit/processors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataset_toolkit/processors/merger.py,sha256=h8qQNgSmkPrhoQ3QiWEyIl11CmmjT5K1-8TzNb7_jbk,2834
+dataset_toolkit/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataset_toolkit/utils/coords.py,sha256=GtTQz2gFyFQfXhKfecI8tzqWFjraJY6Xo85-kRXYAYc,614
+dataset_toolkit-0.1.0.dist-info/licenses/LICENSE,sha256=8_up1FX6vk2DRcusQEZ4pWJGkgkjvEkD14xB1hdLe3c,1067
+dataset_toolkit-0.1.0.dist-info/METADATA,sha256=yjqPr_Wjioiw5v7AOkqduI5B_Y6oyBbKrTpJGIKVIWw,7225
+dataset_toolkit-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dataset_toolkit-0.1.0.dist-info/top_level.txt,sha256=B4D5vMLjUNJBZDdL7Utc0FYIfYoWbzyIGBMVYaeMd3U,16
+dataset_toolkit-0.1.0.dist-info/RECORD,,

dataset_toolkit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dataset_toolkit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

dataset_toolkit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dataset_toolkit