README.md

---
license: apache-2.0
title: Towards Unified Solution for Floatings in Document Layout Analysis
subtitle: >-
  A Definition for Floating Object Localization (FLD) and Floating Object
  Structure Analysis (FSA) Tasks
author: Chengxiang Ren
date: '2024-10-19T00:00:00.000Z'
format:
  nwa-cea-docx: default
lang: en
task_categories:
- object-detection
tags:
- DocumentLayoutAnalysis
size_categories:
- n<1K
---

# Description

A *floating object* is a common type of page element found in academic literature, books, and other formal publications. In LaTeX, a floating object typically refers to a container that can hold text, images, tables, code, algorithms, and other content. The placement of these containers within the document is automatically adjusted by LaTeX to fit the page layout. To facilitate indexing and readability, floating objects are usually accompanied by additional information such as type, numbering, and captions beyond the main content (image, table, code block, algorithm block). In more complex cases, a floating object may contain multiple sub-elements, each of which may have its own numbering. In LaTeX, common floating objects include the following:

-   *Figure*: A floating object for images, typically defined within the `\begin{figure}` and `\end{figure}` environment.
-   *Table*: A floating object for tables, typically defined within the `\begin{table}` and `\end{table}` environment.
-   *Algorithm*: A floating object for describing algorithms, often defined using additional packages such as `algorithm`, `algorithm2e`, or `algorithmicx`.
-   *Code*: A floating object for code, often defined using packages such as `listings` or `minted`.

For a long time, the number of elements detected by *Document Layout Analysis* (DLA) tasks has been extremely limited, with elements like tables and figures typically handled separately. This approach has several drawbacks:

1.  The relationship between the floating object’s caption and its main content is not captured, making it difficult to treat them as a single unit.
2.  The types of supported floating objects are limited. For instance, code blocks and algorithm blocks are often mistakenly recognized by DLA models as multiple text paragraphs, thus reducing accuracy.
3.  Extensibility is limited, preventing adaptation to increasingly diverse layout styles, such as more complex small-page environments. As a result, layout analysis models exhibit poor adaptability.

To address this, two additional tasks have been introduced on top of existing document layout analysis: *Floating Object Localization* (FLD) and *Floating Object Structure Analysis* (FSA). Specifically:

-   The *Floating Object Localization* (FLD) task aims to detect the position and type information of entire floating objects in document images. This includes five types of floating objects: figures, tables, algorithms, code, and others.
-   The *Floating Object Structure Analysis* (FSA) task aims to detect the substructure of floating objects in document images, whether for entire pages or individual floating objects. When sub-elements such as sub-figures or sub-tables are present, their positions and types can also be identified, along with the corresponding captions. The six recognized types include figures, tables, algorithms, code, captions, and others.

For the two tasks mentioned above, the *DocGenome* dataset was used to find arXiv documents, and X-AnyLabel was employed for annotation, resulting in the creation of the *Floating Object Localization Dataset* (FLD) and the *Floating Object Structure Analysis Dataset* (FSA), each containing 600 images.

# Download Method

The **Floating Object Localization Dataset (FLD)** can be downloaded from the following Huggingface URL:

- <https://huggingface.co/datasets/irhawks/floating-det>

The **Floating Object Structure Analysis Dataset (FSA)** can be downloaded from the following Huggingface URL:

- <https://huggingface.co/datasets/irhawks/floating-fsa>

# Annotation Standards

## Algorithms

The algorithm environment is used to describe procedural operations in pseudocode format. In practice, to maintain simplicity, pseudocode or programming languages such as Pascal or C are often used, typically containing control statements such as `for`, `while`, and `if`, along with line numbering. Additionally, the algorithm’s numbering and caption information are usually displayed above the algorithm. In this dataset, the algorithm’s number, caption, and main body are treated as a single unit, with all of these elements included as part of the annotation.

![Algorithm Annotation Example](images/paste-1.png)

*Algorithm structure analysis*, as a subtask of Floating Object Structure Analysis (FSA), focuses on analyzing the structure of algorithm blocks, dividing them into two parts: the caption and the main body. An example is shown below:

![Algorithm Structure Analysis Example](images/paste-9.png)

Notably, for the main body of the algorithm, the **algorithm’s bounding box is not considered; instead, the actual location of the pseudocode within the document image is used as the reference standard**. The same annotation standard is applied to other floating object elements (e.g., images, tables, code blocks).

![](images/paste-10.png)

## Code

The code environment typically describes programs in either a programming language or a language close to one, with an emphasis on executability. Therefore, it is usually associated with a specific programming language or a reduced language format. The main body of the code is often set in a monospaced font (though some environments may not use monospaced fonts), with English and symbols being the primary content, adhering to a clear indentation structure. For accurate recognition, this is critical. In this dataset, the code environment’s number, caption (if present), and main body are treated as a single unit, and all of these elements are included as part of the annotation.

![Code Annotation Example](images/paste-2.png)

In addition, the code environment may sometimes include numbering similar to inline mathematical formulas, primarily for the purpose of referencing within the main text. Although these elements are generally not considered floating objects, they are also annotated as floating objects.

![Inline Formula-like Code Environment](images/paste-3.png)

It is important to note that sometimes code environments share numbering with floating objects like figures. In such cases, although the caption might be labeled as a *Figure*, the floating object’s type should still be classified as *Code*. An example is shown below.

![](images/paste-6.png)

When annotating the structure of code environments, the title and the main body of the code are differentiated. Both the caption and the code body are bounded by their actual areas, excluding decorative lines.

![Code Structure Analysis Example](images/paste-11.png)

For non-floating code lines, the main body of the code and any accompanying numbering are annotated separately, with the numbering categorized as “other.”

![](images/paste-12.png)

## Figures

In this dataset, a *figure* is defined as an element that visually conveys information through graphical means rather than symbolic representation. This may include natural images or schematic drawings. Floating objects whose primary purpose is to explain one or more images are classified as *figures*. In the annotation process, the figure’s number, caption (if present), and main body are treated as a single unit, with all of these elements included.

![Figure Annotation Example](images/paste-4.png)

In the *Figure Structure Analysis* task, each individual graphic is annotated and labeled as a *figure*, while the caption for each sub-figure and any accompanying labels are classified as “captions.” An example is shown below.

![](images/paste-13.png)

## Tables

Tables are elements that display information in a two-dimensional grid, typically composed of rows, columns, and possibly footnotes. In this dataset, floating objects that aim to explain one or more tables are categorized as *tables*. During annotation, the table’s number, caption (if present), and main body are treated as a single unit, with all elements included.

![Table Annotation Example](images/paste-7.png)

![Table Environment Annotation Example](images/paste-8.png)

For the *Table Structure Analysis* task, the annotation standards are consistent with those of other structure analysis tasks. The main body is labeled as *table*, while each table caption is labeled as *caption*.

![](images/paste-14.png)

## Others

Elements other than figures, tables, code blocks, or algorithm blocks that still exhibit the basic characteristics of floating objects, or floating object regions that combine two or more types of content, are annotated as *other*. However, due to formatting conventions, these elements may also share caption styles with figures and tables.

![Other Annotation Example](images/paste-5.png)

In the *Other Structure Analysis* task, elements that do not fall into the categories of algorithms, code, figures, tables, or captions are labeled as *other*. Common examples include inline code numbering, table footnotes, and other similar elements. An example is shown below in the cyan-colored area.

![](images/paste-15.png)