i have folder has classes.txt images.jpg images.tx...

The script below converts each YOLO segmentation polygon:

text
class_id x1 y1 x2 y2 x3 y3 ...

into a YOLO detection bounding box:

text
class_id x_center y_center width height

Coordinates remain normalized, so image dimensions are not required.

python
from pathlib import Path
import shutil


# ============================================================
# HARDCODED PATHS
# ============================================================
INPUT_FOLDER = Path(r"C:\datasets\segmentation_dataset")
OUTPUT_FOLDER = Path(r"C:\datasets\detection_dataset")

# Copy image files into the output folder.
COPY_IMAGES = True

IMAGE_EXTENSIONS = {
    ".jpg",
    ".jpeg",
    ".png",
    ".bmp",
    ".tif",
    ".tiff",
    ".webp",
}


def segmentation_line_to_detection(line: str) -> str | None:
    """
    Convert one YOLO segmentation annotation line into
    one YOLO detection annotation line.

    Input:
        class_id x1 y1 x2 y2 x3 y3 ...

    Output:
        class_id x_center y_center width height
    """
    parts = line.strip().split()

    if not parts:
        return None

    class_id = parts[0]
    coordinate_values = parts[1:]

    # A polygon must contain at least 3 points: 6 coordinate values.
    if len(coordinate_values) < 6:
        raise ValueError("Polygon contains fewer than 3 points.")

    if len(coordinate_values) % 2 != 0:
        raise ValueError("Polygon has an odd number of coordinate values.")

    try:
        coordinates = [float(value) for value in coordinate_values]
    except ValueError as error:
        raise ValueError("Polygon contains a non-numeric coordinate.") from error

    x_values = coordinates[0::2]
    y_values = coordinates[1::2]

    x_min = min(x_values)
    x_max = max(x_values)
    y_min = min(y_values)
    y_max = max(y_values)

    # Keep the resulting box within YOLO's normalized range.
    x_min = max(0.0, min(1.0, x_min))
    x_max = max(0.0, min(1.0, x_max))
    y_min = max(0.0, min(1.0, y_min))
    y_max = max(0.0, min(1.0, y_max))

    width = x_max - x_min
    height = y_max - y_min

    if width <= 0 or height <= 0:
        raise ValueError("Polygon produces a zero-size bounding box.")

    x_center = (x_min + x_max) / 2.0
    y_center = (y_min + y_max) / 2.0

    return (
        f"{class_id} "
        f"{x_center:.6f} "
        f"{y_center:.6f} "
        f"{width:.6f} "
        f"{height:.6f}"
    )


def convert_label_file(input_file: Path, output_file: Path) -> tuple[int, int]:
    """Convert every valid segmentation annotation in one label file."""
    converted_lines = []
    converted_count = 0
    skipped_count = 0

    with input_file.open("r", encoding="utf-8") as file:
        for line_number, line in enumerate(file, start=1):
            if not line.strip():
                continue

            try:
                converted_line = segmentation_line_to_detection(line)

                if converted_line is not None:
                    converted_lines.append(converted_line)
                    converted_count += 1

            except ValueError as error:
                skipped_count += 1
                print(
                    f"Warning: skipped {input_file}, line {line_number}: "
                    f"{error}"
                )

    output_file.parent.mkdir(parents=True, exist_ok=True)

    with output_file.open("w", encoding="utf-8") as file:
        if converted_lines:
            file.write("\n".join(converted_lines) + "\n")

    return converted_count, skipped_count


def main() -> None:
    if not INPUT_FOLDER.exists():
        raise FileNotFoundError(
            f"Input folder does not exist: {INPUT_FOLDER}"
        )

    if INPUT_FOLDER.resolve() == OUTPUT_FOLDER.resolve():
        raise ValueError("Input and output folders must be different.")

    OUTPUT_FOLDER.mkdir(parents=True, exist_ok=True)

    converted_files = 0
    converted_objects = 0
    skipped_objects = 0
    copied_images = 0

    for input_file in INPUT_FOLDER.rglob("*"):
        if not input_file.is_file():
            continue

        relative_path = input_file.relative_to(INPUT_FOLDER)
        output_file = OUTPUT_FOLDER / relative_path

        # Copy classes.txt without modifying it.
        if input_file.name.lower() == "classes.txt":
            output_file.parent.mkdir(parents=True, exist_ok=True)
            shutil.copy2(input_file, output_file)
            print(f"Copied classes: {relative_path}")
            continue

        # Convert all other .txt files as YOLO label files.
        if input_file.suffix.lower() == ".txt":
            converted, skipped = convert_label_file(
                input_file,
                output_file,
            )

            converted_files += 1
            converted_objects += converted
            skipped_objects += skipped

            print(
                f"Converted: {relative_path} "
                f"({converted} objects, {skipped} skipped)"
            )
            continue

        # Copy corresponding images while preserving subfolders.
        if COPY_IMAGES and input_file.suffix.lower() in IMAGE_EXTENSIONS:
            output_file.parent.mkdir(parents=True, exist_ok=True)
            shutil.copy2(input_file, output_file)
            copied_images += 1
            print(f"Copied image: {relative_path}")

    print("\nConversion complete.")
    print(f"Label files converted: {converted_files}")
    print(f"Objects converted:     {converted_objects}")
    print(f"Objects skipped:       {skipped_objects}")
    print(f"Images copied:         {copied_images}")
    print(f"Output folder:         {OUTPUT_FOLDER}")


if __name__ == "__main__":
    main()

For the polygon in your example, the converted detection annotation is approximately:

text
3 0.715235 0.868750 0.017969 0.029166

Change only INPUT_FOLDER and OUTPUT_FOLDER at the top, then run:

bash
python convert_segmentation_to_detection.py