Merge branch 'RED-7384' into 'release/0.89.x'

RED-7384: Fixes for ClassCastException

See merge request fforesight/layout-parser!110

.gitignore

@@ -38,3 +38,7 @@ build/
 
 ### VS Code ###
 .vscode/
+gradlew.bat
+gradlew
+gradle.properties
+gradle/

.gitlab-ci.yml

@@ -1,4 +1,21 @@
 include:
   - project: 'gitlab/gitlab'
     ref: 'main'
-    file: 'ci-templates/gradle_java.yml'
+    file: 'ci-templates/gradle_java.yml'
+
+deploy:
+  stage: deploy
+  tags:
+    - dind
+  script:
+    - echo "Building with gradle version ${BUILDVERSION}"
+    - gradle -Pversion=${BUILDVERSION} publish
+    - gradle bootBuildImage --publishImage -PbuildbootDockerHostNetwork=true -Pversion=${BUILDVERSION}
+    - echo "BUILDVERSION=$BUILDVERSION" >> version.env
+  artifacts:
+    reports:
+      dotenv: version.env
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH 
+    - if: $CI_COMMIT_BRANCH =~ /^release/
+    - if: $CI_COMMIT_TAG

README.md

@@ -1 +1,89 @@
+# PDF Layout Parser Micro-Service: layout-parser  
 
+## Introduction
+The layout-parser micro-service is a powerful tool designed to efficiently extract structured information from PDF documents. Written in Java and utilizing Spring Boot 3, Apache PDFBox, and RabbitMQ, this micro-service excels at parsing PDFs and organizing their content into a meaningful and coherent layout structure. Notably, the layout-parser micro-service distinguishes itself by relying solely on advanced algorithms, rather than machine learning techniques.
+
+### Key Steps in the PDF Layout Parsing Process:
+
+* **Text Position Extraction:**  
+The micro-service leverages Apache PDFBox to extract precise text positions for each individual character within the PDF document.
+
+* **Word Segmentation and Text Block Formation:**  
+Employing an array of diverse algorithms, the micro-service initially identifies and segments words, creating distinct text blocks.
+
+* **Text Block Classification:**  
+The segmented text blocks are then subjected to classification algorithms. These algorithms categorize the text blocks based on their content and visual properties, distinguishing between sections, subsections, headlines, paragraphs, images, tables, table cells, headers, and footers.
+
+* **Layout Coherence Establishment:**  
+The classified text blocks are subsequently orchestrated into a cohesive layout structure. This process involves arranging sections, subsections, paragraphs, images, and other elements in a logical and structured manner.
+
+* **Output Generation in Various Formats:**  
+Once the layout structure is established, the micro-service generates output in multiple formats. These formats are designed for seamless integration with downstream micro-services. The supported formats include JSON, XML, and others, ensuring flexibility in downstream data consumption.
+
+### Optional Enhancements:
+
+* **ML-Based Table Extraction:**  
+For enhanced results, users have the option to incorporate machine learning-based table extraction. This feature can be activated by providing ML-generated results as a JSON file, which are then integrated seamlessly into the layout structure.
+
+* **Image Classification using ML:**  
+Additionally, for more accurate image classification, users can optionally feed ML-generated image classification results into the micro-service. Similar to the table extraction option, the micro-service processes the pre-parsed results in JSON format, thus optimizing the accuracy of image content identification.
+
+In conclusion, the layout-parser micro-service is a versatile PDF layout parsing solution crafted entirely around advanced algorithms, without reliance on machine learning. It proficiently extracts text positions, segments content into meaningful blocks, classifies these blocks, arranges them coherently, and outputs structured data for downstream micro-services. Optional integration with ML-generated table extractions and image classifications further enhances its capabilities.
+
+
+
+
+
+
+## Installation
+
+### Prerequisites
+
+Before building and using the layout-parser micro-service, please ensure you have the following software and tools installed:
+
+Java Development Kit (JDK) 17 or later
+Gradle build tool (preinstalled)
+Build and Test
+To build and test the micro-service, follow these steps:
+
+### Clone the Repository:
+
+bash
+```
+git clone ssh://git@git.knecon.com:22222/fforesight/layout-parser.git
+cd layout-parser
+```
+### Build the Project:
+Use the following command to build the project using Gradle:
+
+```
+gradle clean build
+```
+### Run Tests:
+Run the test suite using the following command:
+```
+gradle test
+```
+## Building a Custom Docker Image
+To create a custom Docker image for the layout-parser micro-service, execute the provided script:
+
+### Ensure Docker is Installed:
+Ensure that Docker is installed and running on your system.
+
+### Run the Image Building Script:
+Execute the publish-custom-image script in the project directory:
+
+```
+./publish-custom-image
+```
+## Publishing to Internal Maven Repository
+To publish the layout-parser micro-service to your internal Maven repository, execute the following command:
+
+```
+gradle -Pversion=buildVersion publish
+```
+Replace buildVersion with the desired version number.
+
+## Additional Notes
+Make sure to configure any necessary application properties before deploying the micro-service.
+For advanced usage and configurations, refer to Kilian or Dom or preferably the source code.

buildSrc/src/main/kotlin/com.knecon.fforesight.java-conventions.gradle.kts

@@ -1,24 +1,16 @@
 plugins {
-    java
+    `java-library`
+    `maven-publish`
     pmd
     checkstyle
     jacoco
 }
 
 group = "com.knecon.fforesight"
-version = "0.1-SNAPSHOT"
 
 java.sourceCompatibility = JavaVersion.VERSION_17
 java.targetCompatibility = JavaVersion.VERSION_17
 
-tasks.jacocoTestReport {
-    reports {
-        xml.required.set(false)
-        csv.required.set(false)
-        html.outputLocation.set(layout.buildDirectory.dir("jacocoHtml"))
-    }
-}
-
 tasks.pmdMain {
     pmd.ruleSetFiles = files("${rootDir}/config/pmd/pmd.xml")
 }
@@ -29,6 +21,11 @@ tasks.pmdTest {
 
 tasks.named<Test>("test") {
     useJUnitPlatform()
+    reports {
+        junitXml.outputLocation.set(layout.buildDirectory.dir("reports/junit"))
+    }
+    minHeapSize = "512m"
+    maxHeapSize = "2048m"
 }
 
 tasks.test {
@@ -40,14 +37,38 @@ tasks.jacocoTestReport {
     reports {
         xml.required.set(true)
         csv.required.set(false)
+        html.outputLocation.set(layout.buildDirectory.dir("jacocoHtml"))
     }
 }
 
+allprojects {
+    publishing {
+        publications {
+            create<MavenPublication>(name) {
+                from(components["java"])
+            }
+        }
+        repositories {
+            maven {
+                url = uri("https://nexus.knecon.com/repository/red-platform-releases/")
+                credentials {
+                    username = providers.gradleProperty("mavenUser").getOrNull();
+                    password = providers.gradleProperty("mavenPassword").getOrNull();
+                }
+            }
+        }
+    }
+}
+
+java {
+    withJavadocJar()
+}
+
 repositories {
     mavenLocal()
     mavenCentral()
     maven {
-        url = uri("https://nexus.knecon.com/repository/gindev/");
+        url = uri("https://nexus.knecon.com/repository/gindev/")
         credentials {
             username = providers.gradleProperty("mavenUser").getOrNull();
             password = providers.gradleProperty("mavenPassword").getOrNull();

config/pmd/pmd.xml

@@ -9,13 +9,13 @@
     </description>
 
     <rule ref="category/java/errorprone.xml">
-        <exclude name="DataflowAnomalyAnalysis"/>
         <exclude name="MissingSerialVersionUID"/>
-        <exclude name="NullAssignment"/>
-        <exclude name="BeanMembersShouldSerialize"/>
         <exclude name="AvoidLiteralsInIfCondition"/>
         <exclude name="AvoidDuplicateLiterals"/>
-        <exclude name="AvoidFieldNameMatchingMethodName"/>
+        <exclude name="NullAssignment"/>
+        <exclude name="AssignmentInOperand"/>
+        <exclude name="BeanMembersShouldSerialize"/>
     </rule>
 
-</ruleset>
+</ruleset>
+

config/pmd/test_pmd.xml

@@ -10,14 +10,14 @@
 
 
     <rule ref="category/java/errorprone.xml">
-        <exclude name="DataflowAnomalyAnalysis"/>
         <exclude name="MissingSerialVersionUID"/>
-        <exclude name="NullAssignment"/>
-        <exclude name="BeanMembersShouldSerialize"/>
         <exclude name="AvoidLiteralsInIfCondition"/>
         <exclude name="AvoidDuplicateLiterals"/>
         <exclude name="AvoidFieldNameMatchingMethodName"/>
-        <exclude name="AvoidFieldNameMatchingTypeName"/>
+        <exclude name="NullAssignment"/>
+        <exclude name="AssignmentInOperand"/>
+        <exclude name="TestClassWithoutTestCases"/>
+        <exclude name="BeanMembersShouldSerialize"/>
     </rule>
 
-</ruleset>
+</ruleset>

gradle.properties.kts

@@ -1 +1 @@
-version = 0.1.0
+version = 0.1-SNAPSHOT

layoutparser-service/layoutparser-service-internal-api/build.gradle.kts

@@ -1,6 +1,10 @@
 plugins {
     id("com.knecon.fforesight.java-conventions")
-    id("io.freefair.lombok") version "8.1.0"
+    id("io.freefair.lombok") version "8.4"
 }
 
 description = "layoutparser-service-internal-api"
+
+dependencies {
+    implementation("io.swagger.core.v3:swagger-annotations:2.2.15")
+}

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/redaction/DocumentData.java

@@ -1,5 +1,8 @@
 package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
 
+import java.io.Serializable;
+
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -10,11 +13,16 @@ import lombok.experimental.FieldDefaults;
 @Builder
 @AllArgsConstructor
 @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
-public class DocumentData {
+@Schema(description = "Object containing the complete document layout parsing information. It is split into 4 categories, structure, text, positions and pages: " + "The document tree structure of SemanticNodes such as Section, Paragraph, Headline, etc. " + "The text, which is stored as separate blocks of data. " + "The text positions, which are also stored as separate blocks. The Blocks are equal to the text blocks in length and order. " + "The page information.")
+public class DocumentData implements Serializable {
 
+    @Schema(description = "Contains information about the document's pages.")
     DocumentPage[] documentPages;
+    @Schema(description = "Contains information about the document's text.")
     DocumentTextData[] documentTextData;
+    @Schema(description = "Contains information about the document's text positions.")
     DocumentPositionData[] documentPositions;
+    @Schema(description = "Contains information about the document's semantic structure.")
     DocumentStructure documentStructure;
 
 }

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/redaction/DocumentPage.java

@@ -1,5 +1,8 @@
 package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
 
+import java.io.Serializable;
+
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -12,11 +15,16 @@ import lombok.experimental.FieldDefaults;
 @NoArgsConstructor
 @AllArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
-public class DocumentPage {
+@Schema(description = "Object containing information about the document's pages.")
+public class DocumentPage implements Serializable {
 
+    @Schema(description = "The page number, starting with 1.")
     int number;
+    @Schema(description = "The page height in PDF user units.", example = "792")
     int height;
+    @Schema(description = "The page width in PDF user units.", example = "694")
     int width;
+    @Schema(description = "The page rotation as specified by the PDF.", example = "90", allowableValues = {"0", "90", "180", "270"})
     int rotation;
 
 }

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/redaction/DocumentPositionData.java

@@ -1,5 +1,8 @@
 package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
 
+import java.io.Serializable;
+
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -12,10 +15,14 @@ import lombok.experimental.FieldDefaults;
 @NoArgsConstructor
 @AllArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
-public class DocumentPositionData {
+@Schema(description = "Object containing text positional information of a specific text block. A document is split into multiple text blocks, which are supposed to be read in order. Every text block can only occur on a single page.")
+public class DocumentPositionData implements Serializable {
 
+    @Schema(description = "Identifier of the text block.")
     Long id;
+    @Schema(description = "For each string coordinate in the search text of the text block, the array contains an entry relating the string coordinate to the position coordinate. This is required due to the text and position coordinates not being equal.")
     int[] stringIdxToPositionIdx;
+    @Schema(description = "The bounding box for each glyph as a rectangle. This matrix is of size (n,4), where n is the number of glyphs in the text block. The second dimension specifies the rectangle with the value x, y, width, height, with x, y specifying the lower left corner. In order to access this information, the stringIdxToPositionIdx array must be used to transform the coordinates.")
     float[][] positions;
 
 }

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/redaction/DocumentStructure.java

@@ -1,9 +1,13 @@
 package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
 
+import java.awt.geom.Rectangle2D;
+import java.io.Serializable;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Stream;
 
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -16,10 +20,49 @@ import lombok.experimental.FieldDefaults;
 @NoArgsConstructor
 @AllArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
-public class DocumentStructure {
+@Schema(description = "Object containing information about the parsed tree structure of the SemanticNodes, such as Section, Paragraph, Headline etc inside of the document.")
+public class DocumentStructure implements Serializable {
 
+    @Schema(description = "The root EntryData represents the Document.")
     EntryData root;
 
+    @Schema(description = "Object containing the extra field names, a table has in its properties field.")
+    public static class TableProperties implements Serializable {
+
+        public static final String NUMBER_OF_ROWS = "numberOfRows";
+        public static final String NUMBER_OF_COLS = "numberOfCols";
+
+    }
+
+    @Schema(description = "Object containing the extra field names, an Image has in its properties field.")
+    public static class ImageProperties implements Serializable {
+
+        public static final String TRANSPARENT = "transparent";
+        public static final String IMAGE_TYPE = "imageType";
+        public static final String POSITION = "position";
+        public static final String ID = "id";
+
+    }
+
+    @Schema(description = "Object containing the extra field names, a table cell has in its properties field.")
+    public static class TableCellProperties implements Serializable {
+
+        public static final String B_BOX = "bBox";
+        public static final String ROW = "row";
+        public static final String COL = "col";
+        public static final String HEADER = "header";
+
+    }
+
+    public static final String RECTANGLE_DELIMITER = ";";
+
+
+    public static Rectangle2D parseRectangle2D(String bBox) {
+
+        List<Float> floats = Arrays.stream(bBox.split(RECTANGLE_DELIMITER)).map(Float::parseFloat).toList();
+        return new Rectangle2D.Float(floats.get(0), floats.get(1), floats.get(2), floats.get(3));
+    }
+
 
     public EntryData get(List<Integer> tocId) {
 
@@ -57,15 +100,23 @@ public class DocumentStructure {
     @NoArgsConstructor
     @AllArgsConstructor
     @FieldDefaults(level = AccessLevel.PRIVATE)
-    public static class EntryData {
+    @Schema(description = "Object containing information of a SemanticNode and also structuring the layout with children.")
+    public static class EntryData implements Serializable {
 
+        @Schema(description = "Type of the semantic node.", allowableValues = {"DOCUMENT", "SECTION", "PARAGRAPH", "HEADLINE", "TABLE", "TABLE_CELL", "HEADER", "FOOTER", "IMAGE"})
         NodeType type;
+        @Schema(description = "Specifies the position in the parsed tree structure.", example = "[1, 0, 2]")
         int[] treeId;
+        @Schema(description = "Specifies the text block IDs associated with this semantic node. The value should be joined with the DocumentTextData/DocumentPositionData. Is empty, if no text block is directly associated with this semantic node. Only Paragraph, Headline, Header or Footer is directly associated with a text block.", example = "[1]")
         Long[] atomicBlockIds;
+        @Schema(description = "Specifies the pages this semantic node appears on. The value should be joined with the PageData.", example = "[1, 2, 3]")
         Long[] pageNumbers;
+        @Schema(description = "Some semantic nodes have additional information, this information is stored in this Map. The extra fields are specified by the Properties subclasses.", example = "For a Table: {\"numberOfRows\": 3, \"numberOfCols\": 4}")
         Map<String, String> properties;
+        @Schema(description = "All child Entries of this Entry.", example = "[1, 2, 3]")
         List<EntryData> children;
 
+
         @Override
         public String toString() {
 

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/redaction/DocumentTextData.java

@@ -1,7 +1,8 @@
 package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
 
+import java.io.Serializable;
 
-
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -14,14 +15,22 @@ import lombok.experimental.FieldDefaults;
 @NoArgsConstructor
 @AllArgsConstructor
 @FieldDefaults(level = AccessLevel.PRIVATE)
-public class DocumentTextData {
+@Schema(description = "Object containing text information of a specific text block. A document is split into multiple text blocks, which are supposed to be read in order. Every text block can only occur on a single page.")
+public class DocumentTextData implements Serializable {
 
+    @Schema(description = "Identifier of the text block.")
     Long id;
+    @Schema(description = "The page the text block occurs on.")
     Long page;
+    @Schema(description = "The text the text block.")
     String searchText;
+    @Schema(description = "Each text block is assigned a number on a page, starting from 0.")
     int numberOnPage;
+    @Schema(description = "The text blocks are ordered, this number represents the start of the text block as a string offset.")
     int start;
+    @Schema(description = "The text blocks are ordered, this number represents the end of the text block as a string offset.")
     int end;
+    @Schema(description = "The line breaks in the text of this semantic node in string offsets. They are exclusive end. At the end of each semantic node there is an implicit linebreak.", example = "[5, 10]")
     int[] lineBreaks;
 
 }

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/redaction/NodeType.java

@@ -1,8 +1,9 @@
 package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
 
+import java.io.Serializable;
 import java.util.Locale;
 
-public enum NodeType {
+public enum NodeType implements Serializable {
     DOCUMENT,
     SECTION,
     HEADLINE,

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/redaction/SimplifiedSectionText.java

@@ -0,0 +1,21 @@
+package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(description = "Object containing a simplified version, which contains almost exclusively text, of the document structure Section class.")
+public class SimplifiedSectionText {
+
+    @Schema(description = "The number of this Section. This is used to map the simplified section text back to the original Section.")
+    private int sectionNumber;
+    @Schema(description = "The text in this Section.")
+    private String text;
+
+}

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/redaction/SimplifiedText.java

@@ -0,0 +1,24 @@
+package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(description = "Object containing a simplified version, which contains almost exclusively text, of the document structure.")
+public class SimplifiedText {
+
+    @Schema(description = "Number of pages in the entire document.")
+    private int numberOfPages;
+    @Schema(description = "A List of simplified Sections, which contains almost exclusively text.")
+    private List<SimplifiedSectionText> sectionTexts = new ArrayList<>();
+
+}

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/taas/ParagraphData.java

@@ -2,20 +2,29 @@ package com.knecon.fforesight.service.layoutparser.internal.api.data.taas;
 
 import java.util.List;
 
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Builder;
 import lombok.Data;
 
 @Data
 @Builder
+@Schema(description = "Object containing information about a Paragraph/Headline/Header/Footer.")
 public class ParagraphData {
 
+    @Schema(description = "The text of this Semantic Node, without any linebreaks.", example = "This is some text.")
     private String text;
+    @Schema(description = "A list of text ranges in string offsets. Every character in any of the ranges is bold.", example = "[0, 15]")
     List<Range> boldTextBoundaries;
+    @Schema(description = "A list of text ranges in string offsets. Every character in any of the ranges is italic.", example = "[0, 15]")
     List<Range> italicTextBoundaries;
+    @Schema(description = "The line breaks in the text of this semantic node in string offsets. They are exclusive end. At the end of each semantic node there is an implicit linebreak.", example = "[5, 10]")
     List<Integer> linebreaks;
+    @Schema(description = "The classification of this Paragraph.", allowableValues = "{paragraph, headline, header, footer}")
     private String classification;
 
+    @Schema(description = "Describes the text orientation of this semantic node. Any semantic node only has a single text orientation.", allowableValues = "{ZERO, QUARTER_CIRCLE, HALF_CIRCLE, THREE_QUARTER_CIRCLE}")
     private String orientation;
+    @Schema(description = "Describes the text direction in degrees of this semantic node. Any semantic node only has a single text direction.", minimum = "0", maximum = "359")
     private int textDirection;
 
 }

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/taas/Range.java

@@ -1,5 +1,8 @@
 package com.knecon.fforesight.service.layoutparser.internal.api.data.taas;
 
+import io.swagger.v3.oas.annotations.media.Schema;
+
+@Schema(description = "Object specifying the start and end offsets of a text range in string offsets.")
 public record Range(int start, int end) {
 
 }

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/taas/ResearchDocumentData.java

@@ -2,6 +2,7 @@ package com.knecon.fforesight.service.layoutparser.internal.api.data.taas;
 
 import java.util.List;
 
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
@@ -9,8 +10,12 @@ import lombok.Data;
 @Builder
 @Data
 @AllArgsConstructor
+@Schema(description = "Object containing a simplified version of the document structure. This simplified form only knows Paragraphs and Tables. The Paragraph Objects might be a Paragraph, Headline, Header or Footer.")
 public class ResearchDocumentData {
 
+    @Schema(description = "File name of the original uploaded file.")
     String originalFile;
+    @Schema(description = "A List of all paragraphs/headline or table objects, that have been parsed in this document.")
     List<StructureObject> structureObjects;
+
 }

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/taas/RowData.java

@@ -2,14 +2,19 @@ package com.knecon.fforesight.service.layoutparser.internal.api.data.taas;
 
 import java.util.List;
 
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 
 @Data
 @AllArgsConstructor
+@Schema(description = "Object containing information about a Table Row.")
 public class RowData {
 
+    @Schema(description = "Boolean indicating whether this table row is classified as a header row.")
     boolean header;
+    @Schema(description = "A list of Objects containing information about the text in each cell of this row.")
     List<ParagraphData> cellText;
+    @Schema(description = "The bounding box of this StructureObject. Is always exactly 4 values representing x, y, w, h, where x, y specify the lower left corner.")
     float[] bBox;
 }

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/taas/StructureObject.java

@@ -1,5 +1,6 @@
 package com.knecon.fforesight.service.layoutparser.internal.api.data.taas;
 
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
@@ -7,13 +8,20 @@ import lombok.Data;
 @Data
 @Builder
 @AllArgsConstructor
+@Schema(description = "Object containing information about either a Paragraph/Headline/Header/Footer or a Table.")
 public class StructureObject {
 
+    @Schema(description = "The ID of this StructureObject.")
     Integer structureObjectNumber;
+    @Schema(description = "This value indicates the start of the string offsets in this Object, with respect to the reading order.")
     int page;
+    @Schema(description = "This stringOffset indicates the start of the string offsets in this Object, with respect to the reading order of the entire document. It is equal to the previous' StructureObject stringOffset + its length.")
     int stringOffset;
+    @Schema(description = "The bounding box of this StructureObject. Is always exactly 4 values representing x, y, w, h, where x, y specify the lower left corner.", example = "[100, 100, 50, 50]")
     float[] boundingBox;
+    @Schema(description = "Object containing information about a Paragraph/Headline/Header/Footer. Either this or table is null.")
     ParagraphData paragraph;
+    @Schema(description = "Object containing information about a Table. Either this or paragraph is null.")
     TableData table;
 
 }

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/taas/TableData.java

@@ -2,15 +2,20 @@ package com.knecon.fforesight.service.layoutparser.internal.api.data.taas;
 
 import java.util.List;
 
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 
 @Data
 @AllArgsConstructor
+@Schema(description = "Object containing information about a Table.")
 public class TableData {
 
+    @Schema(description = "A list of Objects containing information about all rows in this table.")
     List<RowData> rowData;
+    @Schema(description = "Number of columns in this table.")
     Integer numberOfCols;
+    @Schema(description = "Number of rows in this table.")
     Integer numberOfRows;
 
 }

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/queue/LayoutParsingFinishedEvent.java

@@ -2,9 +2,19 @@ package com.knecon.fforesight.service.layoutparser.internal.api.queue;
 
 import java.util.Map;
 
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Builder;
 
 @Builder
-public record LayoutParsingFinishedEvent(Map<String, String> identifier, long duration, int numberOfPages, String message) {
+@Schema(description = "Object containing information about the layout parsing.")
+public record LayoutParsingFinishedEvent(
+        @Schema(description = "General purpose identifier. It is returned exactly the same way it is inserted with the LayoutParsingRequest.")
+        Map<String, String> identifier,//
+        @Schema(description = "The duration of a single layout parsing in ms.")
+        long duration,//
+        @Schema(description = "The number of pages of the parsed document.")
+        int numberOfPages,//
+        @Schema(description = "A general message. It contains some information useful for a developer, like the paths where the files are stored. Not meant to be machine readable.")
+        String message) {
 
 }

layoutparser-service/layoutparser-service-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/queue/LayoutParsingRequest.java

@@ -3,21 +3,39 @@ package com.knecon.fforesight.service.layoutparser.internal.api.queue;
 import java.util.Map;
 import java.util.Optional;
 
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Builder;
-
+import lombok.NonNull;
 
 @Builder
+@Schema(description = "Object containing all storage paths the service needs to know.")
 public record LayoutParsingRequest(
-        LayoutParsingType layoutParsingType,
+        @Schema(description = "Enum specifying the type of layout parsing to be performed.", allowableValues = "{RedactManager, DocuMine, TAAS}")//
+        @NonNull LayoutParsingType layoutParsingType,
+
+        @Schema(description = "General purpose identifiers. They are not changed by the service at all and are returned as is in the response queue.")//
         Map<String, String> identifier,
-        String originFileStorageId,
-        Optional<String> tablesFileStorageId,
-        Optional<String> imagesFileStorageId,
-        String structureFileStorageId,
-        String researchDocumentStorageId,
-        String textBlockFileStorageId,
-        String positionBlockFileStorageId,
-        String pageFileStorageId,
-        String sectionGridStorageId) {
+
+        @Schema(description = "Path to the original PDF file.")//
+        @NonNull String originFileStorageId,//
+        @Schema(description = "Optional Path to the table extraction file.")//
+        Optional<String> tablesFileStorageId,//
+        @Schema(description = "Optional Path to the image classification file.")//
+        Optional<String> imagesFileStorageId,//
+
+        @Schema(description = "Path where the Document Structure File will be stored.")//
+        @NonNull String structureFileStorageId,//
+        @Schema(description = "Path where the Research Data File will be stored.")//
+        String researchDocumentStorageId,//
+        @Schema(description = "Path where the Document Text File will be stored.")//
+        @NonNull String textBlockFileStorageId,//
+        @Schema(description = "Path where the Document Positions File will be stored.")//
+        @NonNull String positionBlockFileStorageId,//
+        @Schema(description = "Path where the Document Pages File will be stored.")//
+        @NonNull String pageFileStorageId,//
+        @Schema(description = "Path where the Simplified Text File will be stored.")//
+        @NonNull String simplifiedTextStorageId,//
+        @Schema(description = "Path where the Viewer Document PDF will be stored.")//
+        @NonNull String viewerDocumentStorageId) {
 
 }

layoutparser-service/layoutparser-service-processor/build.gradle.kts

@@ -1,21 +1,27 @@
 plugins {
     id("com.knecon.fforesight.java-conventions")
-    id("io.freefair.lombok") version "8.1.0"
-}
-
-dependencies {
-    implementation(project(":layoutparser-service-internal-api"))
-
-    implementation("com.iqser.red.service:persistence-service-shared-api-v1:2.36.0")
-    implementation("com.knecon.fforesight:tenant-commons:0.10.0")
-    implementation("com.iqser.red.commons:storage-commons:2.1.0")
-
-    implementation("org.apache.pdfbox:pdfbox:3.0.0-alpha2")
-    implementation("org.apache.pdfbox:pdfbox-tools:3.0.0-alpha2")
-    implementation("com.fasterxml.jackson.module:jackson-module-afterburner:2.15.0-rc2")
-    implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.15.0-rc2")
-    implementation("org.springframework.boot:spring-boot-starter-web:3.0.6")
-    implementation("org.springframework.boot:spring-boot-starter-amqp:3.0.6")
+    id("io.freefair.lombok") version "8.4"
 }
 
 description = "layoutparser-service-processor"
+
+val jacksonVersion = "2.15.2"
+val pdfBoxVersion = "3.0.0"
+
+dependencies {
+    implementation(project(":layoutparser-service-internal-api"))
+    implementation(project(":viewer-doc-processor"))
+
+    implementation("com.iqser.red.service:persistence-service-shared-api-v1:2.144.0") {
+        exclude("org.springframework.boot", "spring-boot-starter-security")
+        exclude("org.springframework.boot", "spring-boot-starter-validation")
+    }
+    implementation("com.knecon.fforesight:tenant-commons:0.21.0")
+    implementation("com.iqser.red.commons:storage-commons:2.45.0")
+
+    implementation("org.apache.pdfbox:pdfbox:${pdfBoxVersion}")
+    implementation("org.apache.pdfbox:pdfbox-tools:${pdfBoxVersion}")
+    implementation("com.fasterxml.jackson.module:jackson-module-afterburner:${jacksonVersion}")
+    implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:${jacksonVersion}")
+    implementation("org.springframework.boot:spring-boot-starter-web:3.1.3")
+}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/LayoutParsingPipeline.java

@@ -2,142 +2,354 @@ package com.knecon.fforesight.service.layoutparser.processor;
 
 import static java.lang.String.format;
 
+import java.awt.geom.Rectangle2D;
+import java.io.File;
 import java.io.IOException;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
 
+import org.apache.pdfbox.Loader;
 import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.apache.pdfbox.pdmodel.common.PDRectangle;
+import org.apache.pdfbox.pdmodel.documentinterchange.markedcontent.PDMarkedContent;
 import org.springframework.stereotype.Service;
 
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
 import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingFinishedEvent;
 import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingRequest;
 import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingType;
+import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
+import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationDocument;
+import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Document;
+import com.knecon.fforesight.service.layoutparser.processor.model.image.ClassifiedImage;
+import com.knecon.fforesight.service.layoutparser.processor.model.table.CleanRulings;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
 import com.knecon.fforesight.service.layoutparser.processor.python_api.adapter.CvTableParsingAdapter;
 import com.knecon.fforesight.service.layoutparser.processor.python_api.adapter.ImageServiceResponseAdapter;
 import com.knecon.fforesight.service.layoutparser.processor.python_api.model.image.ImageServiceResponse;
+import com.knecon.fforesight.service.layoutparser.processor.python_api.model.table.TableCells;
 import com.knecon.fforesight.service.layoutparser.processor.python_api.model.table.TableServiceResponse;
-import com.knecon.fforesight.service.layoutparser.processor.services.factory.DocumentGraphFactory;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Document;
-import com.knecon.fforesight.service.layoutparser.processor.services.mapper.DocumentDataMapper;
-import com.knecon.fforesight.service.layoutparser.processor.services.mapper.TaasDocumentDataMapper;
-import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationDocument;
-import com.knecon.fforesight.service.layoutparser.processor.services.PdfParsingService;
-import com.knecon.fforesight.service.layoutparser.processor.services.SectionGridCreatorService;
+import com.knecon.fforesight.service.layoutparser.processor.services.BodyTextFrameService;
+import com.knecon.fforesight.service.layoutparser.processor.services.RulingCleaningService;
 import com.knecon.fforesight.service.layoutparser.processor.services.SectionsBuilderService;
+import com.knecon.fforesight.service.layoutparser.processor.services.SimplifiedSectionTextService;
+import com.knecon.fforesight.service.layoutparser.processor.services.TableExtractionService;
+import com.knecon.fforesight.service.layoutparser.processor.services.blockification.DocuMineBlockificationService;
+import com.knecon.fforesight.service.layoutparser.processor.services.blockification.RedactManagerBlockificationService;
+import com.knecon.fforesight.service.layoutparser.processor.services.blockification.TaasBlockificationService;
 import com.knecon.fforesight.service.layoutparser.processor.services.classification.DocuMineClassificationService;
 import com.knecon.fforesight.service.layoutparser.processor.services.classification.RedactManagerClassificationService;
 import com.knecon.fforesight.service.layoutparser.processor.services.classification.TaasClassificationService;
+import com.knecon.fforesight.service.layoutparser.processor.services.factory.DocumentGraphFactory;
+import com.knecon.fforesight.service.layoutparser.processor.services.mapper.DocumentDataMapper;
+import com.knecon.fforesight.service.layoutparser.processor.services.mapper.TaasDocumentDataMapper;
+import com.knecon.fforesight.service.layoutparser.processor.services.parsing.PDFLinesTextStripper;
+import com.knecon.fforesight.service.layoutparser.processor.services.visualization.LayoutGridService;
+import com.knecon.fforesight.service.layoutparser.processor.utils.MarkedContentUtils;
 
+import io.micrometer.observation.Observation;
+import io.micrometer.observation.ObservationRegistry;
+import io.micrometer.observation.annotation.Observed;
+import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import lombok.experimental.FieldDefaults;
 import lombok.extern.slf4j.Slf4j;
 
+@SuppressWarnings("PMD.CloseResource")
 @Slf4j
 @Service
 @RequiredArgsConstructor
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
 public class LayoutParsingPipeline {
 
-    private final ImageServiceResponseAdapter imageServiceResponseAdapter;
-    private final CvTableParsingAdapter cvTableParsingAdapter;
-    private final LayoutParsingStorageService layoutParsingStorageService;
-    private final PdfParsingService pdfParsingService;
-    private final SectionsBuilderService sectionsBuilderService;
-    private final SectionGridCreatorService sectionGridCreatorService;
-    private final TaasClassificationService taasClassificationService;
-    private final RedactManagerClassificationService redactManagerClassificationService;
-    private final DocuMineClassificationService docuMineClassificationService;
+    ImageServiceResponseAdapter imageServiceResponseAdapter;
+    CvTableParsingAdapter cvTableParsingAdapter;
+    LayoutParsingStorageService layoutParsingStorageService;
+    SectionsBuilderService sectionsBuilderService;
+    TaasClassificationService taasClassificationService;
+    RedactManagerClassificationService redactManagerClassificationService;
+    DocuMineClassificationService docuMineClassificationService;
+    SimplifiedSectionTextService simplifiedSectionTextService;
+    BodyTextFrameService bodyTextFrameService;
+    RulingCleaningService rulingCleaningService;
+    TableExtractionService tableExtractionService;
+    TaasBlockificationService taasBlockificationService;
+    DocuMineBlockificationService docuMineBlockificationService;
+    RedactManagerBlockificationService redactManagerBlockificationService;
+    LayoutGridService layoutGridService;
+    ObservationRegistry observationRegistry;
 
 
     public LayoutParsingFinishedEvent parseLayoutAndSaveFilesToStorage(LayoutParsingRequest layoutParsingRequest) throws IOException {
 
         long start = System.currentTimeMillis();
+        log.info("Starting layout parsing for {}", layoutParsingRequest.identifier());
 
-        try (PDDocument originDocument = layoutParsingStorageService.getOriginFile(layoutParsingRequest.originFileStorageId())) {
-            ImageServiceResponse imageServiceResponse = new ImageServiceResponse();
-            if (layoutParsingRequest.imagesFileStorageId().isPresent()) {
-                imageServiceResponse = layoutParsingStorageService.getImagesFile(layoutParsingRequest.pageFileStorageId());
-            }
+        File originFile = layoutParsingStorageService.getOriginFile(layoutParsingRequest.originFileStorageId());
+//        File viewerDocumentFile = layoutParsingStorageService.getViewerDocFile(layoutParsingRequest.viewerDocumentStorageId())
+//                .orElse(originFile);
+        File viewerDocumentFile = originFile;
 
-            TableServiceResponse tableServiceResponse = new TableServiceResponse();
-            if (layoutParsingRequest.tablesFileStorageId().isPresent()) {
-                tableServiceResponse = layoutParsingStorageService.getTablesFile(layoutParsingRequest.pageFileStorageId());
-            }
 
-            Document documentGraph = parseLayout(layoutParsingRequest.layoutParsingType(), originDocument, imageServiceResponse, tableServiceResponse);
-            int numberOfPages = originDocument.getNumberOfPages();
-
-            layoutParsingStorageService.storeSectionGrid(layoutParsingRequest, sectionGridCreatorService.createSectionGrid(documentGraph));
-            layoutParsingStorageService.storeDocumentData(layoutParsingRequest, DocumentDataMapper.toDocumentData(documentGraph));
-
-            if (layoutParsingRequest.layoutParsingType().equals(LayoutParsingType.TAAS)) {
-                var researchDocumentData = TaasDocumentDataMapper.fromDocument(documentGraph);
-                layoutParsingStorageService.storeResearchDocumentData(layoutParsingRequest, researchDocumentData);
-            }
-
-            return LayoutParsingFinishedEvent.builder()
-                    .identifier(layoutParsingRequest.identifier())
-                    .numberOfPages(numberOfPages)
-                    .duration(System.currentTimeMillis() - start)
-                    .message(format("Layout parsing is finished and files have been saved with Ids:\n Structure: %s\nText: %s\nPositions: %s\nPageData: %s",
-                            layoutParsingRequest.structureFileStorageId(),
-                            layoutParsingRequest.textBlockFileStorageId(),
-                            layoutParsingRequest.positionBlockFileStorageId(),
-                            layoutParsingRequest.pageFileStorageId()))
-                    .build();
+        ImageServiceResponse imageServiceResponse = new ImageServiceResponse();
+        if (layoutParsingRequest.imagesFileStorageId()
+                .isPresent()) {
+            imageServiceResponse = layoutParsingStorageService.getImagesFile(layoutParsingRequest.imagesFileStorageId()
+                                                                                     .get());
         }
+
+        TableServiceResponse tableServiceResponse = new TableServiceResponse();
+        if (layoutParsingRequest.tablesFileStorageId()
+                .isPresent()) {
+            tableServiceResponse = layoutParsingStorageService.getTablesFile(layoutParsingRequest.tablesFileStorageId()
+                                                                                     .get());
+        }
+
+        ClassificationDocument classificationDocument = parseLayout(layoutParsingRequest.layoutParsingType(),
+                originFile,
+                imageServiceResponse,
+                tableServiceResponse,
+                layoutParsingRequest.identifier().toString());
+
+        log.info("Building document graph for {}", layoutParsingRequest.identifier());
+
+        Document documentGraph = observeBuildDocumentGraph(classificationDocument);
+
+        log.info("Creating viewer document for {}", layoutParsingRequest.identifier());
+
+        layoutGridService.addLayoutGrid(viewerDocumentFile, documentGraph, viewerDocumentFile, false);
+
+        log.info("Storing resulting files for {}", layoutParsingRequest.identifier());
+
+        layoutParsingStorageService.storeDocumentData(layoutParsingRequest, DocumentDataMapper.toDocumentData(documentGraph));
+        layoutParsingStorageService.storeSimplifiedText(layoutParsingRequest, simplifiedSectionTextService.toSimplifiedText(documentGraph));
+        layoutParsingStorageService.storeViewerDocument(layoutParsingRequest, viewerDocumentFile);
+
+        if (layoutParsingRequest.layoutParsingType().equals(LayoutParsingType.TAAS)) {
+            log.info("Building research document data for {}", layoutParsingRequest.identifier());
+            var researchDocumentData = TaasDocumentDataMapper.fromDocument(documentGraph);
+            layoutParsingStorageService.storeResearchDocumentData(layoutParsingRequest, researchDocumentData);
+        }
+
+        if (!viewerDocumentFile.equals(originFile)) {
+            viewerDocumentFile.delete();
+        }
+        originFile.delete();
+
+        return LayoutParsingFinishedEvent.builder()
+                .identifier(layoutParsingRequest.identifier())
+                .numberOfPages(documentGraph.getNumberOfPages())
+                .duration(System.currentTimeMillis() - start)
+                .message(format("""
+                                        Layout parsing has finished in %.02f s.
+                                        identifiers: %s
+                                        %s
+                                        Files have been saved with Ids:
+                                        Structure: %s
+                                        Text: %s
+                                        Positions: %s
+                                        PageData: %s
+                                        Simplified Text: %s
+                                        Viewer Doc: %s""",
+                                ((float) (System.currentTimeMillis() - start)) / 1000,
+                                layoutParsingRequest.identifier(),
+                                buildSemanticNodeCountMessage(documentGraph.getNumberOfPages(), documentGraph.buildSemanticNodeCounts()),
+                                layoutParsingRequest.structureFileStorageId(),
+                                layoutParsingRequest.textBlockFileStorageId(),
+                                layoutParsingRequest.positionBlockFileStorageId(),
+                                layoutParsingRequest.pageFileStorageId(),
+                                layoutParsingRequest.simplifiedTextStorageId(),
+                                layoutParsingRequest.viewerDocumentStorageId()))
+                .build();
+
     }
 
 
-    public Document parseLayout(LayoutParsingType layoutParsingType,
-                                PDDocument originDocument,
-                                ImageServiceResponse imageServiceResponse,
-                                TableServiceResponse tableServiceResponse) {
+    private Document observeBuildDocumentGraph(ClassificationDocument classificationDocument) {
 
-        ClassificationDocument classificationDocument = pdfParsingService.parseDocument(layoutParsingType,
-                originDocument,
-                cvTableParsingAdapter.buildCvParsedTablesPerPage(tableServiceResponse),
-                imageServiceResponseAdapter.buildClassifiedImagesPerPage(imageServiceResponse));
+        AtomicReference<Document> documentReference = new AtomicReference<>();
 
+        Observation.createNotStarted("LayoutParsingPipeline", observationRegistry)
+                .contextualName("build-document-graph")
+                .observe(() -> documentReference.set(DocumentGraphFactory.buildDocumentGraph(classificationDocument)));
+
+        return documentReference.get();
+    }
+
+
+    private String buildSemanticNodeCountMessage(int numberOfPages, Map<NodeType, Long> semanticNodeCounts) {
+
+        return String.format("%d pages with %d sections, %d headlines, %d paragraphs, %d tables with %d cells, %d headers, and %d footers parsed",
+                             numberOfPages,
+                             semanticNodeCounts.get(NodeType.SECTION) == null ? 0 : semanticNodeCounts.get(NodeType.SECTION),
+                             semanticNodeCounts.get(NodeType.HEADLINE) == null ? 0 : semanticNodeCounts.get(NodeType.HEADLINE),
+                             semanticNodeCounts.get(NodeType.PARAGRAPH) == null ? 0 : semanticNodeCounts.get(NodeType.PARAGRAPH),
+                             semanticNodeCounts.get(NodeType.TABLE) == null ? 0 : semanticNodeCounts.get(NodeType.TABLE),
+                             semanticNodeCounts.get(NodeType.TABLE_CELL) == null ? 0 : semanticNodeCounts.get(NodeType.TABLE_CELL),
+                             semanticNodeCounts.get(NodeType.HEADER) == null ? 0 : semanticNodeCounts.get(NodeType.HEADER),
+                             semanticNodeCounts.get(NodeType.FOOTER) == null ? 0 : semanticNodeCounts.get(NodeType.FOOTER));
+    }
+
+
+    @SneakyThrows
+    @Observed(name = "LayoutParsingPipeline", contextualName = "parse-layout")
+    public ClassificationDocument parseLayout(LayoutParsingType layoutParsingType,
+                                              File originFile,
+                                              ImageServiceResponse imageServiceResponse,
+                                              TableServiceResponse tableServiceResponse,
+                                              String identifier) {
+
+        PDDocument originDocument = openDocument(originFile);
+        addNumberOfPagesToTrace(originDocument.getNumberOfPages(), Files.size(originFile.toPath()));
+        Map<Integer, List<TableCells>> pdfTableCells = cvTableParsingAdapter.buildCvParsedTablesPerPage(tableServiceResponse);
+        Map<Integer, List<ClassifiedImage>> pdfImages = imageServiceResponseAdapter.buildClassifiedImagesPerPage(imageServiceResponse);
+
+        ClassificationDocument classificationDocument = new ClassificationDocument();
+        List<ClassificationPage> classificationPages = new ArrayList<>();
+
+        long pageCount = originDocument.getNumberOfPages();
+
+        for (int pageNumber = 1; pageNumber <= pageCount; pageNumber++) {
+
+            if (pageNumber % 100 == 0) {
+                // re-open document every once in a while to save on RAM. This has no significant performance impact.
+                // This is due to PDFBox caching all images and some other stuff with Soft References. This dereferences them and forces the freeing of memory.
+                originDocument.close();
+                originDocument = openDocument(originFile);
+            }
+
+            if (pageNumber % 100 == 0 || pageNumber == pageCount || pageNumber == 1) {
+                log.info("Extracting text on Page {} for {}", pageNumber, identifier);
+            }
+
+            classificationDocument.setPages(classificationPages);
+            PDFLinesTextStripper stripper = new PDFLinesTextStripper();
+            PDPage pdPage = originDocument.getPage(pageNumber - 1);
+            stripper.setPageNumber(pageNumber);
+            stripper.setStartPage(pageNumber);
+            stripper.setEndPage(pageNumber);
+            stripper.setPdpage(pdPage);
+            if (layoutParsingType.equals(LayoutParsingType.DOCUMINE)) {
+                stripper.setSortByPosition(true);
+            }
+            stripper.getText(originDocument);
+
+            PDRectangle pdr = pdPage.getMediaBox();
+
+            int rotation = pdPage.getRotation();
+            boolean isLandscape = pdr.getWidth() > pdr.getHeight() && (rotation == 0 || rotation == 180) || pdr.getHeight() > pdr.getWidth() && (rotation == 90 || rotation == 270);
+
+            PDRectangle cropbox = pdPage.getCropBox();
+            CleanRulings cleanRulings = rulingCleaningService.getCleanRulings(pdfTableCells.get(pageNumber), stripper.getRulings());
+
+            ClassificationPage classificationPage = switch (layoutParsingType) {
+                case REDACT_MANAGER -> redactManagerBlockificationService.blockify(stripper.getTextPositionSequences(), cleanRulings.getHorizontal(), cleanRulings.getVertical());
+                case TAAS -> taasBlockificationService.blockify(stripper.getTextPositionSequences(), cleanRulings.getHorizontal(), cleanRulings.getVertical());
+                case DOCUMINE -> docuMineBlockificationService.blockify(stripper.getTextPositionSequences(), cleanRulings.getHorizontal(), cleanRulings.getVertical());
+            };
+            classificationPage.setCleanRulings(cleanRulings);
+            classificationPage.setRotation(rotation);
+            classificationPage.setLandscape(isLandscape);
+            classificationPage.setPageNumber(pageNumber);
+            classificationPage.setPageWidth(cropbox.getWidth());
+            classificationPage.setPageHeight(cropbox.getHeight());
+
+            // MarkedContent needs to be converted at this point, otherwise it leads to GC Problems in Pdfbox.
+            classificationPage.setMarkedContentBboxPerType(convertMarkedContents(stripper.getMarkedContents()));
+
+            // If images is ocr needs to be calculated before textBlocks are moved into tables, otherwise findOcr algorithm needs to be adopted.
+            if (pdfImages != null && pdfImages.containsKey(pageNumber)) {
+                classificationPage.setImages(pdfImages.get(pageNumber));
+                imageServiceResponseAdapter.findOcr(classificationPage);
+            }
+
+            tableExtractionService.extractTables(cleanRulings, classificationPage);
+
+            buildPageStatistics(classificationPage);
+            increaseDocumentStatistics(classificationPage, classificationDocument);
+
+            classificationPages.add(classificationPage);
+        }
+
+        originDocument.close();
+
+        log.info("Calculating BodyTextFrame for {}", identifier);
+        bodyTextFrameService.setBodyTextFrames(classificationDocument, layoutParsingType);
+        log.info("Classify TextBlocks for {}", identifier);
         switch (layoutParsingType) {
             case TAAS -> taasClassificationService.classifyDocument(classificationDocument);
             case DOCUMINE -> docuMineClassificationService.classifyDocument(classificationDocument);
             case REDACT_MANAGER -> redactManagerClassificationService.classifyDocument(classificationDocument);
         }
 
+        log.info("Building Sections for {}", identifier);
         sectionsBuilderService.buildSections(classificationDocument);
         sectionsBuilderService.addImagesToSections(classificationDocument);
-
-        return DocumentGraphFactory.buildDocumentGraph(classificationDocument);
+        return classificationDocument;
     }
 
 
-    public Document parseLayoutWithTimer(LayoutParsingType layoutParsingType,
-                                         PDDocument originDocument,
-                                         ImageServiceResponse imageServiceResponse,
-                                         TableServiceResponse tableServiceResponse) {
+    private void addNumberOfPagesToTrace(int numberOfPages, long size) {
 
-        long start = System.currentTimeMillis();
-
-        ClassificationDocument classificationDocument = pdfParsingService.parseDocument(layoutParsingType,
-                originDocument,
-                cvTableParsingAdapter.buildCvParsedTablesPerPage(tableServiceResponse),
-                imageServiceResponseAdapter.buildClassifiedImagesPerPage(imageServiceResponse));
-
-        System.out.printf("parsed %d ms", System.currentTimeMillis() - start);
-
-        start = System.currentTimeMillis();
-        switch (layoutParsingType) {
-            case TAAS -> taasClassificationService.classifyDocument(classificationDocument);
-            case DOCUMINE -> docuMineClassificationService.classifyDocument(classificationDocument);
-            case REDACT_MANAGER -> redactManagerClassificationService.classifyDocument(classificationDocument);
+        if (observationRegistry.getCurrentObservation() != null) {
+            observationRegistry.getCurrentObservation().highCardinalityKeyValue("numberOfPages", String.valueOf(numberOfPages));
+            observationRegistry.getCurrentObservation().highCardinalityKeyValue("fileSize", String.valueOf(size));
         }
-        System.out.printf(", classified %d ms", System.currentTimeMillis() - start);
+    }
 
-        start = System.currentTimeMillis();
-        sectionsBuilderService.buildSections(classificationDocument);
-        System.out.printf(", sections built %d ms", System.currentTimeMillis() - start);
 
-        start = System.currentTimeMillis();
-        Document document = DocumentGraphFactory.buildDocumentGraph(classificationDocument);
-        System.out.printf(", graph constructed %d ms", System.currentTimeMillis() - start);
+    @SneakyThrows
+    private PDDocument openDocument(File originFile) {
+
+        PDDocument document = Loader.loadPDF(originFile);
+        document.setAllSecurityToBeRemoved(true);
         return document;
     }
 
+
+    private Map<String, List<Rectangle2D>> convertMarkedContents(List<PDMarkedContent> pdMarkedContents) {
+
+        Map<String, List<Rectangle2D>> markedContentBboxes = new HashMap<>();
+        markedContentBboxes.put(MarkedContentUtils.HEADER, MarkedContentUtils.getMarkedContentBboxPerLine(pdMarkedContents, MarkedContentUtils.HEADER));
+        markedContentBboxes.put(MarkedContentUtils.FOOTER, MarkedContentUtils.getMarkedContentBboxPerLine(pdMarkedContents, MarkedContentUtils.FOOTER));
+        return markedContentBboxes;
+    }
+
+
+    private void increaseDocumentStatistics(ClassificationPage classificationPage, ClassificationDocument document) {
+
+        document.getFontSizeCounter().addAll(classificationPage.getFontSizeCounter().getCountPerValue());
+        document.getFontCounter().addAll(classificationPage.getFontCounter().getCountPerValue());
+        document.getTextHeightCounter().addAll(classificationPage.getTextHeightCounter().getCountPerValue());
+        document.getFontStyleCounter().addAll(classificationPage.getFontStyleCounter().getCountPerValue());
+    }
+
+
+    private void buildPageStatistics(ClassificationPage classificationPage) {
+
+        // Collect all statistics for the classificationPage, except from blocks inside tables, as tables will always be added to BodyTextFrame.
+        for (AbstractPageBlock textBlock : classificationPage.getTextBlocks()) {
+            if (textBlock instanceof TextPageBlock) {
+                if (((TextPageBlock) textBlock).getSequences() == null) {
+                    continue;
+                }
+                for (TextPositionSequence word : ((TextPageBlock) textBlock).getSequences()) {
+                    classificationPage.getTextHeightCounter().add(word.getTextHeight());
+                    classificationPage.getFontCounter().add(word.getFont());
+                    classificationPage.getFontSizeCounter().add(word.getFontSize());
+                    classificationPage.getFontStyleCounter().add(word.getFontStyle());
+                }
+            }
+        }
+
+    }
+
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/LayoutParsingServiceProcessorConfiguration.java

@@ -1,10 +1,24 @@
 package com.knecon.fforesight.service.layoutparser.processor;
 
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
 
+import com.knecon.fforesight.service.viewerdoc.service.ViewerDocumentService;
+
+import io.micrometer.observation.ObservationRegistry;
+
 @Configuration
 @ComponentScan
 public class LayoutParsingServiceProcessorConfiguration {
 
+
+    @Bean
+    @Autowired
+    public ViewerDocumentService viewerDocumentService(ObservationRegistry registry) {
+
+        return new ViewerDocumentService(registry);
+    }
+
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/LayoutParsingStorageService.java

@@ -1,32 +1,32 @@
 package com.knecon.fforesight.service.layoutparser.processor;
 
 import java.io.File;
-import java.io.FileOutputStream;
+import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.Optional;
 
-import org.apache.commons.io.IOUtils;
 import org.apache.pdfbox.Loader;
-import org.apache.pdfbox.io.MemoryUsageSetting;
 import org.apache.pdfbox.pdmodel.PDDocument;
 import org.springframework.stereotype.Service;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.section.SectionGrid;
 import com.iqser.red.storage.commons.service.StorageService;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentPositionData;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentTextData;
 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentData;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentStructure;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentPage;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.SimplifiedText;
 import com.knecon.fforesight.service.layoutparser.internal.api.data.taas.ResearchDocumentData;
 import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingRequest;
 import com.knecon.fforesight.service.layoutparser.processor.python_api.model.image.ImageServiceResponse;
 import com.knecon.fforesight.service.layoutparser.processor.python_api.model.table.TableServiceResponse;
 import com.knecon.fforesight.tenantcommons.TenantContext;
 
+import io.micrometer.observation.annotation.Observed;
 import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 
 @Slf4j
@@ -37,38 +37,50 @@ public class LayoutParsingStorageService {
     private final StorageService storageService;
     private final ObjectMapper objectMapper;
 
+    @Observed(name = "LayoutParsingStorageService", contextualName = "get-origin-file")
+    public File getOriginFile(String storageId) throws IOException {
 
-    public PDDocument getOriginFile(String storageId) throws IOException {
+        File tempFile = createTempFile("document", ".pdf");
+        storageService.downloadTo(TenantContext.getTenantId(), storageId, tempFile);
+        return tempFile;
+    }
 
-        try (var originDocumentInputStream = storageService.getObject(TenantContext.getTenantId(), storageId).getInputStream()) {
-            File tempFile = createTempFile("document", ".pdf");
-            try (var tempFileOutputStream = new FileOutputStream(tempFile)) {
-                IOUtils.copy(originDocumentInputStream, tempFileOutputStream);
-            }
-            return Loader.loadPDF(tempFile, MemoryUsageSetting.setupMixed(67108864L));
+
+    @Observed(name = "LayoutParsingStorageService", contextualName = "get-viewer-doc-file")
+    public Optional<File> getViewerDocFile(String storageId) throws IOException {
+
+        if (!storageService.objectExists(TenantContext.getTenantId(), storageId)) {
+            return Optional.empty();
         }
+        File tempFile = createTempFile("viewerDocument", ".pdf");
+        storageService.downloadTo(TenantContext.getTenantId(), storageId, tempFile);
+        return Optional.of(tempFile);
     }
 
 
     public ImageServiceResponse getImagesFile(String storageId) throws IOException {
 
-        try (InputStream inputStream = storageService.getObject(TenantContext.getTenantId(), storageId).getInputStream()) {
+        try (InputStream inputStream = getObject(storageId)) {
 
-            return objectMapper.readValue(inputStream, ImageServiceResponse.class);
+            ImageServiceResponse imageServiceResponse = objectMapper.readValue(inputStream, ImageServiceResponse.class);
+            inputStream.close();
+            return imageServiceResponse;
         }
     }
 
 
     public TableServiceResponse getTablesFile(String storageId) throws IOException {
 
-        try (var tableClassificationStream = storageService.getObject(TenantContext.getTenantId(), storageId).getInputStream()) {
-
-            return objectMapper.readValue(tableClassificationStream, TableServiceResponse.class);
+        try (var tableClassificationStream = getObject(storageId)) {
 
+            TableServiceResponse tableServiceResponse = objectMapper.readValue(tableClassificationStream, TableServiceResponse.class);
+            tableClassificationStream.close();
+            return tableServiceResponse;
         }
     }
 
 
+    @Observed(name = "LayoutParsingStorageService", contextualName = "store-document-data")
     public void storeDocumentData(LayoutParsingRequest layoutParsingRequest, DocumentData documentData) {
 
         storageService.storeJSONObject(TenantContext.getTenantId(), layoutParsingRequest.structureFileStorageId(), documentData.getDocumentStructure());
@@ -78,38 +90,12 @@ public class LayoutParsingStorageService {
     }
 
 
-    public void storeSectionGrid(LayoutParsingRequest layoutParsingRequest, SectionGrid sectionGrid) {
-
-        storageService.storeJSONObject(TenantContext.getTenantId(), layoutParsingRequest.sectionGridStorageId(), sectionGrid);
-    }
-
-
     public void storeResearchDocumentData(LayoutParsingRequest layoutParsingRequest, ResearchDocumentData researchDocumentData) {
 
         storageService.storeJSONObject(TenantContext.getTenantId(), layoutParsingRequest.researchDocumentStorageId(), researchDocumentData);
     }
 
 
-    public DocumentData readDocumentData(LayoutParsingRequest layoutParsingRequest) throws IOException {
-
-        DocumentPage[] documentPageData = storageService.readJSONObject(TenantContext.getTenantId(), layoutParsingRequest.pageFileStorageId(), DocumentPage[].class);
-        DocumentTextData[] documentTextDataBlockData = storageService.readJSONObject(TenantContext.getTenantId(),
-                layoutParsingRequest.textBlockFileStorageId(),
-                DocumentTextData[].class);
-        DocumentPositionData[] atomicPositionBlockData = storageService.readJSONObject(TenantContext.getTenantId(),
-                layoutParsingRequest.positionBlockFileStorageId(),
-                DocumentPositionData[].class);
-        DocumentStructure tableOfContentsData = storageService.readJSONObject(TenantContext.getTenantId(), layoutParsingRequest.structureFileStorageId(), DocumentStructure.class);
-
-        return DocumentData.builder()
-                .documentStructure(tableOfContentsData)
-                .documentPositions(atomicPositionBlockData)
-                .documentTextData(documentTextDataBlockData)
-                .documentPages(documentPageData)
-                .build();
-    }
-
-
     private File createTempFile(String filenamePrefix, String filenameSuffix) throws IOException {
 
         File tempFile = Files.createTempFile(filenamePrefix, filenameSuffix).toFile();
@@ -134,4 +120,31 @@ public class LayoutParsingStorageService {
         }
     }
 
+
+    @Observed(name = "LayoutParsingStorageService", contextualName = "store-simplified-text")
+    public void storeSimplifiedText(LayoutParsingRequest layoutParsingRequest, SimplifiedText simplifiedText) {
+
+        storageService.storeJSONObject(TenantContext.getTenantId(), layoutParsingRequest.simplifiedTextStorageId(), simplifiedText);
+    }
+
+
+    @SneakyThrows
+    private InputStream getObject(String storageId) {
+
+        File tempFile = File.createTempFile("temp", ".data");
+        storageService.downloadTo(TenantContext.getTenantId(), storageId, tempFile);
+        Path path = Paths.get(tempFile.getPath());
+        return Files.newInputStream(path, StandardOpenOption.DELETE_ON_CLOSE);
+    }
+
+
+    @SneakyThrows
+    @Observed(name = "LayoutParsingStorageService", contextualName = "store-viewer-document")
+    public void storeViewerDocument(LayoutParsingRequest layoutParsingRequest, File out) {
+
+        try (var in = new FileInputStream(out)) {
+            storageService.storeObject(TenantContext.getTenantId(), layoutParsingRequest.viewerDocumentStorageId(), in);
+        }
+    }
+
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/AbstractPageBlock.java

@@ -6,12 +6,14 @@ import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageB
 
 import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 
 @Data
 @AllArgsConstructor
 @NoArgsConstructor
-public abstract class AbstractPageBlock {
+@EqualsAndHashCode(callSuper = true)
+public abstract class AbstractPageBlock extends Rectangle {
 
     @JsonIgnore
     protected float minX;
@@ -72,9 +74,30 @@ public abstract class AbstractPageBlock {
     }
 
 
-    public boolean intersectsY(AbstractPageBlock atc) {
+    public boolean intersectsY(AbstractPageBlock apb) {
 
-        return this.minY <= atc.getMaxY() && this.maxY >= atc.getMinY();
+        return this.minY <= apb.getMaxY() && this.maxY >= apb.getMinY();
     }
 
+
+    public boolean almostIntersects(AbstractPageBlock apb, float yThreshold, float xThreshold) {
+
+        return this.almostIntersectsX(apb, xThreshold) && this.almostIntersectsY(apb, yThreshold);
+    }
+
+
+    private boolean almostIntersectsY(AbstractPageBlock apb, float threshold) {
+
+        return this.minY - threshold <= apb.getMaxY() && this.maxY + threshold >= apb.getMinY();
+    }
+
+
+    private boolean almostIntersectsX(AbstractPageBlock apb, float threshold) {
+
+        return this.minX - threshold <= apb.getMaxX() && this.maxX + threshold >= apb.getMinX();
+    }
+
+
+    public abstract boolean isEmpty();
+
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/ClassificationDocument.java

@@ -3,7 +3,6 @@ package com.knecon.fforesight.service.layoutparser.processor.model;
 import java.util.ArrayList;
 import java.util.List;
 
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.section.SectionGrid;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.StringFrequencyCounter;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.UnclassifiedText;
 
@@ -25,7 +24,6 @@ public class ClassificationDocument {
     private StringFrequencyCounter fontStyleCounter = new StringFrequencyCounter();
     private boolean headlines;
 
-    private SectionGrid sectionGrid = new SectionGrid();
     private long rulesVersion;
 
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/ClassificationPage.java

@@ -1,15 +1,20 @@
 package com.knecon.fforesight.service.layoutparser.processor.model;
 
+import java.awt.geom.Rectangle2D;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Rectangle;
 import com.knecon.fforesight.service.layoutparser.processor.model.image.ClassifiedImage;
+import com.knecon.fforesight.service.layoutparser.processor.model.table.CleanRulings;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.StringFrequencyCounter;
 
 import lombok.Data;
 import lombok.NonNull;
 import lombok.RequiredArgsConstructor;
+import org.apache.pdfbox.pdmodel.documentinterchange.markedcontent.PDMarkedContent;
 
 @Data
 @RequiredArgsConstructor
@@ -35,4 +40,8 @@ public class ClassificationPage {
     private float pageWidth;
     private float pageHeight;
 
+    CleanRulings cleanRulings;
+
+    private Map<String, List<Rectangle2D>> markedContentBboxPerType = new HashMap<>();
+
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/ClassificationSection.java

@@ -2,6 +2,7 @@ package com.knecon.fforesight.service.layoutparser.processor.model;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import com.knecon.fforesight.service.layoutparser.processor.model.image.ClassifiedImage;
 import com.knecon.fforesight.service.layoutparser.processor.model.table.TablePageBlock;
@@ -29,4 +30,10 @@ public class ClassificationSection {
         return tables;
     }
 
+
+    public List<AbstractPageBlock> getNonEmptyPageBlocks() {
+
+        return pageBlocks.stream().filter(pageBlock -> !pageBlock.isEmpty()).collect(Collectors.toList());
+    }
+
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/PageContents.java

@@ -3,6 +3,7 @@ package com.knecon.fforesight.service.layoutparser.processor.model;
 import java.awt.geom.Rectangle2D;
 import java.util.List;
 
+import com.knecon.fforesight.service.layoutparser.processor.model.table.Ruling;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
 
 import lombok.AllArgsConstructor;
@@ -17,5 +18,5 @@ public class PageContents {
     List<TextPositionSequence> sortedTextPositionSequences;
     Rectangle2D cropBox;
     Rectangle2D mediaBox;
-
+    List<Ruling> rulings;
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/graph/Boundary.java

@@ -12,6 +12,7 @@ import lombok.Setter;
 
 @Setter
 @EqualsAndHashCode
+@SuppressWarnings("PMD.AvoidFieldNameMatchingMethodName")
 public class Boundary implements Comparable<Boundary> {
 
     private int start;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/graph/nodes/Document.java

@@ -10,7 +10,6 @@ import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import com.amazonaws.services.kms.model.NotFoundException;
 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.DocumentTree;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.entity.RedactionEntity;
@@ -84,7 +83,7 @@ public class Document implements GenericSemanticNode {
     @Override
     public Headline getHeadline() {
 
-        return streamAllSubNodesOfType(NodeType.HEADLINE).map(node -> (Headline) node).findFirst().orElseThrow(() -> new NotFoundException("No Headlines found in this document!"));
+        return streamAllSubNodesOfType(NodeType.HEADLINE).map(node -> (Headline) node).findFirst().orElse(Headline.builder().build());
     }
 
 
@@ -100,6 +99,12 @@ public class Document implements GenericSemanticNode {
     }
 
 
+    public Map<NodeType, Long> buildSemanticNodeCounts() {
+
+        return streamAllSubNodes().collect(Collectors.groupingBy(SemanticNode::getType, Collectors.counting()));
+    }
+
+
     @Override
     public String toString() {
 

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/graph/nodes/Footer.java

@@ -1,7 +1,9 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes;
 
+import java.awt.geom.Rectangle2D;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
@@ -34,6 +36,9 @@ public class Footer implements GenericSemanticNode {
     @EqualsAndHashCode.Exclude
     Set<RedactionEntity> entities = new HashSet<>();
 
+    @EqualsAndHashCode.Exclude
+    Map<Page, Rectangle2D> bBoxCache;
+
 
     @Override
     public NodeType getType() {
@@ -62,4 +67,14 @@ public class Footer implements GenericSemanticNode {
         return treeId + ": " + NodeType.FOOTER + ": " + leafTextBlock.buildSummary();
     }
 
+
+    @Override
+    public Map<Page, Rectangle2D> getBBox() {
+
+        if (bBoxCache == null) {
+            bBoxCache = GenericSemanticNode.super.getBBox();
+        }
+        return bBoxCache;
+    }
+
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/graph/nodes/Header.java

@@ -1,7 +1,9 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes;
 
+import java.awt.geom.Rectangle2D;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
@@ -34,6 +36,9 @@ public class Header implements GenericSemanticNode {
     @EqualsAndHashCode.Exclude
     Set<RedactionEntity> entities = new HashSet<>();
 
+    @EqualsAndHashCode.Exclude
+    Map<Page, Rectangle2D> bBoxCache;
+
 
     @Override
     public boolean isLeaf() {
@@ -62,4 +67,14 @@ public class Header implements GenericSemanticNode {
         return treeId + ": " + NodeType.HEADER + ": " + leafTextBlock.buildSummary();
     }
 
+
+    @Override
+    public Map<Page, Rectangle2D> getBBox() {
+
+        if (bBoxCache == null) {
+            bBoxCache = GenericSemanticNode.super.getBBox();
+        }
+        return bBoxCache;
+    }
+
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/graph/nodes/Headline.java

@@ -1,7 +1,9 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes;
 
+import java.awt.geom.Rectangle2D;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
@@ -34,6 +36,9 @@ public class Headline implements GenericSemanticNode {
     @EqualsAndHashCode.Exclude
     Set<RedactionEntity> entities = new HashSet<>();
 
+    @EqualsAndHashCode.Exclude
+    Map<Page, Rectangle2D> bBoxCache;
+
 
     @Override
     public NodeType getType() {
@@ -69,4 +74,14 @@ public class Headline implements GenericSemanticNode {
         return this;
     }
 
+
+    @Override
+    public Map<Page, Rectangle2D> getBBox() {
+
+        if (bBoxCache == null) {
+            bBoxCache = GenericSemanticNode.super.getBBox();
+        }
+        return bBoxCache;
+    }
+
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/graph/nodes/Paragraph.java

@@ -1,7 +1,9 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes;
 
+import java.awt.geom.Rectangle2D;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
@@ -32,6 +34,9 @@ public class Paragraph implements GenericSemanticNode {
     @EqualsAndHashCode.Exclude
     Set<RedactionEntity> entities = new HashSet<>();
 
+    @EqualsAndHashCode.Exclude
+    Map<Page, Rectangle2D> bBoxCache;
+
 
     @Override
     public NodeType getType() {
@@ -60,4 +65,14 @@ public class Paragraph implements GenericSemanticNode {
         return treeId + ": " + NodeType.PARAGRAPH + ": " + leafTextBlock.buildSummary();
     }
 
+
+    @Override
+    public Map<Page, Rectangle2D> getBBox() {
+
+        if (bBoxCache == null) {
+            bBoxCache = GenericSemanticNode.super.getBBox();
+        }
+        return bBoxCache;
+    }
+
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/graph/nodes/Section.java

@@ -1,7 +1,9 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes;
 
+import java.awt.geom.Rectangle2D;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
@@ -35,6 +37,9 @@ public class Section implements GenericSemanticNode {
     @EqualsAndHashCode.Exclude
     Set<RedactionEntity> entities = new HashSet<>();
 
+    @EqualsAndHashCode.Exclude
+    Map<Page, Rectangle2D> bBoxCache;
+
 
     @Override
     public NodeType getType() {
@@ -74,4 +79,14 @@ public class Section implements GenericSemanticNode {
                 .orElseGet(() -> getParent().getHeadline());
     }
 
+
+    @Override
+    public Map<Page, Rectangle2D> getBBox() {
+
+        if (bBoxCache == null) {
+            bBoxCache = GenericSemanticNode.super.getBBox();
+        }
+        return bBoxCache;
+    }
+
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/graph/nodes/SemanticNode.java

@@ -398,12 +398,11 @@ public interface SemanticNode {
      */
     default Map<Page, Rectangle2D> getBBox() {
 
-        Map<Page, Rectangle2D> bBoxPerPage = new HashMap<>();
         if (isLeaf()) {
-            return getBBoxFromLeafTextBlock(bBoxPerPage);
+            return getBBoxFromLeafTextBlock();
         }
 
-        return getBBoxFromChildren(bBoxPerPage);
+        return getBBoxFromChildren();
     }
 
 
@@ -426,25 +425,31 @@ public interface SemanticNode {
 
     /**
      * TODO: this produces unwanted results for sections spanning multiple columns.
-     *
-     * @param bBoxPerPage initial empty BoundingBox
+     * Computes the Union of the bounding boxes of all children recursively.
      * @return The union of the BoundingBoxes of all children
      */
-    private Map<Page, Rectangle2D> getBBoxFromChildren(Map<Page, Rectangle2D> bBoxPerPage) {
+    private Map<Page, Rectangle2D> getBBoxFromChildren() {
 
-        return streamChildren().map(SemanticNode::getBBox).reduce((map1, map2) -> {
-            map1.forEach((page, rectangle) -> map2.merge(page, rectangle, (rect1, rect2) -> rect1.createUnion(rect2).getBounds2D()));
-            return map2;
-        }).orElse(bBoxPerPage);
+        Map<Page, Rectangle2D> bBoxPerPage = new HashMap<>();
+        List<Map<Page, Rectangle2D>> childrenBBoxes = streamChildren().map(SemanticNode::getBBox).toList();
+        Set<Page> pages = childrenBBoxes.stream().flatMap(map -> map.keySet().stream()).collect(Collectors.toSet());
+        for (Page page : pages) {
+            Rectangle2D bBoxOnPage = childrenBBoxes.stream()
+                    .filter(childBboxPerPage -> childBboxPerPage.containsKey(page))
+                    .map(childBboxPerPage -> childBboxPerPage.get(page))
+                    .collect(RectangleTransformations.collectBBox());
+            bBoxPerPage.put(page, bBoxOnPage);
+        }
+        return bBoxPerPage;
     }
 
 
     /**
-     * @param bBoxPerPage initial empty BoundingBox
      * @return The union of all BoundingBoxes of the TextBlock of this node
      */
-    private Map<Page, Rectangle2D> getBBoxFromLeafTextBlock(Map<Page, Rectangle2D> bBoxPerPage) {
+    private Map<Page, Rectangle2D> getBBoxFromLeafTextBlock() {
 
+        Map<Page, Rectangle2D> bBoxPerPage = new HashMap<>();
         Map<Page, List<AtomicTextBlock>> atomicTextBlockPerPage = getTextBlock().getAtomicTextBlocks().stream().collect(Collectors.groupingBy(AtomicTextBlock::getPage));
         atomicTextBlockPerPage.forEach((page, atbs) -> bBoxPerPage.put(page, RectangleTransformations.bBoxUnionAtomicTextBlock(atbs)));
         return bBoxPerPage;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/graph/nodes/Table.java

@@ -2,10 +2,12 @@ package com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes;
 
 import static java.lang.String.format;
 
+import java.awt.geom.Rectangle2D;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import java.util.Set;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
@@ -34,13 +36,14 @@ public class Table implements SemanticNode {
 
     int numberOfRows;
     int numberOfCols;
-
     TextBlock textBlock;
 
     @Builder.Default
     @EqualsAndHashCode.Exclude
     Set<RedactionEntity> entities = new HashSet<>();
 
+    @EqualsAndHashCode.Exclude
+    Map<Page, Rectangle2D> bBoxCache;
 
     /**
      * Streams all entities in this table, that appear in a row, which contains any of the provided strings.
@@ -208,7 +211,6 @@ public class Table implements SemanticNode {
         return IntStream.range(0, numberOfCols).boxed().map(col -> getCell(row, col));
     }
 
-
     /**
      * Streams all TableCells row-wise and filters them with header == true.
      *
@@ -313,5 +315,12 @@ public class Table implements SemanticNode {
 
         return treeId.toString() + ": " + NodeType.TABLE + ": #cols: " + numberOfCols + ", #rows: " + numberOfRows + ", " + this.getTextBlock().buildSummary();
     }
+    @Override
+    public Map<Page, Rectangle2D> getBBox() {
 
+        if (bBoxCache == null) {
+            bBoxCache = SemanticNode.super.getBBox();
+        }
+        return bBoxCache;
+    }
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/graph/nodes/TableCell.java

@@ -76,12 +76,20 @@ public class TableCell implements GenericSemanticNode {
         }
 
         if (textBlock == null) {
-            textBlock = streamAllSubNodes().filter(SemanticNode::isLeaf).map(SemanticNode::getLeafTextBlock).collect(new TextBlockCollector());
+            textBlock = buildTextBlock();
         }
         return textBlock;
     }
 
 
+    private TextBlock buildTextBlock() {
+
+        return streamAllSubNodes().filter(SemanticNode::isLeaf)
+                .map(SemanticNode::getLeafTextBlock)
+                .collect(new TextBlockCollector());
+    }
+
+
     @Override
     public String toString() {
 

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/table/Cell.java

@@ -1,6 +1,7 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.table;
 
 import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
@@ -36,6 +37,12 @@ public class Cell extends Rectangle {
     }
 
 
+    public Cell(Rectangle2D r) {
+
+        super((float) r.getY(), (float) r.getX(), (float) r.getWidth(), (float) r.getHeight());
+    }
+
+
     public void addTextBlock(TextPageBlock textBlock) {
 
         textBlocks.add(textBlock);

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/table/Ruling.java

@@ -20,7 +20,8 @@ import lombok.extern.slf4j.Slf4j;
 @SuppressWarnings("all")
 public class Ruling extends Line2D.Float {
 
-    private static int PERPENDICULAR_PIXEL_EXPAND_AMOUNT = 2;
+    public static final int PERPENDICULAR_UNIT_EXPAND_AMOUNT = 2;
+    public static final int COLINEAR_OR_PARALLEL_UNIT_EXPAND_AMOUNT = 2;
 
 
     public Ruling(Point2D p1, Point2D p2) {
@@ -28,6 +29,7 @@ public class Ruling extends Line2D.Float {
         super(p1, p2);
     }
 
+
     public Ruling straightenVertical() {
 
         double y1 = Math.min(getY1(), getY2());
@@ -36,6 +38,7 @@ public class Ruling extends Line2D.Float {
         return new Ruling(new Point2D.Double(x, y1), new Point2D.Double(x, y2));
     }
 
+
     public Ruling straightenHorizontal() {
 
         double x1 = Math.min(getX1(), getX2());
@@ -108,8 +111,8 @@ public class Ruling extends Line2D.Float {
         });
 
         for (Ruling h : horizontals) {
-            sos.add(new SortObject(SOType.HLEFT, h.getLeft() - PERPENDICULAR_PIXEL_EXPAND_AMOUNT, h));
-            sos.add(new SortObject(SOType.HRIGHT, h.getRight() + PERPENDICULAR_PIXEL_EXPAND_AMOUNT, h));
+            sos.add(new SortObject(SOType.HLEFT, h.getLeft() - PERPENDICULAR_UNIT_EXPAND_AMOUNT, h));
+            sos.add(new SortObject(SOType.HRIGHT, h.getRight() + PERPENDICULAR_UNIT_EXPAND_AMOUNT, h));
         }
 
         for (Ruling v : verticals) {
@@ -149,7 +152,7 @@ public class Ruling extends Line2D.Float {
                             if (i == null) {
                                 continue;
                             }
-                            rv.put(i, new Ruling[]{h.getKey().expand(PERPENDICULAR_PIXEL_EXPAND_AMOUNT), so.ruling.expand(PERPENDICULAR_PIXEL_EXPAND_AMOUNT)});
+                            rv.put(i, new Ruling[]{h.getKey().expand(PERPENDICULAR_UNIT_EXPAND_AMOUNT), so.ruling.expand(PERPENDICULAR_UNIT_EXPAND_AMOUNT)});
                         } catch (UnsupportedOperationException e) {
                             log.info("Some line are oblique, ignoring...");
                             continue;
@@ -265,7 +268,7 @@ public class Ruling extends Line2D.Float {
     }
 
 
-    public boolean nearlyIntersects(Ruling another, int colinearOrParallelExpandAmount) {
+    public boolean nearlyIntersects(Ruling another) {
 
         if (this.intersectsLine(another)) {
             return true;
@@ -274,9 +277,9 @@ public class Ruling extends Line2D.Float {
         boolean rv = false;
 
         if (this.perpendicularTo(another)) {
-            rv = this.expand(PERPENDICULAR_PIXEL_EXPAND_AMOUNT).intersectsLine(another);
+            rv = this.expand(PERPENDICULAR_UNIT_EXPAND_AMOUNT).intersectsLine(another);
         } else {
-            rv = this.expand(colinearOrParallelExpandAmount).intersectsLine(another.expand(colinearOrParallelExpandAmount));
+            rv = this.expand(COLINEAR_OR_PARALLEL_UNIT_EXPAND_AMOUNT).intersectsLine(another.expand(COLINEAR_OR_PARALLEL_UNIT_EXPAND_AMOUNT));
         }
 
         return rv;
@@ -317,8 +320,8 @@ public class Ruling extends Line2D.Float {
 
     public Point2D intersectionPoint(Ruling other) {
 
-        Ruling this_l = this.expand(PERPENDICULAR_PIXEL_EXPAND_AMOUNT);
-        Ruling other_l = other.expand(PERPENDICULAR_PIXEL_EXPAND_AMOUNT);
+        Ruling this_l = this.expand(PERPENDICULAR_UNIT_EXPAND_AMOUNT);
+        Ruling other_l = other.expand(PERPENDICULAR_UNIT_EXPAND_AMOUNT);
         Ruling horizontal, vertical;
 
         if (!this_l.intersectsLine(other_l)) {
@@ -444,6 +447,16 @@ public class Ruling extends Line2D.Float {
     }
 
 
+    public boolean almostMatches(Ruling ruling) {
+
+        final float TOLERANCE = 1;
+        return Math.abs(ruling.getX1() - x1) < TOLERANCE &&//
+                Math.abs(ruling.getY1() - y1) < TOLERANCE &&//
+                Math.abs(ruling.getX2() - x2) < TOLERANCE &&//
+                Math.abs(ruling.getY2() - y2) < TOLERANCE;
+    }
+
+
     private enum SOType {
         VERTICAL,
         HRIGHT,

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/table/TablePageBlock.java

@@ -3,6 +3,7 @@ package com.knecon.fforesight.service.layoutparser.processor.model.table;
 import java.awt.geom.Point2D;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -11,6 +12,7 @@ import java.util.TreeMap;
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.PageBlockType;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
+import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
 
 import lombok.Getter;
 import lombok.Setter;
@@ -19,7 +21,8 @@ import lombok.extern.slf4j.Slf4j;
 @Slf4j
 public class TablePageBlock extends AbstractPageBlock {
 
-    private final TreeMap<CellPosition, Cell> cells = new TreeMap<>();
+    public static final double CELL_AREA_CONTAINED_THRESHOLD = 0.98;
+    private final TreeMap<CellPosition, Cell> cellTreeMap = new TreeMap<>();
 
     private final int rotation;
     @Getter
@@ -28,10 +31,14 @@ public class TablePageBlock extends AbstractPageBlock {
     private int unrotatedRowCount;
     private int unrotatedColCount;
     private List<List<Cell>> rows;
+    @Getter
+    @Setter
+    private List<Cell> cells;
 
 
     public TablePageBlock(List<Cell> cells, Rectangle area, int rotation) {
 
+        this.cells = cells;
         addCells(cells);
         minX = area.getLeft();
         minY = area.getBottom();
@@ -42,6 +49,13 @@ public class TablePageBlock extends AbstractPageBlock {
     }
 
 
+    @Override
+    public boolean isEmpty() {
+
+        return getColCount() == 0 || getRowCount() == 0;
+    }
+
+
     public List<List<Cell>> getRows() {
 
         if (rows == null) {
@@ -72,14 +86,17 @@ public class TablePageBlock extends AbstractPageBlock {
 
     public int getColCount() {
 
-        return getRows().stream().mapToInt(List::size).max().orElse(0);
+        return getRows().stream()
+                .mapToInt(List::size)
+                .max()
+                .orElse(0);
 
     }
 
 
     /**
      * Detect header cells (either first row or first column):
-     * Column is marked as header if cell text is bold and row cell text is not bold.
+     * Column is marked as header if originalCell text is bold and row originalCell text is not bold.
      * Defaults to row.
      */
     private void computeHeaders() {
@@ -87,7 +104,7 @@ public class TablePageBlock extends AbstractPageBlock {
         if (rows == null) {
             rows = computeRows();
         }
-        // A bold cell is a header cell as long as every cell to the left/top is bold, too
+        // A bold originalCell is a header originalCell as long as every originalCell to the left/top is bold, too
         // we move from left to right and top to bottom
         for (int rowIndex = 0; rowIndex < rows.size(); rowIndex++) {
             List<Cell> rowCells = rows.get(rowIndex);
@@ -112,7 +129,8 @@ public class TablePageBlock extends AbstractPageBlock {
                 List<Cell> cellsToTheTop = new ArrayList<>();
                 for (int i = 0; i < rowIndex; i++) {
                     try {
-                        cellsToTheTop.add(rows.get(i).get(colIndex));
+                        cellsToTheTop.add(rows.get(i)
+                                                  .get(colIndex));
                     } catch (IndexOutOfBoundsException e) {
                         log.debug("No cell {} in row {}, ignoring.", colIndex, rowIndex);
                     }
@@ -127,7 +145,8 @@ public class TablePageBlock extends AbstractPageBlock {
                 if (lastHeaderCell != null) {
                     cell.getHeaderCells().add(lastHeaderCell);
                 }
-                if (!cell.getTextBlocks().isEmpty() && cell.getTextBlocks().get(0).getMostPopularWordStyle().equals("bold")) {
+                if (!cell.getTextBlocks().isEmpty() && cell.getTextBlocks()
+                        .get(0).getMostPopularWordStyle().equals("bold")) {
                     cell.setHeaderCell(true);
                 }
             }
@@ -143,7 +162,7 @@ public class TablePageBlock extends AbstractPageBlock {
             for (int i = 0; i < unrotatedColCount; i++) { // rows
                 List<Cell> lastRow = new ArrayList<>();
                 for (int j = unrotatedRowCount - 1; j >= 0; j--) { // cols
-                    Cell cell = cells.get(new CellPosition(j, i));
+                    Cell cell = cellTreeMap.get(new CellPosition(j, i));
                     if (cell != null) {
                         lastRow.add(cell);
                     }
@@ -154,7 +173,7 @@ public class TablePageBlock extends AbstractPageBlock {
             for (int i = unrotatedColCount - 1; i >= 0; i--) { // rows
                 List<Cell> lastRow = new ArrayList<>();
                 for (int j = 0; j < unrotatedRowCount; j++) { // cols
-                    Cell cell = cells.get(new CellPosition(j, i));
+                    Cell cell = cellTreeMap.get(new CellPosition(j, i));
                     if (cell != null) {
                         lastRow.add(cell);
                     }
@@ -165,7 +184,7 @@ public class TablePageBlock extends AbstractPageBlock {
             for (int i = 0; i < unrotatedRowCount; i++) {
                 List<Cell> lastRow = new ArrayList<>();
                 for (int j = 0; j < unrotatedColCount; j++) {
-                    Cell cell = cells.get(new CellPosition(i, j)); // JAVA_8 use getOrDefault()
+                    Cell cell = cellTreeMap.get(new CellPosition(i, j)); // JAVA_8 use getOrDefault()
                     if (cell != null) {
                         lastRow.add(cell);
                     }
@@ -179,17 +198,6 @@ public class TablePageBlock extends AbstractPageBlock {
     }
 
 
-    private void add(Cell chunk, int row, int col) {
-
-        unrotatedRowCount = Math.max(unrotatedRowCount, row + 1);
-        unrotatedColCount = Math.max(unrotatedColCount, col + 1);
-
-        CellPosition cp = new CellPosition(row, col);
-        cells.put(cp, chunk);
-
-    }
-
-
     private void addCells(List<Cell> cells) {
 
         if (cells.isEmpty()) {
@@ -198,11 +206,12 @@ public class TablePageBlock extends AbstractPageBlock {
 
         cells.removeIf(cell -> cell.getWidth() < 1.1 || cell.getHeight() < 1.1);
 
-        List<List<Cell>> rowsOfCells = calculateStructure(cells);
+        List<List<Cell>> rowsOfCellsMatrix = calculateTableStructure(cells);
 
-        for (int i = 0; i < rowsOfCells.size(); i++) {
-            for (int j = 0; j < rowsOfCells.get(i).size(); j++) {
-                add(rowsOfCells.get(i).get(j), i, j);
+        for (int i = 0; i < rowsOfCellsMatrix.size(); i++) {
+            for (int j = 0; j < rowsOfCellsMatrix.get(i).size(); j++) {
+                addCellToRowAndCol(rowsOfCellsMatrix.get(i)
+                                           .get(j), i, j);
             }
         }
 
@@ -213,29 +222,36 @@ public class TablePageBlock extends AbstractPageBlock {
      * Calculates the structure of the table. For spanning rows and columns multiple cells with the same values will be inserted.
      *
      * @param cells The found cells
-     * @return TablePageBlock Structure
+     * @return TablePageBlock Structure as a rows of cells matrix
      */
-    private List<List<Cell>> calculateStructure(List<Cell> cells) {
-
-        List<List<Cell>> matrix = new ArrayList<>();
+    private List<List<Cell>> calculateTableStructure(List<Cell> cells) {
 
         if (cells.isEmpty()) {
-            return matrix;
+            return new ArrayList<>();
         }
 
         Set<Float> uniqueX = new HashSet<>();
         Set<Float> uniqueY = new HashSet<>();
-        cells.stream().filter(c -> !c.getTextBlocks().isEmpty() || c.getHeight() > 3 && c.getWidth() > 3).forEach(c -> {
-            uniqueX.add(c.getLeft());
-            uniqueX.add(c.getRight());
-            uniqueY.add(c.getBottom());
-            uniqueY.add(c.getTop());
-        });
+        cells.stream()
+                .filter(c -> !c.getTextBlocks().isEmpty() || c.getHeight() > 3 && c.getWidth() > 3)
+                .forEach(c -> {
+                    uniqueX.add(c.getLeft());
+                    uniqueX.add(c.getRight());
+                    uniqueY.add(c.getBottom());
+                    uniqueY.add(c.getTop());
+                });
 
-        var sortedUniqueX = uniqueX.stream().sorted().toList();
-        var sortedUniqueY = uniqueY.stream().sorted().toList();
+        var sortedUniqueX = uniqueX.stream()
+                .sorted()
+                .toList();
+        var sortedUniqueY = uniqueY.stream()
+                .sorted()
+                .toList();
+
+        List<List<Cell>> rowsOfCells = new ArrayList<>();
 
         Float prevY = null;
+
         for (Float y : sortedUniqueY) {
 
             List<Cell> row = new ArrayList<>();
@@ -244,26 +260,85 @@ public class TablePageBlock extends AbstractPageBlock {
             for (Float x : sortedUniqueX) {
 
                 if (prevY != null && prevX != null) {
-                    var cell = new Cell(new Point2D.Float(prevX, prevY), new Point2D.Float(x, y));
+                    var cellFromGridStructure = new Cell(new Point2D.Float(prevX, prevY), new Point2D.Float(x, y));
 
-                    var intersectionCell = cells.stream().filter(c -> cell.intersects(c) && cell.overlapRatio(c) > 0.1f).findFirst();
-                    intersectionCell.ifPresent(value -> cell.getTextBlocks().addAll(value.getTextBlocks()));
-                    if (cell.hasMinimumSize()) {
-                        row.add(cell);
+                    if (cellFromGridStructure.hasMinimumSize()) {
+
+                        cells.stream()
+                                .map(originalCell -> new CellWithIntersection(originalCell, RectangleTransformations.calculateIntersectedArea(cellFromGridStructure, originalCell)))
+                                .filter(cellWithIntersection -> cellWithIntersection.intersectedArea > 0)
+                                .filter(cellWithIntersection -> cellWithIntersection.originalCell.getArea() > cellWithIntersection.intersectedArea * CELL_AREA_CONTAINED_THRESHOLD)
+                                .max(Comparator.comparing(CellWithIntersection::intersectedArea))
+                                .map(CellWithIntersection::originalCell)
+                                .ifPresent(matchingCell -> cellFromGridStructure.getTextBlocks().addAll(matchingCell.getTextBlocks()));
+
+                        row.add(cellFromGridStructure);
                     }
                 }
                 prevX = x;
             }
 
-            if (prevY != null && prevX != null && !row.isEmpty()) {
-                matrix.add(row);
+            // exclude empty rows and rows where all text blocks are empty
+            if (prevY != null && prevX != null && !row.isEmpty() && !row.stream()
+                    .allMatch(cell -> cell.getTextBlocks().isEmpty())) {
+
+                rowsOfCells.add(row);
             }
             prevY = y;
         }
 
-        Collections.reverse(matrix);
+        Collections.reverse(rowsOfCells);
+
+        // now cells are removed which are part of a column without any text blocks
+        // this is done by first computing the inverse matrix which contains call columns of cells
+        // then the column indices that have to be removed are determined
+        List<List<Cell>> columnsOfCells = new ArrayList<>();
+        int maxRowLength = rowsOfCells.stream()
+                .map(List::size)
+                .max(java.util.Comparator.naturalOrder())
+                .orElse(0);
+        for (int i = 0; i < maxRowLength; i++) {
+            columnsOfCells.add(new ArrayList<>());
+        }
+
+        for (List<Cell> row : rowsOfCells) {
+            for (int j = 0; j < row.size(); j++) {
+                columnsOfCells.get(j).add(row.get(j));
+            }
+        }
+
+        List<Integer> columnIndicesToRemove = new ArrayList<>();
+        int columnIndex = 0;
+        for (List<Cell> col : columnsOfCells) {
+            if (col.stream()
+                    .allMatch(cell -> cell.getTextBlocks().isEmpty())) {
+                columnIndicesToRemove.add(columnIndex);
+            }
+            columnIndex++;
+        }
+        columnIndicesToRemove.sort(Collections.reverseOrder());
+
+        // update all rows so that the values of the empty columns get removed
+        var rowsOfCellsBefore = new ArrayList<>(rowsOfCells);
+        rowsOfCells = new ArrayList<>();
+        for (List<Cell> row : rowsOfCellsBefore) {
+            var updatedRow = new ArrayList<>(row);
+            columnIndicesToRemove.forEach(idxToRemove -> updatedRow.remove(updatedRow.get(idxToRemove)));
+            rowsOfCells.add(updatedRow);
+        }
+
+        return rowsOfCells;
+    }
+
+
+    private void addCellToRowAndCol(Cell cell, int row, int col) {
+
+        unrotatedRowCount = Math.max(unrotatedRowCount, row + 1);
+        unrotatedColCount = Math.max(unrotatedColCount, col + 1);
+
+        CellPosition cp = new CellPosition(row, col);
+        cellTreeMap.put(cp, cell);
 
-        return matrix;
     }
 
 
@@ -290,7 +365,7 @@ public class TablePageBlock extends AbstractPageBlock {
                             if (!first) {
                                 sb.append("\n");
                             }
-                            sb.append('\"').append(textBlock.getText().replaceAll("\"", "\\\"")).append('\"');
+                            sb.append('\"').append(textBlock.getText().replaceAll("\"", "\"")).append('\"');
                             first = false;
                         }
                     }
@@ -337,4 +412,9 @@ public class TablePageBlock extends AbstractPageBlock {
         return sb.toString();
     }
 
+
+    record CellWithIntersection(Cell originalCell, double intersectedArea) {
+
+    }
+
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/text/RedTextPosition.java

@@ -1,7 +1,6 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.text;
 
 import org.apache.pdfbox.text.TextPosition;
-import org.springframework.beans.BeanUtils;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 
@@ -17,7 +16,6 @@ import lombok.SneakyThrows;
 @AllArgsConstructor
 public class RedTextPosition {
 
-    private String textMatrix;
     private float[] position;
 
     @JsonIgnore
@@ -51,13 +49,17 @@ public class RedTextPosition {
     public static RedTextPosition fromTextPosition(TextPosition textPosition) {
 
         var pos = new RedTextPosition();
-        BeanUtils.copyProperties(textPosition, pos);
+        pos.setRotation(textPosition.getRotation());
+        pos.setPageHeight(textPosition.getPageHeight());
+        pos.setPageWidth(textPosition.getPageWidth());
+        pos.setUnicode(textPosition.getUnicode());
+        pos.setDir(textPosition.getDir());
+        pos.setWidthOfSpace(textPosition.getWidthOfSpace());
+        pos.setFontSizeInPt(textPosition.getFontSizeInPt());
         pos.setFontName(textPosition.getFont().getName());
 
         pos.setFontSizeInPt(textPosition.getFontSizeInPt());
 
-        pos.setTextMatrix(textPosition.getTextMatrix().toString());
-
         var position = new float[4];
 
         position[0] = textPosition.getXDirAdj();

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/text/SimplifiedSectionText.java

@@ -1,17 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.model.text;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class SimplifiedSectionText {
-
-    private int sectionNumber;
-    private String text;
-
-}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/text/SimplifiedText.java

@@ -1,20 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.model.text;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class SimplifiedText {
-
-    private int numberOfPages;
-    private List<SimplifiedSectionText> sectionTexts = new ArrayList<>();
-
-}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/text/TextPageBlock.java

@@ -73,6 +73,7 @@ public class TextPageBlock extends AbstractPageBlock {
 
         return sequences.get(0).getPageWidth();
     }
+    
 
     public static TextPageBlock merge(List<TextPageBlock> textBlocksToMerge) {
 
@@ -364,4 +365,11 @@ public class TextPageBlock extends AbstractPageBlock {
 
     }
 
+
+    @Override
+    public boolean isEmpty() {
+
+        return sequences.isEmpty();
+    }
+
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/model/text/TextPositionSequence.java

@@ -9,8 +9,6 @@ import java.util.stream.Collectors;
 
 import org.apache.pdfbox.text.TextPosition;
 
-import com.dslplatform.json.JsonAttribute;
-import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Point;
 import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Rectangle;
 
@@ -142,8 +140,7 @@ public class TextPositionSequence implements CharSequence {
      *
      * @return the text direction adjusted minX value
      */
-    @JsonIgnore
-    @JsonAttribute(ignore = true)
+
     public float getMinXDirAdj() {
 
         return textPositions.get(0).getXDirAdj();
@@ -157,8 +154,7 @@ public class TextPositionSequence implements CharSequence {
      *
      * @return the text direction adjusted maxX value
      */
-    @JsonIgnore
-    @JsonAttribute(ignore = true)
+
     public float getMaxXDirAdj() {
 
         return textPositions.get(textPositions.size() - 1).getXDirAdj() + textPositions.get(textPositions.size() - 1).getWidthDirAdj() + HEIGHT_PADDING;
@@ -172,8 +168,7 @@ public class TextPositionSequence implements CharSequence {
      *
      * @return the text direction adjusted minY value. The upper border of the bounding box of the word.
      */
-    @JsonIgnore
-    @JsonAttribute(ignore = true)
+
     public float getMinYDirAdj() {
 
         return textPositions.get(0).getYDirAdj() - getTextHeight();
@@ -187,8 +182,7 @@ public class TextPositionSequence implements CharSequence {
      *
      * @return the text direction adjusted maxY value. The lower border of the bounding box of the word.
      */
-    @JsonIgnore
-    @JsonAttribute(ignore = true)
+
     public float getMaxYDirAdj() {
 
         return textPositions.get(0).getYDirAdj();
@@ -196,42 +190,38 @@ public class TextPositionSequence implements CharSequence {
     }
 
 
-    @JsonIgnore
-    @JsonAttribute(ignore = true)
     public float getTextHeight() {
 
         return textPositions.get(0).getHeightDir() + HEIGHT_PADDING;
     }
 
 
-    @JsonIgnore
-    @JsonAttribute(ignore = true)
     public float getHeight() {
 
         return getMaxYDirAdj() - getMinYDirAdj();
     }
 
 
-    @JsonIgnore
-    @JsonAttribute(ignore = true)
     public float getWidth() {
 
         return getMaxXDirAdj() - getMinXDirAdj();
     }
 
 
-    @JsonIgnore
-    @JsonAttribute(ignore = true)
     public String getFont() {
 
+        if (textPositions.get(0).getFontName() == null) {
+            return "none";
+        }
         return textPositions.get(0).getFontName().toLowerCase(Locale.ROOT).replaceAll(",bold", "").replaceAll(",italic", "");
     }
 
 
-    @JsonIgnore
-    @JsonAttribute(ignore = true)
     public String getFontStyle() {
 
+        if (textPositions.get(0).getFontName() == null) {
+            return "standard";
+        }
         String lowercaseFontName = textPositions.get(0).getFontName().toLowerCase(Locale.ROOT);
 
         if (lowercaseFontName.contains("bold") && lowercaseFontName.contains("italic")) {
@@ -243,20 +233,15 @@ public class TextPositionSequence implements CharSequence {
         } else {
             return "standard";
         }
-
     }
 
 
-    @JsonIgnore
-    @JsonAttribute(ignore = true)
     public float getFontSize() {
 
         return textPositions.get(0).getFontSizeInPt();
     }
 
 
-    @JsonIgnore
-    @JsonAttribute(ignore = true)
     public float getSpaceWidth() {
 
         return textPositions.get(0).getWidthOfSpace();
@@ -272,8 +257,7 @@ public class TextPositionSequence implements CharSequence {
      *
      * @return bounding box of the word in Pdf Coordinate System
      */
-    @JsonIgnore
-    @JsonAttribute(ignore = true)
+
     @SneakyThrows
     public Rectangle getRectangle() {
 

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/adapter/CvTableParsingAdapter.java

@@ -8,6 +8,7 @@ import java.util.Map;
 
 import org.springframework.stereotype.Service;
 
+import com.knecon.fforesight.service.layoutparser.processor.python_api.model.table.PageInfo;
 import com.knecon.fforesight.service.layoutparser.processor.python_api.model.table.TableCells;
 import com.knecon.fforesight.service.layoutparser.processor.python_api.model.table.TableServiceResponse;
 
@@ -24,24 +25,26 @@ public class CvTableParsingAdapter {
         Map<Integer, List<TableCells>> tableCells = new HashMap<>();
         tableServiceResponse.getData()
                 .forEach(tableData -> tableCells.computeIfAbsent(tableData.getPageInfo().getNumber(), tableCell -> new ArrayList<>())
-                        .addAll(convertTableCells(tableData.getTableCells())));
+                        .addAll(convertTableCells(tableData.getTableCells(), tableData.getPageInfo())));
 
         return tableCells;
     }
 
 
-    private Collection<TableCells> convertTableCells(List<TableCells> tableCells) {
+    private Collection<TableCells> convertTableCells(List<TableCells> tableCells, PageInfo pageInfo) {
 
         List<TableCells> cvParsedTableCells = new ArrayList<>();
 
-        tableCells.forEach(t -> cvParsedTableCells.add(TableCells.builder()
-                .y0(t.getY0())
-                .x1(t.getX1())
-                .y1(t.getY1())
-                .x0(t.getX0())
-                .width(t.getWidth())
-                .height(t.getHeight())
-                .build()));
+        tableCells.stream()
+                .filter(cell -> cell.getWidth() < pageInfo.getWidth() * 0.98 && cell.getHeight() < pageInfo.getHeight() * 0.98)
+                .forEach(t -> cvParsedTableCells.add(TableCells.builder()
+                        .y0(t.getY0())
+                        .x1(t.getX1())
+                        .y1(t.getY1())
+                        .x0(t.getX0())
+                        .width(t.getWidth())
+                        .height(t.getHeight())
+                        .build()));
 
         return cvParsedTableCells;
     }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/image/Classification.java

@@ -3,9 +3,15 @@ package com.knecon.fforesight.service.layoutparser.processor.python_api.model.im
 import java.util.HashMap;
 import java.util.Map;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class Classification {
 
     private Map<String, Float> probabilities = new HashMap<>();

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/image/FilterGeometry.java

@@ -1,8 +1,14 @@
 package com.knecon.fforesight.service.layoutparser.processor.python_api.model.image;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class FilterGeometry {
 
     private ImageSize imageSize;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/image/Filters.java

@@ -1,8 +1,14 @@
 package com.knecon.fforesight.service.layoutparser.processor.python_api.model.image;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class Filters {
 
     private FilterGeometry geometry;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/image/Geometry.java

@@ -1,8 +1,14 @@
 package com.knecon.fforesight.service.layoutparser.processor.python_api.model.image;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class Geometry {
 
     private float width;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/image/ImageFormat.java

@@ -1,8 +1,14 @@
 package com.knecon.fforesight.service.layoutparser.processor.python_api.model.image;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class ImageFormat {
 
     private float quotient;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/image/ImageMetadata.java

@@ -1,8 +1,14 @@
 package com.knecon.fforesight.service.layoutparser.processor.python_api.model.image;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class ImageMetadata {
 
     private Classification classification;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/image/ImageServiceResponse.java

@@ -6,9 +6,15 @@ import java.util.List;
 import com.fasterxml.jackson.annotation.JsonAlias;
 import com.fasterxml.jackson.annotation.JsonProperty;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class ImageServiceResponse {
 
     private String dossierId;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/image/ImageSize.java

@@ -1,8 +1,14 @@
 package com.knecon.fforesight.service.layoutparser.processor.python_api.model.image;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class ImageSize {
 
     private float quotient;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/image/Position.java

@@ -1,8 +1,14 @@
 package com.knecon.fforesight.service.layoutparser.processor.python_api.model.image;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class Position {
 
     private float x1;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/image/Probability.java

@@ -1,8 +1,14 @@
 package com.knecon.fforesight.service.layoutparser.processor.python_api.model.image;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class Probability {
 
     private boolean unconfident;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/table/PageInfo.java

@@ -1,8 +1,14 @@
 package com.knecon.fforesight.service.layoutparser.processor.python_api.model.table;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class PageInfo {
 
     private int number;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/table/PdfTableCell.java

@@ -3,12 +3,12 @@ package com.knecon.fforesight.service.layoutparser.processor.python_api.model.ta
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
-import lombok.RequiredArgsConstructor;
+import lombok.NoArgsConstructor;
 
 @Data
 @Builder
+@NoArgsConstructor
 @AllArgsConstructor
-@RequiredArgsConstructor
 public class PdfTableCell {
 
     private float x0;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/table/TableCells.java

@@ -1,10 +1,14 @@
 package com.knecon.fforesight.service.layoutparser.processor.python_api.model.table;
 
+import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
 @Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class TableCells {
 
     private float x0;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/table/TableData.java

@@ -3,9 +3,15 @@ package com.knecon.fforesight.service.layoutparser.processor.python_api.model.ta
 import java.util.ArrayList;
 import java.util.List;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class TableData {
 
     private PageInfo pageInfo;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/python_api/model/table/TableServiceResponse.java

@@ -3,9 +3,15 @@ package com.knecon.fforesight.service.layoutparser.processor.python_api.model.ta
 import java.util.ArrayList;
 import java.util.List;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class TableServiceResponse {
 
     private String dossierId;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/queue/MessagingConfiguration.java

@@ -1,40 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.queue;
-
-import static com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingQueueNames.LAYOUT_PARSING_FINISHED_EVENT_QUEUE;
-import static com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingQueueNames.LAYOUT_PARSING_DLQ;
-import static com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingQueueNames.LAYOUT_PARSING_REQUEST_QUEUE;
-
-import org.springframework.amqp.core.Queue;
-import org.springframework.amqp.core.QueueBuilder;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-import lombok.RequiredArgsConstructor;
-
-@Configuration
-@RequiredArgsConstructor
-public class MessagingConfiguration {
-
-    @Bean
-    public Queue layoutparsingRequestQueue() {
-
-        return QueueBuilder.durable(LAYOUT_PARSING_REQUEST_QUEUE)//
-                .withArgument("x-dead-letter-exchange", "").withArgument("x-dead-letter-routing-key", LAYOUT_PARSING_DLQ).build();
-    }
-
-
-    @Bean
-    public Queue layoutparsingResponseQueue() {
-
-        return QueueBuilder.durable(LAYOUT_PARSING_FINISHED_EVENT_QUEUE)//
-                .withArgument("x-dead-letter-exchange", "").withArgument("x-dead-letter-routing-key", LAYOUT_PARSING_DLQ).build();
-    }
-
-
-    @Bean
-    public Queue layoutparsingDLQ() {
-
-        return QueueBuilder.durable(LAYOUT_PARSING_DLQ).build();
-    }
-
-}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/BodyTextFrameService.java

@@ -1,5 +1,6 @@
 package com.knecon.fforesight.service.layoutparser.processor.services;
 
+import java.util.Comparator;
 import java.util.List;
 
 import org.springframework.stereotype.Service;
@@ -8,17 +9,74 @@ import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlo
 import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Rectangle;
 import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingType;
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
+import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationDocument;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
 import com.knecon.fforesight.service.layoutparser.processor.model.FloatFrequencyCounter;
 import com.knecon.fforesight.service.layoutparser.processor.model.table.Cell;
+import com.knecon.fforesight.service.layoutparser.processor.model.table.Ruling;
 import com.knecon.fforesight.service.layoutparser.processor.model.table.TablePageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
+import com.knecon.fforesight.service.layoutparser.processor.utils.MarkedContentUtils;
 import com.knecon.fforesight.service.layoutparser.processor.utils.PositionUtils;
 
 @Service
 public class BodyTextFrameService {
 
+    private static final float RULING_HEIGHT_THRESHOLD = 0.15f; // multiplied with page height. Header/Footer Rulings must be within that border of the page.
+    private static final float RULING_WIDTH_THRESHOLD = 0.75f; // multiplied with page width. Header/Footer Rulings must be at least that wide.
 
+    public void setBodyTextFrames(ClassificationDocument classificationDocument, LayoutParsingType layoutParsingType) {
+
+        Rectangle bodyTextFrame = calculateBodyTextFrame(classificationDocument.getPages(), classificationDocument.getFontSizeCounter(), false, layoutParsingType);
+        Rectangle landscapeBodyTextFrame = calculateBodyTextFrame(classificationDocument.getPages(), classificationDocument.getFontSizeCounter(), true, layoutParsingType);
+        for (ClassificationPage page : classificationDocument.getPages()) {
+//            var updatedBodyTextFrame = getBodyTextFrameFromRulings(page, bodyTextFrame, landscapeBodyTextFrame);
+            setBodyTextFrameAdjustedToPage(page, bodyTextFrame, landscapeBodyTextFrame);
+        }
+    }
+
+
+    private Rectangle getBodyTextFrameFromRulings(ClassificationPage page, Rectangle bodyTextFrame, Rectangle landscapeBodyTextFrame) {
+
+        List<Ruling> potentialFooterRulings = getPotentialFooterRulings(page);
+        List<Ruling> potentialHeaderRulings = getPotentialHeaderRulings(page);
+        var x = bodyTextFrame.getTopLeft().getX();
+        var y = bodyTextFrame.getTopLeft().getY();
+        var w = bodyTextFrame.getWidth();
+        var h = bodyTextFrame.getHeight();
+        if (!potentialFooterRulings.isEmpty()) {
+            h = y + h - potentialFooterRulings.get(0).getTop();
+            y = potentialFooterRulings.get(0).getTop();
+        }
+        if (!potentialHeaderRulings.isEmpty()) {
+            h = potentialHeaderRulings.get(0).getBottom() - bodyTextFrame.getTopLeft().getY();
+        }
+        return new Rectangle(new Point(x, y), w, h, page.getPageNumber());
+    }
+
+
+    private List<Ruling> getPotentialFooterRulings(ClassificationPage page) {
+
+        return page.getCleanRulings()
+                .getHorizontal()
+                .stream()
+                .filter(ruling -> ruling.getY1() < page.getPageHeight() * RULING_HEIGHT_THRESHOLD)
+                .filter(ruling -> ruling.getWidth() > RULING_WIDTH_THRESHOLD * page.getPageWidth())
+                .sorted(Comparator.comparingDouble(Ruling::getTop))
+                .toList();
+    }
+
+
+    private List<Ruling> getPotentialHeaderRulings(ClassificationPage page) {
+
+        return page.getCleanRulings()
+                .getHorizontal()
+                .stream()
+                .filter(ruling -> ruling.getY1() > page.getPageHeight() * (1 - RULING_HEIGHT_THRESHOLD))
+                .filter(ruling -> ruling.getWidth() > RULING_WIDTH_THRESHOLD * page.getPageWidth())
+                .sorted(Comparator.comparingDouble(Ruling::getBottom).reversed())
+                .toList();
+    }
 
 
     /**
@@ -34,7 +92,7 @@ public class BodyTextFrameService {
      * @param bodyTextFrame          frame that contains the main text on portrait pages
      * @param landscapeBodyTextFrame frame that contains the main text on landscape pages
      */
-    public void setBodyTextFrameAdjustedToPage(ClassificationPage page, Rectangle bodyTextFrame, Rectangle landscapeBodyTextFrame) {
+    private void setBodyTextFrameAdjustedToPage(ClassificationPage page, Rectangle bodyTextFrame, Rectangle landscapeBodyTextFrame) {
 
         Rectangle textFrame = page.isLandscape() ? landscapeBodyTextFrame : bodyTextFrame;
 
@@ -69,7 +127,10 @@ public class BodyTextFrameService {
      * @param landscape               Calculate for landscape or portrait
      * @return Rectangle of the text frame
      */
-    public Rectangle calculateBodyTextFrame(List<ClassificationPage> pages, FloatFrequencyCounter documentFontSizeCounter, boolean landscape, LayoutParsingType layoutParsingType) {
+    protected Rectangle calculateBodyTextFrame(List<ClassificationPage> pages,
+                                               FloatFrequencyCounter documentFontSizeCounter,
+                                               boolean landscape,
+                                               LayoutParsingType layoutParsingType) {
 
         float approximateHeaderLineCount;
         if (layoutParsingType.equals(LayoutParsingType.TAAS)) {
@@ -94,9 +155,14 @@ public class BodyTextFrameService {
                         continue;
                     }
 
+                    if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.HEADER)
+                            || MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.FOOTER)) {
+                        continue;
+                    }
+
                     float approxLineCount = PositionUtils.getApproxLineCount(textBlock);
-                    if (layoutParsingType.equals(LayoutParsingType.DOCUMINE) && approxLineCount < approximateHeaderLineCount && textBlock.getMaxY() >= page.getPageHeight() - (page.getPageHeight() / 10)
-                            || !layoutParsingType.equals(LayoutParsingType.DOCUMINE) && approxLineCount < approximateHeaderLineCount){
+                    if (layoutParsingType.equals(LayoutParsingType.DOCUMINE) && approxLineCount < approximateHeaderLineCount && textBlock.getMaxY() >= page.getPageHeight() - (page.getPageHeight() / 10) || !layoutParsingType.equals(
+                            LayoutParsingType.DOCUMINE) && approxLineCount < approximateHeaderLineCount) {
                         continue;
                     }
 
@@ -170,4 +236,4 @@ public class BodyTextFrameService {
 
     }
 
-}
+}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/PageContentExtractor.java

@@ -0,0 +1,73 @@
+package com.knecon.fforesight.service.layoutparser.processor.services;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.apache.pdfbox.Loader;
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.springframework.core.io.ClassPathResource;
+
+import com.knecon.fforesight.service.layoutparser.processor.model.PageContents;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
+import com.knecon.fforesight.service.layoutparser.processor.services.parsing.PDFLinesTextStripper;
+import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
+
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class PageContentExtractor {
+
+    public List<PageContents> getSortedPageContents(String filename) throws IOException {
+
+        List<PageContents> textPositionSequencesPerPage = new LinkedList<>();
+        ClassPathResource pdfResource = new ClassPathResource(filename);
+
+        try (PDDocument pdDocument = Loader.loadPDF(pdfResource.getFile())) {
+
+            for (int pageNumber = 1; pageNumber < pdDocument.getNumberOfPages() + 1; pageNumber++) {
+
+                PDFLinesTextStripper stripper = new PDFLinesTextStripper();
+                PDPage pdPage = pdDocument.getPage(pageNumber - 1);
+                stripper.setPageNumber(pageNumber);
+                stripper.setSortByPosition(true);
+                stripper.setStartPage(pageNumber);
+                stripper.setEndPage(pageNumber);
+                stripper.setPdpage(pdPage);
+                stripper.getText(pdDocument);
+
+                Map<Float, List<TextPositionSequence>> sortedTextPositionSequencesPerDir = stripper.getTextPositionSequences()
+                        .stream()
+                        .collect(Collectors.groupingBy(textPositionSequence -> textPositionSequence.getDir().getDegrees()));
+
+                var sortedTextPositionSequences = sortByDirAccordingToPageRotation(sortedTextPositionSequencesPerDir, pdPage.getRotation());
+
+                textPositionSequencesPerPage.add(new PageContents(sortedTextPositionSequences,
+                        RectangleTransformations.toRectangle2D(pdPage.getCropBox()),
+                        RectangleTransformations.toRectangle2D(pdPage.getMediaBox()),
+                        stripper.getRulings()));
+            }
+        }
+    
+        return textPositionSequencesPerPage;
+    }
+
+
+    public List<TextPositionSequence> sortByDirAccordingToPageRotation(Map<Float, List<TextPositionSequence>> sortedTextPositionSequencesPerDir, int rotation) {
+
+        LinkedList<Float> sortedKeys = new LinkedList<>(sortedTextPositionSequencesPerDir.keySet().stream().sorted().toList());
+
+        for (int i = 0; i < sortedKeys.size(); i++) {
+            if (sortedKeys.get(i) < rotation) {
+                Float keyToSwap = sortedKeys.remove(i);
+                sortedKeys.addLast(keyToSwap);
+            }
+        }
+        return sortedKeys.stream().map(sortedTextPositionSequencesPerDir::get).flatMap(Collection::stream).toList();
+    }
+
+}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/PdfParsingService.java

@@ -1,151 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.services;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-import org.apache.pdfbox.pdmodel.PDDocument;
-import org.apache.pdfbox.pdmodel.PDPage;
-import org.apache.pdfbox.pdmodel.common.PDRectangle;
-import org.springframework.stereotype.Service;
-
-import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingType;
-import com.knecon.fforesight.service.layoutparser.processor.python_api.adapter.ImageServiceResponseAdapter;
-import com.knecon.fforesight.service.layoutparser.processor.python_api.model.table.TableCells;
-import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationDocument;
-import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
-import com.knecon.fforesight.service.layoutparser.processor.model.image.ClassifiedImage;
-import com.knecon.fforesight.service.layoutparser.processor.model.table.CleanRulings;
-import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
-import com.knecon.fforesight.service.layoutparser.processor.services.parsing.PDFLinesTextStripper;
-import com.knecon.fforesight.service.layoutparser.processor.services.blockification.DocuMineBlockificationService;
-import com.knecon.fforesight.service.layoutparser.processor.services.blockification.RedactManagerBlockificationService;
-import com.knecon.fforesight.service.layoutparser.processor.services.blockification.TaasBlockificationService;
-
-import lombok.RequiredArgsConstructor;
-import lombok.SneakyThrows;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-@Service
-@RequiredArgsConstructor
-public class PdfParsingService {
-
-    private final RulingCleaningService rulingCleaningService;
-    private final TableExtractionService tableExtractionService;
-    private final ImageServiceResponseAdapter imageServiceResponseAdapter;
-    private final TaasBlockificationService taasBlockificationService;
-    private final DocuMineBlockificationService docuMineBlockificationService;
-    private final RedactManagerBlockificationService redactManagerBlockificationService;
-
-
-    public ClassificationDocument parseDocument(LayoutParsingType layoutParsingType,
-                                                PDDocument originDocument,
-                                                Map<Integer, List<TableCells>> pdfTableCells,
-                                                Map<Integer, List<ClassifiedImage>> pdfImages) {
-
-        ClassificationDocument document = new ClassificationDocument();
-        List<ClassificationPage> classificationPages = new ArrayList<>();
-
-        originDocument.setAllSecurityToBeRemoved(true);
-        long pageCount = originDocument.getNumberOfPages();
-
-        for (int pageNumber = 1; pageNumber <= pageCount; pageNumber++) {
-            parsePage(layoutParsingType, pdfImages, originDocument, pdfTableCells, document, classificationPages, pageNumber);
-        }
-
-        document.setPages(classificationPages);
-
-        return document;
-    }
-
-
-    @SneakyThrows
-    private void parsePage(LayoutParsingType layoutParsingType,
-                           Map<Integer, List<ClassifiedImage>> pdfImages,
-                           PDDocument pdDocument,
-                           Map<Integer, List<TableCells>> pdfTableCells,
-                           ClassificationDocument document,
-                           List<ClassificationPage> classificationPages,
-                           int pageNumber) {
-
-        PDFLinesTextStripper stripper = new PDFLinesTextStripper();
-        PDPage pdPage = pdDocument.getPage(pageNumber - 1);
-        stripper.setPageNumber(pageNumber);
-        stripper.setStartPage(pageNumber);
-        stripper.setEndPage(pageNumber);
-        stripper.setPdpage(pdPage);
-        stripper.getText(pdDocument);
-
-        PDRectangle pdr = pdPage.getMediaBox();
-
-        int rotation = pdPage.getRotation();
-        boolean isLandscape = pdr.getWidth() > pdr.getHeight() && (rotation == 0 || rotation == 180) || pdr.getHeight() > pdr.getWidth() && (rotation == 90 || rotation == 270);
-
-        PDRectangle cropbox = pdPage.getCropBox();
-        CleanRulings cleanRulings = rulingCleaningService.getCleanRulings(pdfTableCells.get(pageNumber),
-                stripper.getRulings(),
-                stripper.getMinCharWidth(),
-                stripper.getMaxCharHeight());
-
-        ClassificationPage classificationPage = switch (layoutParsingType) {
-            case REDACT_MANAGER -> redactManagerBlockificationService.blockify(stripper.getTextPositionSequences(), cleanRulings.getHorizontal(), cleanRulings.getVertical());
-            case TAAS -> taasBlockificationService.blockify(stripper.getTextPositionSequences(), cleanRulings.getHorizontal(), cleanRulings.getVertical());
-            case DOCUMINE -> docuMineBlockificationService.blockify(stripper.getTextPositionSequences(), cleanRulings.getHorizontal(), cleanRulings.getVertical());
-        };
-
-        classificationPage.setRotation(rotation);
-        classificationPage.setLandscape(isLandscape);
-        classificationPage.setPageNumber(pageNumber);
-        classificationPage.setPageWidth(cropbox.getWidth());
-        classificationPage.setPageHeight(cropbox.getHeight());
-
-        // If images is ocr needs to be calculated before textBlocks are moved into tables, otherwise findOcr algorithm needs to be adopted.
-        if (pdfImages != null && pdfImages.containsKey(pageNumber)) {
-            classificationPage.setImages(pdfImages.get(pageNumber));
-            imageServiceResponseAdapter.findOcr(classificationPage);
-        }
-
-        tableExtractionService.extractTables(cleanRulings, classificationPage, layoutParsingType);
-        buildPageStatistics(classificationPage);
-        increaseDocumentStatistics(classificationPage, document);
-
-        classificationPages.add(classificationPage);
-    }
-
-
-    private void increaseDocumentStatistics(ClassificationPage classificationPage, ClassificationDocument document) {
-
-        if (!classificationPage.isLandscape()) {
-            document.getFontSizeCounter().addAll(classificationPage.getFontSizeCounter().getCountPerValue());
-        }
-        document.getFontCounter().addAll(classificationPage.getFontCounter().getCountPerValue());
-        document.getTextHeightCounter().addAll(classificationPage.getTextHeightCounter().getCountPerValue());
-        document.getFontStyleCounter().addAll(classificationPage.getFontStyleCounter().getCountPerValue());
-    }
-
-
-    private void buildPageStatistics(ClassificationPage classificationPage) {
-
-        // Collect all statistics for the classificationPage, except from blocks inside tables, as tables will always be added to BodyTextFrame.
-        for (AbstractPageBlock textBlock : classificationPage.getTextBlocks()) {
-            if (textBlock instanceof TextPageBlock) {
-                if (((TextPageBlock) textBlock).getSequences() == null) {
-                    continue;
-                }
-                for (TextPositionSequence word : ((TextPageBlock) textBlock).getSequences()) {
-                    classificationPage.getTextHeightCounter().add(word.getTextHeight());
-                    classificationPage.getFontCounter().add(word.getFont());
-                    classificationPage.getFontSizeCounter().add(word.getFontSize());
-                    classificationPage.getFontStyleCounter().add(word.getFontStyle());
-                }
-            }
-        }
-
-    }
-
-}
-
-

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/RulingCleaningService.java

@@ -1,21 +1,21 @@
 package com.knecon.fforesight.service.layoutparser.processor.services;
 
-import java.awt.geom.Line2D;
+import static com.knecon.fforesight.service.layoutparser.processor.utils.GeometricComparators.X_FIRST_RULING_COMPARATOR;
+
 import java.awt.geom.Point2D;
 import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 import org.springframework.stereotype.Service;
 
-import com.knecon.fforesight.service.layoutparser.processor.python_api.model.table.TableCells;
 import com.knecon.fforesight.service.layoutparser.processor.model.table.CleanRulings;
+import com.knecon.fforesight.service.layoutparser.processor.model.table.Rectangle;
 import com.knecon.fforesight.service.layoutparser.processor.model.table.Ruling;
-import com.knecon.fforesight.service.layoutparser.processor.utils.DoubleComparisons;
+import com.knecon.fforesight.service.layoutparser.processor.python_api.model.table.TableCells;
+import com.knecon.fforesight.service.layoutparser.processor.utils.UnionFind;
 
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -25,22 +25,145 @@ import lombok.extern.slf4j.Slf4j;
 @RequiredArgsConstructor
 public class RulingCleaningService {
 
-    public CleanRulings getCleanRulings(List<TableCells> tableCells, List<Ruling> rulings, float minCharWidth, float maxCharHeight) {
+    private static final float THRESHOLD_X_VERTICAL = 1;
+    private static final float THRESHOLD_Y_VERTICAL = 2;
+    private static final float THRESHOLD_X_HORIZONTAL = 2;
+    private static final float THRESHOLD_Y_HORIZONTAL = 3;
+
+
+    public CleanRulings getCleanRulings(List<TableCells> tableCells, List<Ruling> rulings) {
+
+        Rulings verticalAndHorizontalRulingLines;
 
         if (!rulings.isEmpty()) {
-            snapPoints(rulings, minCharWidth, maxCharHeight);
+            verticalAndHorizontalRulingLines = extractVerticalAndHorizontalRulingLines(rulings);
+        } else {
+            verticalAndHorizontalRulingLines = getRulingsFromParsedCells(tableCells);
         }
 
+        verticalAndHorizontalRulingLines.verticalLines.sort(X_FIRST_RULING_COMPARATOR);
+        verticalAndHorizontalRulingLines.horizontalLines.sort(X_FIRST_RULING_COMPARATOR);
+        verticalAndHorizontalRulingLines = cleanRulings(verticalAndHorizontalRulingLines);
+
+        return CleanRulings.builder().vertical(verticalAndHorizontalRulingLines.verticalLines()).horizontal(verticalAndHorizontalRulingLines.horizontalLines()).build();
+    }
+
+
+    private Rulings cleanRulings(Rulings rulings) {
+
+        List<List<Rectangle>> groupedOverlappingVerticalRectangles = groupOverlappingRectangles(rulings.verticalLines.stream()
+                                                                                                        .map(RulingCleaningService::getOverlapRectangle)
+                                                                                                        .distinct()
+                                                                                                        .toList());
+        List<Ruling> cleanedVerticalRulings = groupedOverlappingVerticalRectangles.stream()
+                .map(rectList -> getXCenteredRuling(Rectangle.boundingBoxOf(rectList)))
+                .toList();
+
+        List<List<Rectangle>> groupedOverlappingHorizontalRectangles = groupOverlappingRectangles(rulings.horizontalLines.stream()
+                                                                                                          .map(RulingCleaningService::getOverlapRectangle)
+                                                                                                          .distinct()
+                                                                                                          .toList());
+
+        List<Ruling> cleanedHorizontalRulings = groupedOverlappingHorizontalRectangles.stream()
+                .map(rectList -> getYCenteredRuling(Rectangle.boundingBoxOf(rectList)))
+                .collect(Collectors.toList());
+
+        return new Rulings(cleanedVerticalRulings, cleanedHorizontalRulings);
+    }
+
+
+    private List<List<Rectangle>> groupOverlappingRectangles(List<Rectangle> rectangles) {
+
+        UnionFind<Rectangle> unionFind = new UnionFind<>();
+        for (int i = 0; i < rectangles.size(); i++) {
+            for (int j = i + 1; j < rectangles.size(); j++) {
+                Rectangle rectangle1 = rectangles.get(i);
+                Rectangle rectangle2 = rectangles.get(j);
+
+                // we can stop early when we are too far off because of x-y-sorting
+                if(rectangle1.getRight() < rectangle2.getLeft() && rectangle1.getBottom() < rectangle2.getTop()) {
+                    break;
+                }
+
+                if (rectangle1.intersects(rectangle2)) {
+                    unionFind.union(rectangle1, rectangle2);
+                }
+            }
+        }
+
+        Map<Rectangle, List<Rectangle>> groups = new HashMap<>();
+        for (Rectangle rectangle : rectangles) {
+            Rectangle root = unionFind.find(rectangle);
+            groups.computeIfAbsent(root, k -> new ArrayList<>()).add(rectangle);
+        }
+        return new ArrayList<>(groups.values());
+    }
+
+
+    private static Rectangle getOverlapRectangle(Ruling ruling) {
+
+        float top;
+        float left;
+        float w;
+        float h;
+
+        if (ruling.x1 < ruling.x2) {
+            left = ruling.x1;
+            w = ruling.x2 - ruling.x1;
+        } else {
+            left = ruling.x2;
+            w = ruling.x1 - ruling.x2;
+        }
+        if (ruling.y1 < ruling.y2) {
+            top = ruling.y1;
+            h = ruling.y2 - ruling.y1;
+        } else {
+            top = ruling.y2;
+            h = ruling.y1 - ruling.y2;
+        }
+
+        if (ruling.horizontal()) {
+            return new Rectangle(top - THRESHOLD_Y_HORIZONTAL, left - THRESHOLD_X_HORIZONTAL, w + 2 * THRESHOLD_X_HORIZONTAL, h + 2 * THRESHOLD_Y_HORIZONTAL);
+        } else {
+            return new Rectangle(top - THRESHOLD_Y_VERTICAL, left - THRESHOLD_X_VERTICAL, w + 2 * THRESHOLD_X_VERTICAL, h + 2 * THRESHOLD_Y_VERTICAL);
+        }
+    }
+
+
+    public static Ruling getXCenteredRuling(Rectangle rectangle) {
+
+        float x = (float) rectangle.getCenterX();
+        float y1 = rectangle.getTop();
+        float y2 = rectangle.getBottom();
+
+        Point2D point1 = new Point2D.Float(x, y1 + THRESHOLD_Y_VERTICAL);
+        Point2D point2 = new Point2D.Float(x, y2 - THRESHOLD_Y_VERTICAL);
+
+        return new Ruling(point1, point2);
+    }
+
+
+    public static Ruling getYCenteredRuling(Rectangle rectangle) {
+
+        float x1 = rectangle.getLeft();
+        float x2 = rectangle.getRight();
+        float y = (float) rectangle.getCenterY();
+
+        Point2D point1 = new Point2D.Float(x1 + THRESHOLD_X_HORIZONTAL, y);
+        Point2D point2 = new Point2D.Float(x2 - THRESHOLD_X_HORIZONTAL, y);
+
+        return new Ruling(point1, point2);
+    }
+
+
+    private Rulings extractVerticalAndHorizontalRulingLines(List<Ruling> rulings) {
+
         List<Ruling> vrs = new ArrayList<>();
         for (Ruling vr : rulings) {
             if (vr.vertical()) {
                 vrs.add(vr);
             }
         }
-        if (vrs.isEmpty()) {
-            vrs.addAll(extractVerticalRulings(tableCells));
-        }
-        List<Ruling> verticalRulingLines = collapseOrientedRulings(vrs);
 
         List<Ruling> hrs = new ArrayList<>();
         for (Ruling hr : rulings) {
@@ -48,101 +171,26 @@ public class RulingCleaningService {
                 hrs.add(hr);
             }
         }
-        if (hrs.isEmpty()) {
-            hrs.addAll(extractHorizontalRulings(tableCells));
-        }
-        List<Ruling> horizontalRulingLines = collapseOrientedRulings(hrs);
-
-        return CleanRulings.builder()
-                .vertical(verticalRulingLines)
-                .horizontal(horizontalRulingLines)
-                .build();
+        return new Rulings(vrs, hrs);
     }
 
 
-    public void snapPoints(List<? extends Line2D.Float> rulings, float xThreshold, float yThreshold) {
+    private Rulings getRulingsFromParsedCells(List<TableCells> tableCells) {
 
-        // collect points and keep a Line -> p1,p2 map
-        Map<Line2D.Float, Point2D[]> linesToPoints = new HashMap<>();
-        List<Point2D> points = new ArrayList<>();
-        for (Line2D.Float r : rulings) {
-            Point2D p1 = r.getP1();
-            Point2D p2 = r.getP2();
-            linesToPoints.put(r, new Point2D[]{p1, p2});
-            points.add(p1);
-            points.add(p2);
-        }
-
-        // snap by X
-        points.sort(Comparator.comparingDouble(Point2D::getX));
-
-        List<List<Point2D>> groupedPoints = new ArrayList<>();
-        groupedPoints.add(new ArrayList<>(Collections.singletonList(points.get(0))));
-
-        for (Point2D p : points.subList(1, points.size() - 1)) {
-            List<Point2D> last = groupedPoints.get(groupedPoints.size() - 1);
-            if (Math.abs(p.getX() - last.get(0).getX()) < xThreshold) {
-                groupedPoints.get(groupedPoints.size() - 1).add(p);
-            } else {
-                groupedPoints.add(new ArrayList<>(Collections.singletonList(p)));
-            }
-        }
-
-        for (List<Point2D> group : groupedPoints) {
-            float avgLoc = 0;
-            for (Point2D p : group) {
-                avgLoc += p.getX();
-            }
-            avgLoc /= group.size();
-            for (Point2D p : group) {
-                p.setLocation(avgLoc, p.getY());
-            }
-        }
-        // ---
-
-        // snap by Y
-        points.sort(Comparator.comparingDouble(Point2D::getY));
-
-        groupedPoints = new ArrayList<>();
-        groupedPoints.add(new ArrayList<>(Collections.singletonList(points.get(0))));
-
-        for (Point2D p : points.subList(1, points.size() - 1)) {
-            List<Point2D> last = groupedPoints.get(groupedPoints.size() - 1);
-            if (Math.abs(p.getY() - last.get(0).getY()) < yThreshold) {
-                groupedPoints.get(groupedPoints.size() - 1).add(p);
-            } else {
-                groupedPoints.add(new ArrayList<>(Collections.singletonList(p)));
-            }
-        }
-
-        for (List<Point2D> group : groupedPoints) {
-            float avgLoc = 0;
-            for (Point2D p : group) {
-                avgLoc += p.getY();
-            }
-            avgLoc /= group.size();
-            for (Point2D p : group) {
-                p.setLocation(p.getX(), avgLoc);
-            }
-        }
-        // ---
-
-        // finally, modify lines
-        for (Map.Entry<Line2D.Float, Point2D[]> ltp : linesToPoints.entrySet()) {
-            Point2D[] p = ltp.getValue();
-            ltp.getKey().setLine(p[0], p[1]);
-        }
+        List<Ruling> vrs = extractVerticalRulingsFromParsedCells(tableCells);
+        List<Ruling> hrs = extractHorizontalRulingsFromParsedCells(tableCells);
+        return new Rulings(vrs, hrs);
     }
 
 
-    private Collection<? extends Ruling> extractVerticalRulings(List<TableCells> cvParsedTableCells) {
+    private List<Ruling> extractVerticalRulingsFromParsedCells(List<TableCells> tableCells) {
 
         List<Ruling> vrs = new ArrayList<>();
 
-        if (cvParsedTableCells != null) {
-            for (TableCells cvParsedTableCell : cvParsedTableCells) {
-                Ruling leftLine = createRuling(cvParsedTableCell.getX0(), cvParsedTableCell.getX0(), cvParsedTableCell.getY0(), cvParsedTableCell.getY1());
-                Ruling rightLine = createRuling(cvParsedTableCell.getX1(), cvParsedTableCell.getX1(), cvParsedTableCell.getY0(), cvParsedTableCell.getY1());
+        if (tableCells != null) {
+            for (TableCells tableCell : tableCells) {
+                Ruling leftLine = createRuling(tableCell.getX0(), tableCell.getX0(), tableCell.getY0(), tableCell.getY1());
+                Ruling rightLine = createRuling(tableCell.getX1(), tableCell.getX1(), tableCell.getY0(), tableCell.getY1());
                 vrs.add(leftLine);
                 vrs.add(rightLine);
             }
@@ -151,19 +199,18 @@ public class RulingCleaningService {
     }
 
 
-    private Collection<? extends Ruling> extractHorizontalRulings(List<TableCells> cvParsedTableCells) {
+    private List<Ruling> extractHorizontalRulingsFromParsedCells(List<TableCells> tableCells) {
 
         List<Ruling> hrs = new ArrayList<>();
 
-        if (cvParsedTableCells != null) {
-            for (TableCells cvParsedTableCell : cvParsedTableCells) {
-                Ruling topLine = createRuling(cvParsedTableCell.getX0(), cvParsedTableCell.getX1(), cvParsedTableCell.getY1(), cvParsedTableCell.getY1());
-                Ruling baseLine = createRuling(cvParsedTableCell.getX0(), cvParsedTableCell.getX1(), cvParsedTableCell.getY0(), cvParsedTableCell.getY0());
+        if (tableCells != null) {
+            for (TableCells tableCell : tableCells) {
+                Ruling topLine = createRuling(tableCell.getX0(), tableCell.getX1(), tableCell.getY1(), tableCell.getY1());
+                Ruling baseLine = createRuling(tableCell.getX0(), tableCell.getX1(), tableCell.getY0(), tableCell.getY0());
                 hrs.add(topLine);
                 hrs.add(baseLine);
             }
         }
-
         return hrs;
     }
 
@@ -189,46 +236,8 @@ public class RulingCleaningService {
     }
 
 
-    private List<Ruling> collapseOrientedRulings(List<Ruling> lines) {
+    private record Rulings(List<Ruling> verticalLines, List<Ruling> horizontalLines) {
 
-        int COLINEAR_OR_PARALLEL_PIXEL_EXPAND_AMOUNT = 1;
-        return collapseOrientedRulings(lines, COLINEAR_OR_PARALLEL_PIXEL_EXPAND_AMOUNT);
-    }
-
-
-    private List<Ruling> collapseOrientedRulings(List<Ruling> lines, int expandAmount) {
-
-        ArrayList<Ruling> rv = new ArrayList<>();
-        lines.sort((a, b) -> {
-            final float diff = a.getPosition() - b.getPosition();
-            return Float.compare(diff == 0 ? a.getStart() - b.getStart() : diff, 0f);
-        });
-
-        for (Ruling next_line : lines) {
-            Ruling last = rv.isEmpty() ? null : rv.get(rv.size() - 1);
-            // if current line colinear with next, and are "close enough": expand current line
-            if (last != null && DoubleComparisons.feq(next_line.getPosition(), last.getPosition()) && last.nearlyIntersects(next_line, expandAmount)) {
-                final float lastStart = last.getStart();
-                final float lastEnd = last.getEnd();
-
-                final boolean lastFlipped = lastStart > lastEnd;
-                final boolean nextFlipped = next_line.getStart() > next_line.getEnd();
-
-                boolean differentDirections = nextFlipped != lastFlipped;
-                float nextS = differentDirections ? next_line.getEnd() : next_line.getStart();
-                float nextE = differentDirections ? next_line.getStart() : next_line.getEnd();
-
-                final float newStart = lastFlipped ? Math.max(nextS, lastStart) : Math.min(nextS, lastStart);
-                final float newEnd = lastFlipped ? Math.min(nextE, lastEnd) : Math.max(nextE, lastEnd);
-                last.setStartEnd(newStart, newEnd);
-                assert !last.oblique();
-            } else if (next_line.length() == 0) {
-                continue;
-            } else {
-                rv.add(next_line);
-            }
-        }
-        return rv;
     }
 
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/SectionGridCreatorService.java

@@ -1,146 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.services;
-
-import java.awt.geom.Rectangle2D;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.function.BiConsumer;
-import java.util.function.BinaryOperator;
-import java.util.function.Function;
-import java.util.function.Supplier;
-import java.util.stream.Collector;
-import java.util.stream.Stream;
-
-import org.springframework.stereotype.Service;
-
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Point;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.section.CellRectangle;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.section.SectionGrid;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.section.SectionRectangle;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Document;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Page;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.SemanticNode;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Table;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.TableCell;
-
-import lombok.RequiredArgsConstructor;
-
-@Service
-@RequiredArgsConstructor
-public class SectionGridCreatorService {
-
-    public SectionGrid createSectionGrid(Document document) {
-
-        Map<Integer, List<SectionRectangle>> sectionBBox = document.streamAllSubNodesOfType(NodeType.SECTION).map(SemanticNode::getBBox).collect(new SectionGridCollector());
-        Map<Integer, List<SectionRectangle>> paragraphBBox = document.streamAllSubNodesOfType(NodeType.PARAGRAPH).map(SemanticNode::getBBox).collect(new SectionGridCollector());
-        Map<Integer, List<SectionRectangle>> headlineBBox = document.streamAllSubNodesOfType(NodeType.HEADLINE).map(SemanticNode::getBBox).collect(new SectionGridCollector());
-        Map<Integer, List<SectionRectangle>> tableBBox = document.streamAllSubNodesOfType(NodeType.TABLE).map(node -> (Table) node).collect(new TableGridCollector());
-        var sectionGrid = new SectionGrid();
-
-        sectionGrid.setRectanglesPerPage(mergeMapsByConcatenatingLists(//
-                mergeMapsByConcatenatingLists(paragraphBBox, headlineBBox), //
-                mergeMapsByConcatenatingLists(sectionBBox, tableBBox)));
-
-        return sectionGrid;
-    }
-
-
-    private static abstract class GridCollector<T> implements Collector<T, Map<Integer, List<SectionRectangle>>, Map<Integer, List<SectionRectangle>>> {
-
-        @Override
-        public Supplier<Map<Integer, List<SectionRectangle>>> supplier() {
-
-            return HashMap::new;
-        }
-
-
-        @Override
-        public Function<Map<Integer, List<SectionRectangle>>, Map<Integer, List<SectionRectangle>>> finisher() {
-
-            return Function.identity();
-        }
-
-
-        @Override
-        public BinaryOperator<Map<Integer, List<SectionRectangle>>> combiner() {
-
-            return SectionGridCreatorService::mergeMapsByConcatenatingLists;
-        }
-
-
-        @Override
-        public Set<Characteristics> characteristics() {
-
-            return Set.of(Characteristics.IDENTITY_FINISH, Characteristics.CONCURRENT, Characteristics.UNORDERED);
-        }
-
-    }
-
-    private static class TableGridCollector extends GridCollector<Table> {
-
-        @Override
-        public BiConsumer<Map<Integer, List<SectionRectangle>>, Table> accumulator() {
-
-            return (map, table) -> table.getPages()
-                    .forEach(page -> map.merge(page.getNumber(), List.of(toSectionRectangle(table, page, table.getPages().size())), SectionGridCreatorService::concatLists));
-        }
-
-
-        private static SectionRectangle toSectionRectangle(Table table, Page page, int numberOfParts) {
-
-            Rectangle2D rect = table.getBBox().get(page);
-            List<CellRectangle> tableCellRectangles = table.streamTableCells()
-                    .map(TableCell::getBBox)
-                    .map(map -> map.get(page))
-                    .filter(Objects::nonNull)
-                    .map(rectangle2D -> new CellRectangle(new Point((float) rectangle2D.getX(), (float) rectangle2D.getY()),
-                            (float) rectangle2D.getWidth(),
-                            (float) rectangle2D.getHeight()))
-                    .toList();
-            return new SectionRectangle(new Point((float) rect.getX(), (float) rect.getY()),
-                    (float) rect.getWidth(),
-                    (float) rect.getHeight(),
-                    1,
-                    numberOfParts,
-                    tableCellRectangles);
-        }
-
-    }
-
-    private static class SectionGridCollector extends GridCollector<Map<Page, Rectangle2D>> {
-
-        @Override
-        public BiConsumer<Map<Integer, List<SectionRectangle>>, Map<Page, Rectangle2D>> accumulator() {
-
-            return (mapToKeep, mapToMerge) -> mapToMerge.forEach((page, rectangle) -> mapToKeep.merge(page.getNumber(),
-                    List.of(toSectionRectangle(rectangle, mapToMerge.values().size())),
-                    SectionGridCreatorService::concatLists));
-
-        }
-
-
-        private static SectionRectangle toSectionRectangle(Rectangle2D rect, int numberOfParts) {
-
-            return new SectionRectangle(new Point((float) rect.getX(), (float) rect.getY()), (float) rect.getWidth(), (float) rect.getHeight(), 1, numberOfParts, null);
-        }
-
-    }
-
-
-    private static Map<Integer, List<SectionRectangle>> mergeMapsByConcatenatingLists(Map<Integer, List<SectionRectangle>> mapToKeep,
-                                                                                      Map<Integer, List<SectionRectangle>> mapToMerge) {
-
-        mapToMerge.forEach((page, rectangle) -> mapToKeep.merge(page, rectangle, SectionGridCreatorService::concatLists));
-        return mapToKeep;
-    }
-
-
-    private static List<SectionRectangle> concatLists(List<SectionRectangle> l1, List<SectionRectangle> l2) {
-
-        return Stream.concat(l1.stream(), l2.stream()).toList();
-    }
-
-}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/SimplifiedSectionTextService.java

@@ -0,0 +1,26 @@
+package com.knecon.fforesight.service.layoutparser.processor.services;
+
+import java.util.List;
+
+import org.springframework.stereotype.Service;
+
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.SimplifiedSectionText;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Document;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Section;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.SimplifiedText;
+
+@Service
+public class SimplifiedSectionTextService {
+
+    public SimplifiedText toSimplifiedText(Document document) {
+
+        List<SimplifiedSectionText> simplifiedSectionTexts = document.getMainSections().stream().map(this::toSimplifiedSectionText).toList();
+        return SimplifiedText.builder().numberOfPages(document.getNumberOfPages()).sectionTexts(simplifiedSectionTexts).build();
+    }
+
+
+    private SimplifiedSectionText toSimplifiedSectionText(Section section) {
+
+        return SimplifiedSectionText.builder().sectionNumber(section.getTreeId().get(0)).text(section.getTextBlock().getSearchText()).build();
+    }
+}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/TableExtractionService.java

@@ -1,18 +1,16 @@
 package com.knecon.fforesight.service.layoutparser.processor.services;
 
-import java.awt.geom.Point2D;
+import static com.knecon.fforesight.service.layoutparser.processor.utils.GeometricComparators.CELL_SIZE_COMPARATOR;
+import static com.knecon.fforesight.service.layoutparser.processor.utils.GeometricComparators.RECTANGLE_SIZE_COMPARATOR;
+
 import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.springframework.stereotype.Service;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingType;
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
 import com.knecon.fforesight.service.layoutparser.processor.model.table.Cell;
@@ -22,48 +20,15 @@ import com.knecon.fforesight.service.layoutparser.processor.model.table.Ruling;
 import com.knecon.fforesight.service.layoutparser.processor.model.table.TablePageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.utils.DoubleComparisons;
+import com.knecon.fforesight.service.layoutparser.processor.utils.RectangularIntersectionFinder;
+import com.knecon.fforesight.service.layoutparser.processor.utils.SpreadsheetFinder;
 
 @Service
 public class TableExtractionService {
 
-    private static final Comparator<Point2D> X_FIRST_POINT_COMPARATOR = (arg0, arg1) -> {
-
-        int rv = 0;
-        float arg0X = DoubleComparisons.round(arg0.getX(), 2);
-        float arg0Y = DoubleComparisons.round(arg0.getY(), 2);
-        float arg1X = DoubleComparisons.round(arg1.getX(), 2);
-        float arg1Y = DoubleComparisons.round(arg1.getY(), 2);
-
-        if (arg0X > arg1X) {
-            rv = 1;
-        } else if (arg0X < arg1X) {
-            rv = -1;
-        } else if (arg0Y > arg1Y) {
-            rv = 1;
-        } else if (arg0Y < arg1Y) {
-            rv = -1;
-        }
-        return rv;
-    };
-    private static final Comparator<Point2D> POINT_COMPARATOR = (arg0, arg1) -> {
-
-        int rv = 0;
-        float arg0X = DoubleComparisons.round(arg0.getX(), 2);
-        float arg0Y = DoubleComparisons.round(arg0.getY(), 2);
-        float arg1X = DoubleComparisons.round(arg1.getX(), 2);
-        float arg1Y = DoubleComparisons.round(arg1.getY(), 2);
-
-        if (arg0Y > arg1Y) {
-            rv = 1;
-        } else if (arg0Y < arg1Y) {
-            rv = -1;
-        } else if (arg0X > arg1X) {
-            rv = 1;
-        } else if (arg0X < arg1X) {
-            rv = -1;
-        }
-        return rv;
-    };
+    private static final int MAX_TABLE_CONTAINED_CELLS_WITH_TEXT = 1;
+    private static final int TEXT_BLOCK_CONTAINMENT_TOLERANCE = 2;
+    private static final double TABLE_UNIFORMITY_THRESHOLD = 0.7;
 
 
     /**
@@ -79,21 +44,18 @@ public class TableExtractionService {
      * @param cleanRulings The lines used to build the table.
      * @param page         Page object that contains textblocks and statistics.
      */
-    public void extractTables(CleanRulings cleanRulings, ClassificationPage page, LayoutParsingType layoutParsingType) {
 
-        List<Cell> cells = findCells(cleanRulings.getHorizontal(), cleanRulings.getVertical(), layoutParsingType);
+    public void extractTables(CleanRulings cleanRulings, ClassificationPage page) {
 
-        List<TextPageBlock> toBeRemoved = new ArrayList<>();
+        List<Cell> cells = findCells(cleanRulings.getHorizontal(), cleanRulings.getVertical());
+        // sort cells by size (height * width) ascending so that textBlocks are always assigned to the smallest cells that contain them
+        cells.sort(CELL_SIZE_COMPARATOR);
 
         for (AbstractPageBlock abstractPageBlock : page.getTextBlocks()) {
             TextPageBlock textBlock = (TextPageBlock) abstractPageBlock;
             for (Cell cell : cells) {
-                if (cell.hasMinimumSize() && cell.intersects(textBlock.getPdfMinX(),
-                        textBlock.getPdfMinY(),
-                        textBlock.getPdfMaxX() - textBlock.getPdfMinX(),
-                        textBlock.getPdfMaxY() - textBlock.getPdfMinY())) {
+                if (cell.hasMinimumSize() && doesCellContainTextBlock(cell, textBlock)) {
                     cell.addTextBlock(textBlock);
-                    toBeRemoved.add(textBlock);
                     break;
                 }
             }
@@ -102,247 +64,94 @@ public class TableExtractionService {
         cells = new ArrayList<>(new HashSet<>(cells));
         DoubleComparisons.sort(cells, Rectangle.ILL_DEFINED_ORDER);
 
-        List<Rectangle> spreadsheetAreas = findSpreadsheetsFromCells(cells).stream().filter(r -> r.getWidth() > 0f && r.getHeight() > 0f).toList();
+        List<Rectangle> spreadsheetAreas = SpreadsheetFinder.findSpreadsheetsFromCells(cells);
+        // sort spreadsheetAreas by size (height * width) ascending so that cells are placed in the smallest tables first
+        // this way no cell duplication occurs when tables are contained in other tables and only the most inner table contains the cells
+        spreadsheetAreas.sort(RECTANGLE_SIZE_COMPARATOR);
 
         List<TablePageBlock> tables = new ArrayList<>();
         for (Rectangle area : spreadsheetAreas) {
 
-            List<Cell> overlappingCells = new ArrayList<>();
+            List<Cell> containedCells = new ArrayList<>();
             for (Cell c : cells) {
-                if (c.hasMinimumSize() && c.intersects(area)) {
-                    overlappingCells.add(c);
+                if (c.hasMinimumSize() && area.contains(c)) {
+                    containedCells.add(c);
                 }
             }
-            tables.add(new TablePageBlock(overlappingCells, area, page.getRotation()));
+
+            var containedCellsWithText = containedCells.stream()
+                    .filter(cell -> !cell.getTextBlocks().isEmpty())
+                    .toList();
+
+            // verify if table would contain fewer cells with text than the threshold allows
+            if (containedCellsWithText.size() >= MAX_TABLE_CONTAINED_CELLS_WITH_TEXT && checkIfTableCellsAreUniform(containedCells)) {
+                tables.add(new TablePageBlock(containedCells, area, page.getRotation()));
+                cells.removeAll(containedCells);
+            }
         }
 
         for (TablePageBlock table : tables) {
             int position = -1;
 
-            Iterator<AbstractPageBlock> itty = page.getTextBlocks().iterator();
-            while (itty.hasNext()) {
-                AbstractPageBlock textBlock = itty.next();
-                if (textBlock instanceof TextPageBlock ? table.containsBlock((TextPageBlock) textBlock) : table.contains(textBlock) && position == -1) {
-                    position = page.getTextBlocks().indexOf(textBlock);
+            for (AbstractPageBlock pageBlock : page.getTextBlocks()) {
+                if (pageBlock instanceof TextPageBlock ? table.containsBlock((TextPageBlock) pageBlock) : table.contains(pageBlock) && position == -1) {
+                    position = page.getTextBlocks().indexOf(pageBlock);
                 }
             }
             if (position != -1) {
                 page.getTextBlocks().add(position, table);
+
+                var toBeRemoved = table.getCells()
+                        .stream()
+                        .map(Cell::getTextBlocks)
+                        .flatMap(List::stream)
+                        .toList();
+                // remove text blocks from the page that were also added with the table (from its contained cells)
+                page.getTextBlocks().removeAll(toBeRemoved);
             }
         }
-
-        page.getTextBlocks().removeAll(toBeRemoved);
     }
 
 
-    public List<Cell> findCells(List<Ruling> horizontalRulingLines, List<Ruling> verticalRulingLines, LayoutParsingType layoutParsingType) {
+    private boolean checkIfTableCellsAreUniform(List<Cell> containedCells) {
 
-        if (layoutParsingType.equals(LayoutParsingType.TAAS)) {
-            // TODO: breaks some tables, for example "1 Abamectin Prr.pdf" try to fix this upstream in RulingCleaningService
-            for (Ruling r : horizontalRulingLines) {
-                if (r.getX2() < r.getX1()) {
-                    double a = r.getX2();
-                    r.x2 = (float) r.getX1();
-                    r.x1 = (float) a;
-                }
-            }
+        if(containedCells.size() <= 2) {
+            return true;
         }
 
-        List<Cell> cellsFound = new ArrayList<>();
-        Map<Point2D, Ruling[]> intersectionPoints = Ruling.findIntersections(horizontalRulingLines, verticalRulingLines);
-        List<Point2D> intersectionPointsList = new ArrayList<>(intersectionPoints.keySet());
-        intersectionPointsList.sort(POINT_COMPARATOR);
+        Map<Long, List<Long>> cellsGroupedByRoundedWidth = containedCells.stream()
+                .map(Rectangle::getWidth)
+                .map(size -> Math.round(size / 10.0) * 10)
+                .collect(Collectors.groupingBy(Long::longValue));
 
-        for (int i = 0; i < intersectionPointsList.size(); i++) {
-            Point2D topLeft = intersectionPointsList.get(i);
-            Ruling[] hv = intersectionPoints.get(topLeft);
-
-            // CrossingPointsDirectlyBelow( topLeft );
-            List<Point2D> xPoints = new ArrayList<>();
-            // CrossingPointsDirectlyToTheRight( topLeft );
-            List<Point2D> yPoints = new ArrayList<>();
-
-            for (Point2D p : intersectionPointsList.subList(i, intersectionPointsList.size())) {
-                if (p.getX() == topLeft.getX() && p.getY() > topLeft.getY()) {
-                    xPoints.add(p);
-                }
-                if (p.getY() == topLeft.getY() && p.getX() > topLeft.getX()) {
-                    yPoints.add(p);
-                }
-            }
-            outer:
-            for (Point2D xPoint : xPoints) {
-                // is there a vertical edge b/w topLeft and xPoint?
-                if (!hv[1].equals(intersectionPoints.get(xPoint)[1])) {
-                    continue;
-                }
-                for (Point2D yPoint : yPoints) {
-                    // is there an horizontal edge b/w topLeft and yPoint ?
-                    if (!hv[0].equals(intersectionPoints.get(yPoint)[0])) {
-                        continue;
-                    }
-                    Point2D btmRight = new Point2D.Float((float) yPoint.getX(), (float) xPoint.getY());
-                    if (intersectionPoints.containsKey(btmRight) && intersectionPoints.get(btmRight)[0].equals(intersectionPoints.get(xPoint)[0]) && intersectionPoints.get(btmRight)[1].equals(
-                            intersectionPoints.get(yPoint)[1])) {
-                        cellsFound.add(new Cell(topLeft, btmRight));
-                        break outer;
-                    }
-                }
-            }
-        }
-
-        // TODO create cells for vertical ruling lines with aligned endpoints at the top/bottom of a grid
-        // that aren't connected with an horizontal ruler?
-        // see: https://github.com/jazzido/tabula-extractor/issues/78#issuecomment-41481207
-
-        return cellsFound;
+        return (double) cellsGroupedByRoundedWidth.size() / containedCells.size() <= TABLE_UNIFORMITY_THRESHOLD;
     }
 
 
-    private List<Rectangle> findSpreadsheetsFromCells(List<? extends Rectangle> cells) {
-        // via: http://stackoverflow.com/questions/13746284/merging-multiple-adjacent-rectangles-into-one-polygon
-        List<Rectangle> rectangles = new ArrayList<>();
-        Set<Point2D> pointSet = new HashSet<>();
-        Map<Point2D, Point2D> edgesH = new HashMap<>();
-        Map<Point2D, Point2D> edgesV = new HashMap<>();
-        int i = 0;
+    private boolean doesCellContainTextBlock(Cell cell, TextPageBlock textBlock) {
 
-        for (Rectangle cell : cells) {
-            for (Point2D pt : cell.getPoints()) {
-                if (pointSet.contains(pt)) { // shared vertex, remove it
-                    pointSet.remove(pt);
-                } else {
-                    pointSet.add(pt);
-                }
-            }
+        double x = textBlock.getPdfMinX();
+        double y = textBlock.getPdfMinY();
+        double w = textBlock.getPdfMaxX() - textBlock.getPdfMinX();
+        double h = textBlock.getPdfMaxY() - textBlock.getPdfMinY();
+        if (cell.isEmpty() || w <= 0 || h <= 0) {
+            return false;
         }
-
-        // X first sort
-        List<Point2D> pointsSortX = new ArrayList<>(pointSet);
-        pointsSortX.sort(X_FIRST_POINT_COMPARATOR);
-        // Y first sort
-        List<Point2D> pointsSortY = new ArrayList<>(pointSet);
-        pointsSortY.sort(POINT_COMPARATOR);
-
-        while (i < pointSet.size()) {
-            float currY = (float) pointsSortY.get(i).getY();
-            while (i < pointSet.size() && DoubleComparisons.feq(pointsSortY.get(i).getY(), currY)) {
-                edgesH.put(pointsSortY.get(i), pointsSortY.get(i + 1));
-                edgesH.put(pointsSortY.get(i + 1), pointsSortY.get(i));
-                i += 2;
-            }
-        }
-
-        i = 0;
-        while (i < pointSet.size()) {
-            float currX = (float) pointsSortX.get(i).getX();
-            while (i < pointSet.size() && DoubleComparisons.feq(pointsSortX.get(i).getX(), currX)) {
-                edgesV.put(pointsSortX.get(i), pointsSortX.get(i + 1));
-                edgesV.put(pointsSortX.get(i + 1), pointsSortX.get(i));
-                i += 2;
-            }
-        }
-
-        // Get all the polygons
-        List<List<PolygonVertex>> polygons = new ArrayList<>();
-        Point2D nextVertex;
-        while (!edgesH.isEmpty()) {
-            ArrayList<PolygonVertex> polygon = new ArrayList<>();
-            Point2D first = edgesH.keySet().iterator().next();
-            polygon.add(new PolygonVertex(first, Direction.HORIZONTAL));
-            edgesH.remove(first);
-
-            while (true) {
-                PolygonVertex curr = polygon.get(polygon.size() - 1);
-                PolygonVertex lastAddedVertex;
-                if (curr.direction == Direction.HORIZONTAL) {
-                    nextVertex = edgesV.get(curr.point);
-                    edgesV.remove(curr.point);
-                    lastAddedVertex = new PolygonVertex(nextVertex, Direction.VERTICAL);
-                } else {
-                    nextVertex = edgesH.get(curr.point);
-                    edgesH.remove(curr.point);
-                    lastAddedVertex = new PolygonVertex(nextVertex, Direction.HORIZONTAL);
-                }
-                polygon.add(lastAddedVertex);
-
-                if (lastAddedVertex.equals(polygon.get(0))) {
-                    // closed polygon
-                    polygon.remove(polygon.size() - 1);
-                    break;
-                }
-            }
-
-            for (PolygonVertex vertex : polygon) {
-                edgesH.remove(vertex.point);
-                edgesV.remove(vertex.point);
-            }
-            polygons.add(polygon);
-        }
-
-        // calculate grid-aligned minimum area rectangles for each found polygon
-        for (List<PolygonVertex> poly : polygons) {
-            float top = Float.MAX_VALUE;
-            float left = Float.MAX_VALUE;
-            float bottom = Float.MIN_VALUE;
-            float right = Float.MIN_VALUE;
-            for (PolygonVertex pt : poly) {
-                top = (float) Math.min(top, pt.point.getY());
-                left = (float) Math.min(left, pt.point.getX());
-                bottom = (float) Math.max(bottom, pt.point.getY());
-                right = (float) Math.max(right, pt.point.getX());
-            }
-            rectangles.add(new Rectangle(top, left, right - left, bottom - top));
-        }
-
-        return rectangles;
+        double x0 = cell.getX();
+        double y0 = cell.getY();
+        return (x >= x0 - TEXT_BLOCK_CONTAINMENT_TOLERANCE
+                && y >= y0 - TEXT_BLOCK_CONTAINMENT_TOLERANCE
+                && (x + w) <= x0 + cell.getWidth() + 2 * TEXT_BLOCK_CONTAINMENT_TOLERANCE
+                && (y + h) <= y0 + cell.getHeight() + 2 * TEXT_BLOCK_CONTAINMENT_TOLERANCE);
     }
 
 
-    private enum Direction {
-        HORIZONTAL,
-        VERTICAL
-    }
-
-    static class PolygonVertex {
-
-        Point2D point;
-        Direction direction;
-
-
-        PolygonVertex(Point2D point, Direction direction) {
-
-            this.direction = direction;
-            this.point = point;
-        }
-
-
-        @Override
-        public boolean equals(Object other) {
-
-            if (this == other) {
-                return true;
-            }
-            if (!(other instanceof PolygonVertex)) {
-                return false;
-            }
-            return this.point.equals(((PolygonVertex) other).point);
-        }
-
-
-        @Override
-        public int hashCode() {
-
-            return this.point.hashCode();
-        }
-
-
-        @Override
-        public String toString() {
-
-            return String.format("%s[point=%s,direction=%s]", this.getClass().getName(), this.point.toString(), this.direction.toString());
-        }
+    public static List<Cell> findCells(List<Ruling> horizontalRulingLines, List<Ruling> verticalRulingLines) {
 
+        return RectangularIntersectionFinder.find(horizontalRulingLines, verticalRulingLines)
+                .stream()
+                .map(Cell::new)
+                .collect(Collectors.toList());
     }
 
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/TextPositionSequenceSorter.java

@@ -1,74 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.services;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-import org.apache.pdfbox.Loader;
-import org.apache.pdfbox.pdmodel.PDDocument;
-import org.apache.pdfbox.pdmodel.PDPage;
-import org.springframework.core.io.ClassPathResource;
-
-import com.knecon.fforesight.service.layoutparser.processor.model.PageContents;
-import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
-import com.knecon.fforesight.service.layoutparser.processor.services.parsing.PDFLinesTextStripper;
-import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
-
-import lombok.experimental.UtilityClass;
-
-@UtilityClass
-public class TextPositionSequenceSorter {
-
-    public List<PageContents> getSortedTextPositionsWithPages(String filename) throws IOException {
-
-        List<PageContents> textPositionSequencesPerPage = new LinkedList<>();
-        try (InputStream inputStream = new ClassPathResource(filename).getInputStream()) {
-
-            try (PDDocument pdDocument = Loader.loadPDF(inputStream)) {
-
-                for (int pageNumber = 1; pageNumber < pdDocument.getNumberOfPages() + 1; pageNumber++) {
-
-                    PDFLinesTextStripper stripper = new PDFLinesTextStripper();
-                    PDPage pdPage = pdDocument.getPage(pageNumber - 1);
-                    stripper.setPageNumber(pageNumber);
-                    stripper.setSortByPosition(true);
-                    stripper.setStartPage(pageNumber);
-                    stripper.setEndPage(pageNumber);
-                    stripper.setPdpage(pdPage);
-                    stripper.getText(pdDocument);
-
-                    Map<Float, List<TextPositionSequence>> sortedTextPositionSequencesPerDir = stripper.getTextPositionSequences()
-                            .stream()
-                            .collect(Collectors.groupingBy(textPositionSequence -> textPositionSequence.getDir().getDegrees()));
-
-                    var sortedTextPositionSequences = sortByDirAccordingToPageRotation(sortedTextPositionSequencesPerDir, pdPage.getRotation());
-
-                    textPositionSequencesPerPage.add(new PageContents(sortedTextPositionSequences,
-                            RectangleTransformations.toRectangle2D(pdPage.getCropBox()),
-                            RectangleTransformations.toRectangle2D(pdPage.getMediaBox())));
-                }
-            }
-        }
-
-        return textPositionSequencesPerPage;
-    }
-
-
-    public List<TextPositionSequence> sortByDirAccordingToPageRotation(Map<Float, List<TextPositionSequence>> sortedTextPositionSequencesPerDir, int rotation) {
-
-        LinkedList<Float> sortedKeys = new LinkedList<>(sortedTextPositionSequencesPerDir.keySet().stream().sorted().toList());
-
-        for (int i = 0; i < sortedKeys.size(); i++) {
-            if (sortedKeys.get(i) < rotation) {
-                Float keyToSwap = sortedKeys.remove(i);
-                sortedKeys.addLast(keyToSwap);
-            }
-        }
-        return sortedKeys.stream().map(sortedTextPositionSequencesPerDir::get).flatMap(Collection::stream).toList();
-    }
-
-}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/blockification/DocuMineBlockificationService.java

@@ -5,6 +5,9 @@ import static java.util.stream.Collectors.toSet;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 import org.springframework.stereotype.Service;
 
@@ -23,6 +26,8 @@ public class DocuMineBlockificationService {
 
     static final float THRESHOLD = 1f;
 
+    Pattern pattern = Pattern.compile("^(\\d{1,2}\\.){1,3}\\d{1,2}\\.?\\s[0-9A-Za-z ()-]{2,50}", Pattern.CASE_INSENSITIVE);
+
 
     /**
      * This method is building blocks by expanding the minX/maxX and minY/maxY value on each word that is not split by the conditions.
@@ -43,7 +48,6 @@ public class DocuMineBlockificationService {
         float maxX = 0;
         float minY = 1000;
         float maxY = 0;
-
         TextPositionSequence prev = null;
 
         boolean wasSplitted = false;
@@ -60,7 +64,10 @@ public class DocuMineBlockificationService {
             boolean splitByOtherFontAndOtherY = prev != null && prev.getMaxYDirAdj() != word.getMaxYDirAdj() && (word.getFontStyle().contains("bold") && !prev.getFontStyle()
                     .contains("bold") || prev.getFontStyle().contains("bold") && !word.getFontStyle().contains("bold"));
 
-            if (prev != null && (lineSeparation || startFromTop || splitByDir || isSplitByRuling || splitByOtherFontAndOtherY || negativeXGap)) {
+            Matcher matcher = pattern.matcher(chunkWords.stream().collect(Collectors.joining(" ")).toString());
+            boolean startsOnSameX = Math.abs(minX - word.getMinXDirAdj()) < 5 && matcher.matches();
+
+            if (prev != null && (lineSeparation || startFromTop || splitByDir || isSplitByRuling || splitByOtherFontAndOtherY || negativeXGap || startsOnSameX)) {
 
                 Orientation prevOrientation = null;
                 if (!chunkBlockList1.isEmpty()) {
@@ -231,3 +238,4 @@ public class DocuMineBlockificationService {
     }
 
 }
+

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/blockification/TaasBlockificationService.java

@@ -1,13 +1,8 @@
 package com.knecon.fforesight.service.layoutparser.processor.services.blockification;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
-import org.springframework.stereotype.Service;
+// TODO: figure out, why this fails the build
+// import static com.knecon.fforesight.service.layoutparser.processor.services.factory.SearchTextWithTextPositionFactory.HEIGHT_PADDING;
 
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
@@ -16,14 +11,25 @@ import com.knecon.fforesight.service.layoutparser.processor.model.table.Ruling;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
 import com.knecon.fforesight.service.layoutparser.processor.utils.RulingTextDirAdjustUtil;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
 
 @Service
 @SuppressWarnings("all")
 public class TaasBlockificationService {
 
     private static final float THRESHOLD = 1f;
-    private static final float Y_GAP_SPLIT_HEIGHT_MODIFIER = 1.25f;
+    private static final float Y_GAP_SPLIT_HEIGHT_MODIFIER = 1.25f; // multiplied with text height
+    private static final float INTERSECTS_Y_THRESHOLD = 4;// 2 * HEIGHT_PADDING // This is exactly 2 times our position height padding. This is required to find boxes that are visually intersecting.
     private static final int X_GAP_SPLIT_CONSTANT = 50;
+    public static final int X_ALIGNMENT_THRESHOLD = 1;
+    public static final int NEGATIVE_X_GAP_THRESHOLD = -5;
+
+    private Pattern listIdentifier = Pattern.compile("^(?:(?:[1-9]|1\\d|20|[ivxlc]|[a-z])\\s*(?:[.)]))|\\uF0B7", Pattern.CASE_INSENSITIVE);
 
 
     /**
@@ -39,14 +45,28 @@ public class TaasBlockificationService {
     public ClassificationPage blockify(List<TextPositionSequence> textPositions, List<Ruling> horizontalRulingLines, List<Ruling> verticalRulingLines) {
 
         List<TextPageBlock> classificationTextBlocks = constructFineGranularTextPageBlocks(textPositions, horizontalRulingLines, verticalRulingLines);
-
-        classificationTextBlocks = mergeFineGranularTextPageBlocks(classificationTextBlocks);
+        classificationTextBlocks = mergeTextPageBlocksAligningX(classificationTextBlocks);
+        classificationTextBlocks = mergeIntersectingTextBlocksUntilConvergence(classificationTextBlocks);
 
         return new ClassificationPage(new ArrayList<>(classificationTextBlocks.stream().map(classificationTextBlock -> (AbstractPageBlock) classificationTextBlock).toList()));
     }
 
 
-    private List<TextPageBlock> mergeFineGranularTextPageBlocks(List<TextPageBlock> classificationTextBlocks) {
+    private List<TextPageBlock> mergeIntersectingTextBlocksUntilConvergence(List<TextPageBlock> classificationTextBlocks) {
+
+        int currentSize = classificationTextBlocks.size();
+        while (true) {
+            classificationTextBlocks = mergeTextPageBlocksAlmostIntersecting(classificationTextBlocks);
+            if (classificationTextBlocks.size() == currentSize) {
+                break;
+            }
+            currentSize = classificationTextBlocks.size();
+        }
+        return classificationTextBlocks;
+    }
+
+
+    private List<TextPageBlock> mergeTextPageBlocksAligningX(List<TextPageBlock> classificationTextBlocks) {
 
         if (classificationTextBlocks.isEmpty()) {
             return new ArrayList<>();
@@ -55,16 +75,29 @@ public class TaasBlockificationService {
         List<TextPageBlock> currentTextBlocksToMerge = new LinkedList<>();
         textBlocksToMerge.add(currentTextBlocksToMerge);
         TextPageBlock previousTextBlock = null;
+        Float lastLineGap = null;
         for (TextPageBlock currentTextBlock : classificationTextBlocks) {
             if (previousTextBlock == null) {
                 currentTextBlocksToMerge.add(currentTextBlock);
                 previousTextBlock = currentTextBlock;
                 continue;
             }
-            boolean alignsXRight = Math.abs(currentTextBlock.getPdfMaxX() - previousTextBlock.getPdfMaxX()) < 1;
-            boolean smallYGap = Math.abs(currentTextBlock.getPdfMaxY() - previousTextBlock.getPdfMinY()) < 5;
-            if (alignsXRight && smallYGap) {
+
+
+            Matcher listIdentifierPattern = listIdentifier.matcher(currentTextBlock.getText());
+            boolean isListIdentifier = listIdentifierPattern.find();
+
+            boolean yGap = Math.abs(currentTextBlock.getPdfMaxY() - previousTextBlock.getPdfMinY()) < previousTextBlock.getMostPopularWordHeight() * Y_GAP_SPLIT_HEIGHT_MODIFIER;
+
+            boolean sameFont = previousTextBlock.getMostPopularWordFont().equals(currentTextBlock.getMostPopularWordFont()) && previousTextBlock.getMostPopularWordFontSize() == currentTextBlock.getMostPopularWordFontSize();
+//            boolean yGap = previousTextBlock != null && currentTextBlock.getMinYDirAdj() - maxY > Math.min(word.getHeight(), prev.getHeight()) * Y_GAP_SPLIT_HEIGHT_MODIFIER;
+
+            boolean alignsXRight = Math.abs(currentTextBlock.getPdfMaxX() - previousTextBlock.getPdfMaxX()) < X_ALIGNMENT_THRESHOLD;
+            boolean alignsXLeft = Math.abs(currentTextBlock.getPdfMinX() - previousTextBlock.getPdfMinX()) < X_ALIGNMENT_THRESHOLD;
+//            boolean smallYGap = Math.abs(currentTextBlock.getPdfMaxY() - previousTextBlock.getPdfMinY()) < yGap;
+            if (yGap && sameFont && !isListIdentifier) {
                 currentTextBlocksToMerge.add(currentTextBlock);
+
             } else {
                 currentTextBlocksToMerge = new LinkedList<>();
                 currentTextBlocksToMerge.add(currentTextBlock);
@@ -76,6 +109,23 @@ public class TaasBlockificationService {
     }
 
 
+    private List<TextPageBlock> mergeTextPageBlocksAlmostIntersecting(List<TextPageBlock> textPageBlocks) {
+
+        Set<TextPageBlock> alreadyMerged = new HashSet<>();
+        List<List<TextPageBlock>> textBlocksToMerge = new LinkedList<>();
+        for (TextPageBlock textPageBlock : textPageBlocks) {
+            if (alreadyMerged.contains(textPageBlock)) {
+                continue;
+            }
+            alreadyMerged.add(textPageBlock);
+            textBlocksToMerge.add(Stream.concat(Stream.of(textPageBlock),
+                            textPageBlocks.stream().filter(textPageBlock2 -> textPageBlock.almostIntersects(textPageBlock2, INTERSECTS_Y_THRESHOLD, 0) && !alreadyMerged.contains(textPageBlock2)).peek(alreadyMerged::add))
+                    .toList());
+        }
+        return textBlocksToMerge.stream().map(TextPageBlock::merge).toList();
+    }
+
+
     private void assignOrientations(List<TextPageBlock> classificationTextBlocks) {
 
         Iterator<TextPageBlock> itty = classificationTextBlocks.iterator();
@@ -128,8 +178,8 @@ public class TaasBlockificationService {
 
 
     private List<TextPageBlock> constructFineGranularTextPageBlocks(List<TextPositionSequence> textPositions,
-                                                                                        List<Ruling> horizontalRulingLines,
-                                                                                        List<Ruling> verticalRulingLines) {
+                                                                    List<Ruling> horizontalRulingLines,
+                                                                    List<Ruling> verticalRulingLines) {
 
         int indexOnPage = 0;
         List<TextPositionSequence> wordClusterToCombine = new ArrayList<>();
@@ -138,18 +188,18 @@ public class TaasBlockificationService {
         float minX = 1000, maxX = 0, minY = 1000, maxY = 0;
         TextPositionSequence prev = null;
         // TODO: make static final constant
-        var listIdentitifier = Pattern.compile("\\b(?:[1-9]|1\\d|20|[ivxlc]|[a-z])\\s*(?:[.)])", Pattern.CASE_INSENSITIVE);
+
 
         boolean wasSplitted = false;
         Float splitX1 = null;
         for (TextPositionSequence word : textPositions) {
 
-            Matcher listIdentifierPattern = listIdentitifier.matcher(word.toString());
+            Matcher listIdentifierPattern = listIdentifier.matcher(word.toString());
 
             boolean yGap = prev != null && word.getMinYDirAdj() - maxY > Math.min(word.getHeight(), prev.getHeight()) * Y_GAP_SPLIT_HEIGHT_MODIFIER;
             boolean sameLine = prev != null && equalsWithThreshold(prev.getMinYDirAdj(), word.getMinYDirAdj());
             boolean positiveXGapInline = prev != null && maxX + X_GAP_SPLIT_CONSTANT < word.getMinXDirAdj() && sameLine;
-            boolean negativeXGap = prev != null && word.getMinXDirAdj() - minX < -5;
+            boolean negativeXGap = prev != null && word.getMinXDirAdj() - minX < NEGATIVE_X_GAP_THRESHOLD;
             boolean startFromTop = prev != null && word.getMinYDirAdj() < prev.getMinYDirAdj() - prev.getTextHeight();
             boolean newLineAfterSplit = prev != null && word.getMinYDirAdj() != prev.getMinYDirAdj() && wasSplitted && splitX1 != word.getMinXDirAdj();
             boolean splitByRuling = isSplitByRuling(minX, minY, maxX, maxY, word, horizontalRulingLines, verticalRulingLines);
@@ -164,7 +214,7 @@ public class TaasBlockificationService {
 
                 Orientation prevOrientation = null;
                 if (!classificationTextBlocks.isEmpty()) {
-                    prevOrientation = classificationTextBlocks.get(classificationTextBlocks.size() - 1).getOrientation();
+                    prevOrientation = classificationTextBlocks.get(classificationTextBlocks.size() - X_ALIGNMENT_THRESHOLD).getOrientation();
                 }
 
                 TextPageBlock classificationTextBlock = TextPageBlock.fromTextPositionSequences(wordClusterToCombine);

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/classification/DocuMineClassificationService.java

@@ -5,43 +5,36 @@ import java.util.Locale;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import com.knecon.fforesight.service.layoutparser.processor.utils.MarkedContentUtils;
 import org.springframework.stereotype.Service;
 
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Rectangle;
-import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingType;
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationDocument;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
 import com.knecon.fforesight.service.layoutparser.processor.model.PageBlockType;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.services.BodyTextFrameService;
 import com.knecon.fforesight.service.layoutparser.processor.utils.PositionUtils;
 
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
-
 @Slf4j
 @Service
 @RequiredArgsConstructor
 public class DocuMineClassificationService {
 
-    private final BodyTextFrameService bodyTextFrameService;
-    private static final Pattern pattern = Pattern.compile("^(\\d{1,1}\\.?){1,3}\\d{1,2}\\.?\\s[0-9A-Za-z\\[\\]\\-]{2,50}", Pattern.CASE_INSENSITIVE);
-    private static final Pattern pattern2 = Pattern.compile(".*\\d{4}$", Pattern.CASE_INSENSITIVE);
+    private static final Pattern pattern = Pattern.compile("^(\\d{1,2}\\.){1,3}\\d{1,2}\\.?\\s[0-9A-Za-z \\[\\]]{2,50}", Pattern.CASE_INSENSITIVE);
+    private static final Pattern pattern2 = Pattern.compile("\\p{L}{3,}", Pattern.CASE_INSENSITIVE);
     private static final Pattern pattern3 = Pattern.compile("^(\\d{1,1}\\.){1,3}\\d{1,2}\\.?\\s[a-z]{1,2}\\/[a-z]{1,2}.*");
 
 
     public void classifyDocument(ClassificationDocument document) {
 
-        Rectangle bodyTextFrame = bodyTextFrameService.calculateBodyTextFrame(document.getPages(), document.getFontSizeCounter(), false, LayoutParsingType.DOCUMINE);
-        Rectangle landscapeBodyTextFrame = bodyTextFrameService.calculateBodyTextFrame(document.getPages(), document.getFontSizeCounter(), true, LayoutParsingType.DOCUMINE);
         List<Float> headlineFontSizes = document.getFontSizeCounter().getHighterThanMostPopular();
 
         log.debug("Document FontSize counters are: {}", document.getFontSizeCounter().getCountPerValue());
 
         for (ClassificationPage page : document.getPages()) {
-            bodyTextFrameService.setBodyTextFrameAdjustedToPage(page, bodyTextFrame, landscapeBodyTextFrame);
             classifyPage(page, document, headlineFontSizes);
         }
     }
@@ -70,12 +63,16 @@ public class DocuMineClassificationService {
             textBlock.setClassification(PageBlockType.OTHER);
             return;
         }
-        if (PositionUtils.isOverBodyTextFrame(bodyTextFrame, textBlock, page.getRotation()) && (document.getFontSizeCounter()
-                .getMostPopular() == null || textBlock.getHighestFontSize() <= document.getFontSizeCounter().getMostPopular())) {
+        if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.HEADER)
+                || PositionUtils.isOverBodyTextFrame(bodyTextFrame, textBlock, page.getRotation()) && (document.getFontSizeCounter()
+                .getMostPopular() == null || textBlock.getHighestFontSize() <= document.getFontSizeCounter().getMostPopular())
+        ) {
             textBlock.setClassification(PageBlockType.HEADER);
 
-        } else if (PositionUtils.isUnderBodyTextFrame(bodyTextFrame, textBlock, page.getRotation()) && (document.getFontSizeCounter()
-                .getMostPopular() == null || textBlock.getHighestFontSize() <= document.getFontSizeCounter().getMostPopular())) {
+        } else if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.FOOTER)
+                || PositionUtils.isUnderBodyTextFrame(bodyTextFrame, textBlock, page.getRotation()) && (document.getFontSizeCounter()
+                .getMostPopular() == null || textBlock.getHighestFontSize() <= document.getFontSizeCounter().getMostPopular())
+        ) {
             textBlock.setClassification(PageBlockType.FOOTER);
         } else if (page.getPageNumber() == 1 && (PositionUtils.getHeightDifferenceBetweenChunkWordAndDocumentWord(textBlock,
                 document.getTextHeightCounter().getMostPopular()) > 2.5 && textBlock.getHighestFontSize() > document.getFontSizeCounter().getMostPopular() || page.getTextBlocks()
@@ -115,4 +112,4 @@ public class DocuMineClassificationService {
         }
     }
 
-}
+}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/classification/RedactManagerClassificationService.java

@@ -3,16 +3,14 @@ package com.knecon.fforesight.service.layoutparser.processor.services.classifica
 import java.util.List;
 import java.util.regex.Pattern;
 
+import com.knecon.fforesight.service.layoutparser.processor.utils.MarkedContentUtils;
 import org.springframework.stereotype.Service;
 
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Rectangle;
-import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingType;
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationDocument;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
 import com.knecon.fforesight.service.layoutparser.processor.model.PageBlockType;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.services.BodyTextFrameService;
 import com.knecon.fforesight.service.layoutparser.processor.utils.PositionUtils;
 
 import lombok.RequiredArgsConstructor;
@@ -23,19 +21,14 @@ import lombok.extern.slf4j.Slf4j;
 @RequiredArgsConstructor
 public class RedactManagerClassificationService {
 
-    private final BodyTextFrameService bodyTextFrameService;
-
 
     public void classifyDocument(ClassificationDocument document) {
 
-        Rectangle bodyTextFrame = bodyTextFrameService.calculateBodyTextFrame(document.getPages(), document.getFontSizeCounter(), false, LayoutParsingType.REDACT_MANAGER);
-        Rectangle landscapeBodyTextFrame = bodyTextFrameService.calculateBodyTextFrame(document.getPages(), document.getFontSizeCounter(), true, LayoutParsingType.REDACT_MANAGER);
         List<Float> headlineFontSizes = document.getFontSizeCounter().getHighterThanMostPopular();
 
         log.debug("Document FontSize counters are: {}", document.getFontSizeCounter().getCountPerValue());
 
         for (ClassificationPage page : document.getPages()) {
-            bodyTextFrameService.setBodyTextFrameAdjustedToPage(page, bodyTextFrame, landscapeBodyTextFrame);
             classifyPage(page, document, headlineFontSizes);
         }
     }
@@ -59,11 +52,13 @@ public class RedactManagerClassificationService {
             textBlock.setClassification(PageBlockType.OTHER);
             return;
         }
-        if (PositionUtils.isOverBodyTextFrame(bodyTextFrame, textBlock, page.getRotation()) && (document.getFontSizeCounter()
+        if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.HEADER)
+                || PositionUtils.isOverBodyTextFrame(bodyTextFrame, textBlock, page.getRotation()) && (document.getFontSizeCounter()
                 .getMostPopular() == null || textBlock.getHighestFontSize() <= document.getFontSizeCounter().getMostPopular())) {
             textBlock.setClassification(PageBlockType.HEADER);
 
-        } else if (PositionUtils.isUnderBodyTextFrame(bodyTextFrame, textBlock, page.getRotation()) && (document.getFontSizeCounter()
+        } else if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.FOOTER)
+                || PositionUtils.isUnderBodyTextFrame(bodyTextFrame, textBlock, page.getRotation()) && (document.getFontSizeCounter()
                 .getMostPopular() == null || textBlock.getHighestFontSize() <= document.getFontSizeCounter().getMostPopular())) {
             textBlock.setClassification(PageBlockType.FOOTER);
         } else if (page.getPageNumber() == 1 && (PositionUtils.getHeightDifferenceBetweenChunkWordAndDocumentWord(textBlock,

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/classification/TaasClassificationService.java

@@ -3,10 +3,9 @@ package com.knecon.fforesight.service.layoutparser.processor.services.classifica
 import java.util.List;
 import java.util.regex.Pattern;
 
+import com.knecon.fforesight.service.layoutparser.processor.utils.MarkedContentUtils;
 import org.springframework.stereotype.Service;
 
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Rectangle;
-import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingType;
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationDocument;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
@@ -28,14 +27,13 @@ public class TaasClassificationService {
 
     public void classifyDocument(ClassificationDocument document) {
 
-        Rectangle bodyTextFrame = bodyTextFrameService.calculateBodyTextFrame(document.getPages(), document.getFontSizeCounter(), false, LayoutParsingType.TAAS);
-        Rectangle landscapeBodyTextFrame = bodyTextFrameService.calculateBodyTextFrame(document.getPages(), document.getFontSizeCounter(), true, LayoutParsingType.TAAS);
+
         List<Float> headlineFontSizes = document.getFontSizeCounter().getHighterThanMostPopular();
 
         log.debug("Document FontSize counters are: {}", document.getFontSizeCounter().getCountPerValue());
 
         for (ClassificationPage page : document.getPages()) {
-            bodyTextFrameService.setBodyTextFrameAdjustedToPage(page, bodyTextFrame, landscapeBodyTextFrame);
+
             classifyPage(page, document, headlineFontSizes);
         }
     }
@@ -59,9 +57,11 @@ public class TaasClassificationService {
             textBlock.setClassification(PageBlockType.OTHER);
             return;
         }
-        if (PositionUtils.isOverBodyTextFrame(bodyTextFrame, textBlock, page.getRotation())) {
+        if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.HEADER)
+                || PositionUtils.isOverBodyTextFrame(bodyTextFrame, textBlock, page.getRotation())) {
             textBlock.setClassification(PageBlockType.HEADER);
-        } else if (PositionUtils.isUnderBodyTextFrame(bodyTextFrame, textBlock, page.getRotation())) {
+        } else if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.FOOTER)
+                || PositionUtils.isUnderBodyTextFrame(bodyTextFrame, textBlock, page.getRotation())) {
             textBlock.setClassification(PageBlockType.FOOTER);
         } else if (page.getPageNumber() == 1 && (PositionUtils.getHeightDifferenceBetweenChunkWordAndDocumentWord(textBlock,
                 document.getTextHeightCounter().getMostPopular()) > 2.5 && textBlock.getHighestFontSize() > document.getFontSizeCounter().getMostPopular() || page.getTextBlocks()

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/factory/DocumentGraphFactory.java

@@ -64,7 +64,7 @@ public class DocumentGraphFactory {
 
     private void addSections(ClassificationDocument document, Context context) {
 
-        document.getSections().forEach(section -> SectionNodeFactory.addSection(null, section.getPageBlocks(), section.getImages(), context));
+        document.getSections().forEach(section -> SectionNodeFactory.addSection(null, section.getNonEmptyPageBlocks(), section.getImages(), context));
     }
 
 
@@ -105,8 +105,8 @@ public class DocumentGraphFactory {
                 .build();
         page.getMainBody().add(imageNode);
 
-        List<Integer> tocId = context.getDocumentTree().createNewChildEntryAndReturnId(section, imageNode);
-        imageNode.setTreeId(tocId);
+        List<Integer> treeId = context.getDocumentTree().createNewChildEntryAndReturnId(section, imageNode);
+        imageNode.setTreeId(treeId);
     }
 
 

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/factory/SearchTextWithTextPositionFactory.java

@@ -133,7 +133,7 @@ public class SearchTextWithTextPositionFactory {
 
     private static void addTextPositionWithFontType(RedTextPosition currentTextPosition, String fontType, List<Integer> fontTypePositions, int stringIdx) {
 
-        if (currentTextPosition.getFontName().toLowerCase(Locale.ROOT).contains(fontType)) {
+        if (currentTextPosition.getFontName() != null && currentTextPosition.getFontName().toLowerCase(Locale.ROOT).contains(fontType)) {
             fontTypePositions.add(stringIdx);
         }
     }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/factory/TableNodeFactory.java

@@ -32,7 +32,12 @@ public class TableNodeFactory {
         setPageNumberInCells(tablesToMerge);
         Set<Page> pages = tablesToMerge.stream().map(AbstractPageBlock::getPage).map(context::getPage).collect(Collectors.toSet());
         List<List<Cell>> mergedRows = tablesToMerge.stream().map(TablePageBlock::getRows).flatMap(Collection::stream).toList();
-        Table table = Table.builder().documentTree(context.getDocumentTree()).numberOfCols(mergedRows.get(0).size()).numberOfRows(mergedRows.size()).build();
+
+        Table table = Table.builder()
+                .documentTree(context.getDocumentTree())
+                .numberOfCols(mergedRows.isEmpty() ? 0 : mergedRows.get(0).size())
+                .numberOfRows(mergedRows.size())
+                .build();
 
         pages.forEach(page -> addTableToPage(page, parentNode, table));
 

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/mapper/PropertiesMapper.java

@@ -1,36 +1,27 @@
 package com.knecon.fforesight.service.layoutparser.processor.services.mapper;
 
 import java.awt.geom.Rectangle2D;
-import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
-import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentStructure;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Image;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.ImageType;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.TableCell;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Page;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Table;
-import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.TableCell;
 
 public class PropertiesMapper {
 
-    public static final String TRANSPARENT = "transparent";
-    public static final String IMAGE_TYPE = "imageType";
-    public static final String POSITION = "position";
-    public static final String ROW = "row";
-    public static final String COL = "col";
-    public static final String HEADER = "header";
-    public static final String B_BOX = "bBox";
-    public static final String NUMBER_OF_ROWS = "numberOfRows";
-    public static final String NUMBER_OF_COLS = "numberOfCols";
-
-
     public static Map<String, String> buildImageProperties(Image image) {
 
         Map<String, String> properties = new HashMap<>();
-        properties.put(IMAGE_TYPE, image.getImageType().toString());
-        properties.put(TRANSPARENT, String.valueOf(image.isTransparent()));
-        properties.put(POSITION, RectangleTransformations.toString(image.getPosition()));
+        properties.put(DocumentStructure.ImageProperties.IMAGE_TYPE, image.getImageType().toString());
+        properties.put(DocumentStructure.ImageProperties.TRANSPARENT, String.valueOf(image.isTransparent()));
+        properties.put(DocumentStructure.ImageProperties.POSITION, toString(image.getPosition()));
+        properties.put(DocumentStructure.ImageProperties.ID, image.getId());
         return properties;
     }
 
@@ -38,15 +29,15 @@ public class PropertiesMapper {
     public static Map<String, String> buildTableCellProperties(TableCell tableCell) {
 
         Map<String, String> properties = new HashMap<>();
-        properties.put(ROW, String.valueOf(tableCell.getRow()));
-        properties.put(COL, String.valueOf(tableCell.getCol()));
-        properties.put(HEADER, String.valueOf(tableCell.isHeader()));
+        properties.put(DocumentStructure.TableCellProperties.ROW, String.valueOf(tableCell.getRow()));
+        properties.put(DocumentStructure.TableCellProperties.COL, String.valueOf(tableCell.getCol()));
+        properties.put(DocumentStructure.TableCellProperties.HEADER, String.valueOf(tableCell.isHeader()));
 
         if (tableCell.getPages().size() > 1 || tableCell.getBBox().keySet().size() > 1) {
             throw new IllegalArgumentException("TableCell can only occur on a single page!");
         }
-        String bBoxString = RectangleTransformations.toString(tableCell.getBBox().get(tableCell.getPages().stream().findFirst().get()));
-        properties.put(B_BOX, bBoxString);
+        String bBoxString = toString(tableCell.getBBox().get(tableCell.getPages().stream().findFirst().get()));
+        properties.put(DocumentStructure.TableCellProperties.B_BOX, bBoxString);
 
         return properties;
     }
@@ -55,33 +46,33 @@ public class PropertiesMapper {
     public static Map<String, String> buildTableProperties(Table table) {
 
         Map<String, String> properties = new HashMap<>();
-        properties.put(NUMBER_OF_ROWS, String.valueOf(table.getNumberOfRows()));
-        properties.put(NUMBER_OF_COLS, String.valueOf(table.getNumberOfCols()));
+        properties.put(DocumentStructure.TableProperties.NUMBER_OF_ROWS, String.valueOf(table.getNumberOfRows()));
+        properties.put(DocumentStructure.TableProperties.NUMBER_OF_COLS, String.valueOf(table.getNumberOfCols()));
         return properties;
     }
 
 
     public static void parseImageProperties(Map<String, String> properties, Image.ImageBuilder builder) {
 
-        builder.imageType(parseImageType(properties.get(IMAGE_TYPE)));
-        builder.transparent(Boolean.parseBoolean(properties.get(TRANSPARENT)));
-        builder.position(parseRectangle2D(properties.get(POSITION)));
+        builder.imageType(parseImageType(properties.get(DocumentStructure.ImageProperties.IMAGE_TYPE)));
+        builder.transparent(Boolean.parseBoolean(properties.get(DocumentStructure.ImageProperties.TRANSPARENT)));
+        builder.position(DocumentStructure.parseRectangle2D(properties.get(DocumentStructure.ImageProperties.POSITION)));
     }
 
 
     public static void parseTableCellProperties(Map<String, String> properties, TableCell.TableCellBuilder builder) {
 
-        builder.row(Integer.parseInt(properties.get(ROW)));
-        builder.col(Integer.parseInt(properties.get(COL)));
-        builder.header(Boolean.parseBoolean(properties.get(HEADER)));
-        builder.bBox(parseRectangle2D(properties.get(B_BOX)));
+        builder.row(Integer.parseInt(properties.get(DocumentStructure.TableCellProperties.ROW)));
+        builder.col(Integer.parseInt(properties.get(DocumentStructure.TableCellProperties.COL)));
+        builder.header(Boolean.parseBoolean(properties.get(DocumentStructure.TableCellProperties.HEADER)));
+        builder.bBox(DocumentStructure.parseRectangle2D(properties.get(DocumentStructure.TableCellProperties.B_BOX)));
     }
 
 
     public static void parseTableProperties(Map<String, String> properties, Table.TableBuilder builder) {
 
-        builder.numberOfRows(Integer.parseInt(properties.get(NUMBER_OF_ROWS)));
-        builder.numberOfCols(Integer.parseInt(properties.get(NUMBER_OF_COLS)));
+        builder.numberOfRows(Integer.parseInt(properties.get(DocumentStructure.TableProperties.NUMBER_OF_ROWS)));
+        builder.numberOfCols(Integer.parseInt(properties.get(DocumentStructure.TableProperties.NUMBER_OF_COLS)));
     }
 
 
@@ -99,14 +90,15 @@ public class PropertiesMapper {
 
     public static String toString(Rectangle2D rectangle2D) {
 
-        return String.format("%f,%f,%f,%f", rectangle2D.getX(), rectangle2D.getY(), rectangle2D.getWidth(), rectangle2D.getHeight());
-    }
-
-
-    public static Rectangle2D parseRectangle2D(String bBox) {
-
-        List<Float> floats = Arrays.stream(bBox.split(",")).map(Float::parseFloat).toList();
-        return new Rectangle2D.Float(floats.get(0), floats.get(1), floats.get(2), floats.get(3));
+        return String.format(Locale.US,
+                "%f%s%f%s%f%s%f",
+                rectangle2D.getX(),
+                DocumentStructure.RECTANGLE_DELIMITER,
+                rectangle2D.getY(),
+                DocumentStructure.RECTANGLE_DELIMITER,
+                rectangle2D.getWidth(),
+                DocumentStructure.RECTANGLE_DELIMITER,
+                rectangle2D.getHeight());
     }
 
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/parsing/LegacyPDFStreamEngine.java

@@ -92,28 +92,28 @@ public class LegacyPDFStreamEngine extends PDFStreamEngine {
      */
     LegacyPDFStreamEngine() throws IOException {
 
-        addOperator(new BeginText());
-        addOperator(new Concatenate());
-        addOperator(new DrawObject()); // special text version
-        addOperator(new EndText());
-        addOperator(new SetGraphicsStateParameters());
-        addOperator(new Save());
-        addOperator(new Restore());
-        addOperator(new NextLine());
-        addOperator(new SetCharSpacing());
-        addOperator(new MoveText());
-        addOperator(new MoveTextSetLeading());
-        addOperator(new SetFontAndSize());
-        addOperator(new ShowText());
-        addOperator(new ShowTextAdjusted());
-        addOperator(new SetTextLeading());
-        addOperator(new SetMatrix());
-        addOperator(new SetTextRenderingMode());
-        addOperator(new SetTextRise());
-        addOperator(new SetWordSpacing());
-        addOperator(new SetTextHorizontalScaling());
-        addOperator(new ShowTextLine());
-        addOperator(new ShowTextLineAndSpace());
+        addOperator(new BeginText(this));
+        addOperator(new Concatenate(this));
+        addOperator(new DrawObject(this)); // special text version
+        addOperator(new EndText(this));
+        addOperator(new SetGraphicsStateParameters(this));
+        addOperator(new Save(this));
+        addOperator(new Restore(this));
+        addOperator(new NextLine(this));
+        addOperator(new SetCharSpacing(this));
+        addOperator(new MoveText(this));
+        addOperator(new MoveTextSetLeading(this));
+        addOperator(new SetFontAndSize(this));
+        addOperator(new ShowText(this));
+        addOperator(new ShowTextAdjusted(this));
+        addOperator(new SetTextLeading(this));
+        addOperator(new SetMatrix(this));
+        addOperator(new SetTextRenderingMode(this));
+        addOperator(new SetTextRise(this));
+        addOperator(new SetWordSpacing(this));
+        addOperator(new SetTextHorizontalScaling(this));
+        addOperator(new ShowTextLine(this));
+        addOperator(new ShowTextLineAndSpace(this));
 
         // load additional glyph list for Unicode mapping
         String path = "/org/apache/pdfbox/resources/glyphlist/additional.txt";

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/parsing/PDFLinesTextStripper.java

@@ -20,6 +20,8 @@ import org.apache.pdfbox.contentstream.operator.color.SetStrokingColorSpace;
 import org.apache.pdfbox.contentstream.operator.color.SetStrokingDeviceCMYKColor;
 import org.apache.pdfbox.contentstream.operator.color.SetStrokingDeviceGrayColor;
 import org.apache.pdfbox.contentstream.operator.color.SetStrokingDeviceRGBColor;
+import org.apache.pdfbox.contentstream.operator.markedcontent.BeginMarkedContentSequenceWithProperties;
+import org.apache.pdfbox.contentstream.operator.markedcontent.EndMarkedContentSequence;
 import org.apache.pdfbox.contentstream.operator.state.SetFlatness;
 import org.apache.pdfbox.contentstream.operator.state.SetLineCapStyle;
 import org.apache.pdfbox.contentstream.operator.state.SetLineDashPattern;
@@ -53,10 +55,6 @@ public class PDFLinesTextStripper extends PDFTextStripper {
     private final List<Ruling> graphicsPath = new ArrayList<>();
     @Setter
     protected PDPage pdpage;
-    private int minCharWidth;
-    private int maxCharWidth;
-    private int minCharHeight;
-    private int maxCharHeight;
 
     private float path_x;
     private float path_y;
@@ -68,26 +66,30 @@ public class PDFLinesTextStripper extends PDFTextStripper {
     public PDFLinesTextStripper() throws IOException {
 
         super();
-        this.addOperator(new SetStrokingColorSpace());
-        this.addOperator(new SetNonStrokingColorSpace());
-        this.addOperator(new SetLineDashPattern());
-        this.addOperator(new SetStrokingDeviceGrayColor());
-        this.addOperator(new SetNonStrokingDeviceGrayColor());
-        this.addOperator(new SetFlatness());
-        this.addOperator(new SetLineJoinStyle());
-        this.addOperator(new SetLineCapStyle());
-        this.addOperator(new SetStrokingDeviceCMYKColor());
-        this.addOperator(new SetNonStrokingDeviceCMYKColor());
-        this.addOperator(new SetLineMiterLimit());
-        this.addOperator(new SetStrokingDeviceRGBColor());
-        this.addOperator(new SetNonStrokingDeviceRGBColor());
-        this.addOperator(new SetRenderingIntent());
-        this.addOperator(new SetStrokingColor());
-        this.addOperator(new SetNonStrokingColor());
-        this.addOperator(new SetStrokingColorN());
-        this.addOperator(new SetNonStrokingColorN());
-        this.addOperator(new SetFontAndSize());
-        this.addOperator(new SetLineWidth());
+        this.addOperator(new SetStrokingColorSpace(this));
+        this.addOperator(new SetNonStrokingColorSpace(this));
+        this.addOperator(new SetLineDashPattern(this));
+        this.addOperator(new SetStrokingDeviceGrayColor(this));
+        this.addOperator(new SetNonStrokingDeviceGrayColor(this));
+        this.addOperator(new SetFlatness(this));
+        this.addOperator(new SetLineJoinStyle(this));
+        this.addOperator(new SetLineCapStyle(this));
+        this.addOperator(new SetStrokingDeviceCMYKColor(this));
+        this.addOperator(new SetNonStrokingDeviceCMYKColor(this));
+        this.addOperator(new SetLineMiterLimit(this));
+        this.addOperator(new SetStrokingDeviceRGBColor(this));
+        this.addOperator(new SetNonStrokingDeviceRGBColor(this));
+        this.addOperator(new SetRenderingIntent(this));
+        this.addOperator(new SetStrokingColor(this));
+        this.addOperator(new SetNonStrokingColor(this));
+        this.addOperator(new SetStrokingColorN(this));
+        this.addOperator(new SetNonStrokingColorN(this));
+        this.addOperator(new SetFontAndSize(this));
+        this.addOperator(new SetLineWidth(this));
+
+        addOperator(new BeginMarkedContentSequenceWithProperties(this));
+//        addOperator(new BeginMarkedContentSequence(this));
+        addOperator(new EndMarkedContentSequence(this));
     }
 
 
@@ -98,6 +100,7 @@ public class PDFLinesTextStripper extends PDFTextStripper {
 
         //move
         switch (operation) {
+
             case OperatorName.MOVE_TO:
                 if (arguments.size() == 2) {
                     Point2D.Float pos = transformPosition(floatValue(arguments.get(0)), floatValue(arguments.get(1)));
@@ -219,7 +222,11 @@ public class PDFLinesTextStripper extends PDFTextStripper {
             // This is a quick and dirt hack
             // Happens for file 216.pdf
             log.debug(e.getMessage());
-            return color.getComponents()[0] == 0 && color.getComponents()[1] == 0 && color.getComponents()[2] == 0 && color.getComponents()[1] == 1;
+            var result = true;
+            for (var component : color.getComponents()) {
+                result = result && component == 0;
+            }
+            return result;
         }
     }
 
@@ -238,33 +245,15 @@ public class PDFLinesTextStripper extends PDFTextStripper {
                         .get(textPositionSequences.get(textPositionSequences.size() - 1).getTextPositions().size() - 1);
             }
 
-            int charWidth = (int) textPositions.get(i).getWidthDirAdj();
-            if (charWidth < minCharWidth) {
-                minCharWidth = charWidth;
-            }
-            if (charWidth > maxCharWidth) {
-                maxCharWidth = charWidth;
-            }
-
-            int charHeight = (int) textPositions.get(i).getHeightDir();
-            if (charHeight < minCharHeight) {
-                minCharHeight = charHeight;
-            }
-            if (charWidth > maxCharHeight) {
-                maxCharHeight = charHeight;
-            }
-
             if (i == 0 && (textPositions.get(i).getUnicode().equals(" ") || textPositions.get(i).getUnicode().equals("\u00A0") || textPositions.get(i).getUnicode().equals("\t"))) {
                 startIndex++;
                 continue;
             }
 
             // Strange but sometimes this is happening, for example: Metolachlor2.pdf
-            if (i > 0 && textPositions.get(i).getXDirAdj() < textPositions.get(i - 1).getXDirAdj()) {
+            if (checkIfCurrentPositionIsToTheRightOfPreviousPosition(i, textPositions)) {
                 List<TextPosition> sublist = textPositions.subList(startIndex, i);
-                if (!(sublist.isEmpty() || sublist.size() == 1 && (sublist.get(0).getUnicode().equals(" ") || sublist.get(0).getUnicode().equals("\u00A0") || sublist.get(0)
-                        .getUnicode()
-                        .equals("\t")))) {
+                if (checkIfSequenceContainsOnlyWhitespaces(sublist)) {
                     textPositionSequences.add(new TextPositionSequence(sublist, pageNumber, i == textPositions.size() - 1 && isParagraphStart));
                 }
                 startIndex = i;
@@ -272,9 +261,7 @@ public class PDFLinesTextStripper extends PDFTextStripper {
 
             if (textPositions.get(i).getRotation() == 0 && i > 0 && textPositions.get(i).getX() > textPositions.get(i - 1).getEndX() + 1) {
                 List<TextPosition> sublist = textPositions.subList(startIndex, i);
-                if (!(sublist.isEmpty() || sublist.size() == 1 && (sublist.get(0).getUnicode().equals(" ") || sublist.get(0).getUnicode().equals("\u00A0") || sublist.get(0)
-                        .getUnicode()
-                        .equals("\t")))) {
+                if (checkIfSequenceContainsOnlyWhitespaces(sublist)) {
                     textPositionSequences.add(new TextPositionSequence(sublist, pageNumber, i == textPositions.size() - 1 && isParagraphStart));
                 }
                 startIndex = i;
@@ -284,13 +271,10 @@ public class PDFLinesTextStripper extends PDFTextStripper {
                     .getUnicode()
                     .equals("\t")) && i <= textPositions.size() - 2) {
                 List<TextPosition> sublist = textPositions.subList(startIndex, i);
-                if (!(sublist.isEmpty() || sublist.size() == 1 && (sublist.get(0).getUnicode().equals(" ") || sublist.get(0).getUnicode().equals("\u00A0") || sublist.get(0)
-                        .getUnicode()
-                        .equals("\t")))) {
+                if (checkIfSequenceContainsOnlyWhitespaces(sublist)) {
 
                     // Remove false sequence ends (whitespaces)
-                    if (previous != null && sublist.get(0).getYDirAdj() == previous.getYDirAdj() && sublist.get(0)
-                            .getXDirAdj() - (previous.getXDirAdj() + previous.getWidthDirAdj()) < 0.01) {
+                    if (checkIfGapSizeBetweenCharactersSmallerThanMaximum(previous, sublist, 0.01f)) {
                         for (TextPosition t : sublist) {
                             textPositionSequences.get(textPositionSequences.size() - 1).add(t);
                         }
@@ -325,13 +309,29 @@ public class PDFLinesTextStripper extends PDFTextStripper {
     }
 
 
+    public boolean checkIfCurrentPositionIsToTheRightOfPreviousPosition(int i, List<TextPosition> textPositions) {
+
+        return i > 0 && textPositions.get(i).getXDirAdj() < textPositions.get(i - 1).getXDirAdj();
+    }
+
+
+    public boolean checkIfSequenceContainsOnlyWhitespaces(List<TextPosition> sublist) {
+
+        return !(sublist.isEmpty() || sublist.size() == 1 && (sublist.get(0).getUnicode().equals(" ") || sublist.get(0).getUnicode().equals("\u00A0") || sublist.get(0)
+                .getUnicode()
+                .equals("\t")));
+    }
+
+
+    public boolean checkIfGapSizeBetweenCharactersSmallerThanMaximum(RedTextPosition previous, List<TextPosition> sublist, float maximumGapSize) {
+
+        return previous != null && sublist.get(0).getYDirAdj() == previous.getYDirAdj() && sublist.get(0)
+                .getXDirAdj() - (previous.getXDirAdj() + previous.getWidthDirAdj()) < maximumGapSize;
+    }
+
     @Override
     public String getText(PDDocument doc) throws IOException {
 
-        minCharWidth = Integer.MAX_VALUE;
-        maxCharWidth = 0;
-        minCharHeight = Integer.MAX_VALUE;
-        maxCharHeight = 0;
         textPositionSequences.clear();
         rulings.clear();
         graphicsPath.clear();
@@ -344,3 +344,4 @@ public class PDFLinesTextStripper extends PDFTextStripper {
 
 }
 
+

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/parsing/PDFTextStripper.java

@@ -25,32 +25,26 @@ import java.io.StringWriter;
 import java.io.Writer;
 import java.text.Bidi;
 import java.text.Normalizer;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.SortedMap;
-import java.util.SortedSet;
-import java.util.StringTokenizer;
-import java.util.TreeMap;
-import java.util.TreeSet;
+import java.util.*;
 import java.util.regex.Pattern;
 
+import lombok.Getter;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.apache.pdfbox.cos.COSDictionary;
+import org.apache.pdfbox.cos.COSName;
 import org.apache.pdfbox.pdmodel.PDDocument;
 import org.apache.pdfbox.pdmodel.PDPage;
 import org.apache.pdfbox.pdmodel.PDPageTree;
 import org.apache.pdfbox.pdmodel.common.PDRectangle;
+import org.apache.pdfbox.pdmodel.documentinterchange.markedcontent.PDMarkedContent;
+import org.apache.pdfbox.pdmodel.graphics.PDXObject;
 import org.apache.pdfbox.pdmodel.interactive.documentnavigation.outline.PDOutlineItem;
 import org.apache.pdfbox.pdmodel.interactive.pagenavigation.PDThreadBead;
 import org.apache.pdfbox.text.TextPosition;
 import org.apache.pdfbox.text.TextPositionComparator;
-import org.apache.pdfbox.util.QuickSort;
+
+import com.knecon.fforesight.service.layoutparser.processor.utils.QuickSort;
 
 /**
  * This is just a copy except i only adjusted lines 594-607 cause this is a bug in Pdfbox.
@@ -63,6 +57,10 @@ public class PDFTextStripper extends LegacyPDFStreamEngine {
     private static float defaultDropThreshold = 2.5f;
     private static final boolean useCustomQuickSort;
 
+    @Getter
+    protected final List<PDMarkedContent> markedContents = new ArrayList<>();
+    protected final Deque<PDMarkedContent> currentMarkedContents = new ArrayDeque<>();
+
     private static final Log LOG = LogFactory.getLog(PDFTextStripper.class);
 
     // enable the ability to set the default indent/drop thresholds
@@ -196,6 +194,45 @@ public class PDFTextStripper extends LegacyPDFStreamEngine {
     }
 
 
+
+    public void beginMarkedContentSequence(COSName tag, COSDictionary properties)
+    {
+        PDMarkedContent markedContent = PDMarkedContent.create(tag, properties);
+        if (this.currentMarkedContents.isEmpty())
+        {
+            this.markedContents.add(markedContent);
+        }
+        else
+        {
+            PDMarkedContent currentMarkedContent =
+                    this.currentMarkedContents.peek();
+            if (currentMarkedContent != null)
+            {
+                currentMarkedContent.addMarkedContent(markedContent);
+            }
+        }
+        this.currentMarkedContents.push(markedContent);
+    }
+
+    @Override
+    public void endMarkedContentSequence()
+    {
+        if (!this.currentMarkedContents.isEmpty())
+        {
+            this.currentMarkedContents.pop();
+        }
+    }
+
+
+    public void xobject(PDXObject xobject)
+    {
+        if (!this.currentMarkedContents.isEmpty())
+        {
+            this.currentMarkedContents.peek().addXObject(xobject);
+        }
+    }
+
+
     /**
      * This will return the text of a document. See writeText. <br>
      * NOTE: The document must not be encrypted when coming into this method.
@@ -877,7 +914,12 @@ public class PDFTextStripper extends LegacyPDFStreamEngine {
                     textList.add(text);
                 }
             }
+            if (!this.currentMarkedContents.isEmpty())
+            {
+                this.currentMarkedContents.peek().addText(text);
+            }
         }
+
     }
 
 
@@ -1669,7 +1711,7 @@ public class PDFTextStripper extends LegacyPDFStreamEngine {
         int numberOfStrings = line.size();
         for (int i = 0; i < numberOfStrings; i++) {
             WordWithTextPositions word = line.get(i);
-            word.getTextPositions().sort(Comparator.comparing(TextPosition::getX));
+            word.getTextPositions().sort(Comparator.comparing(TextPosition::getXDirAdj));
             writeString(word.getText(), word.getTextPositions(), isParagraphEnd && i == numberOfStrings - 1);
             if (i < numberOfStrings - 1) {
                 writeWordSeparator();
@@ -2103,6 +2145,7 @@ public class PDFTextStripper extends LegacyPDFStreamEngine {
             this.isHangingIndent = true;
         }
 
+
     }
 
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/services/visualization/LayoutGridService.java

@@ -0,0 +1,345 @@
+package com.knecon.fforesight.service.layoutparser.processor.services.visualization;
+
+import java.awt.Color;
+import java.awt.geom.Line2D;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.geom.RectangularShape;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.springframework.stereotype.Service;
+
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Document;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Page;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.SemanticNode;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Table;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.TableCell;
+import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
+import com.knecon.fforesight.service.viewerdoc.ContentStreams;
+import com.knecon.fforesight.service.viewerdoc.model.ColoredLine;
+import com.knecon.fforesight.service.viewerdoc.model.ColoredRectangle;
+import com.knecon.fforesight.service.viewerdoc.model.LayoutGrid;
+import com.knecon.fforesight.service.viewerdoc.model.PlacedText;
+import com.knecon.fforesight.service.viewerdoc.model.Standard14EmbeddableFont;
+import com.knecon.fforesight.service.viewerdoc.model.Visualizations;
+import com.knecon.fforesight.service.viewerdoc.service.ViewerDocumentService;
+
+import io.micrometer.observation.annotation.Observed;
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import lombok.experimental.FieldDefaults;
+
+@Service
+@RequiredArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+public class LayoutGridService {
+
+    ViewerDocumentService viewerDocumentService;
+
+    static float FONT_SIZE = 10f;
+    static float LINE_WIDTH = 1f;
+    static Standard14EmbeddableFont FONT = Standard14EmbeddableFont.helvetica();
+
+    static Color INNER_LINES_COLOR = new Color(255, 175, 175);
+    static Color PARAGRAPH_COLOR = new Color(70, 130, 180);
+    static Color TABLE_COLOR = new Color(102, 205, 170);
+    static Color SECTION_COLOR = new Color(50, 50, 50);
+    static Color HEADLINE_COLOR = new Color(162, 56, 56);
+    static Color HEADER_COLOR = new Color(171, 131, 6);
+    static Color IMAGE_COLOR = new Color(253, 63, 146);
+
+
+    @SneakyThrows
+    @Observed(name = "ViewerDocumentService", contextualName = "create-viewer-document")
+    public void addLayoutGrid(File originFile, Document document, File destinationFile, boolean layerVisibilityDefaultValue) {
+
+        LayoutGrid layoutGrid = createLayoutGrid(document);
+
+        viewerDocumentService.addVisualizationsOnPage(originFile,
+                destinationFile,
+                Visualizations.builder()
+                        .layer(ContentStreams.KNECON_LAYOUT)
+                        .visualizationsOnPages(layoutGrid.getVisualizationsPerPages())
+                        .layerVisibilityDefaultValue(layerVisibilityDefaultValue)
+                        .build());
+    }
+
+
+    private LayoutGrid createLayoutGrid(Document document) {
+
+        LayoutGrid layoutGrid = new LayoutGrid(document.getNumberOfPages());
+        document.streamAllSubNodes().forEach(semanticNode -> {
+            Color color = switch (semanticNode.getType()) {
+                case PARAGRAPH -> PARAGRAPH_COLOR;
+                case TABLE -> TABLE_COLOR;
+                case SECTION -> SECTION_COLOR;
+                case HEADLINE -> HEADLINE_COLOR;
+                case HEADER, FOOTER -> HEADER_COLOR;
+                case IMAGE -> IMAGE_COLOR;
+                default -> null;
+            };
+            if (isNotSectionOrTableCellOrDocument(semanticNode)) {
+                addAsRectangle(semanticNode, layoutGrid, color);
+            }
+            if (semanticNode.getType().equals(NodeType.SECTION)) {
+                addSection(semanticNode, layoutGrid, color);
+            }
+            if (semanticNode.getType().equals(NodeType.TABLE)) {
+                Table table = (Table) semanticNode;
+                addInnerTableLines(table, layoutGrid);
+            }
+        });
+
+        return layoutGrid;
+    }
+
+
+    private void addInnerTableLines(Table table, LayoutGrid layoutGrid) {
+
+        if (table.getNumberOfCols() < 1 || table.getNumberOfRows() < 1) {
+            return;
+        }
+        for (Page page : table.getPages()) {
+            Optional<Integer> optionalFirstRowOnPage = table.streamCol(0).filter(tableCell -> tableCell.isOnPage(page.getNumber())).map(TableCell::getRow).findFirst();
+            if (optionalFirstRowOnPage.isEmpty()) {
+                continue;
+            }
+            int firstRowOnPage = optionalFirstRowOnPage.get();
+            Stream<Double> xStream = switch (page.getRotation()) {
+                case 90 -> streamBBoxOfCellsOnPage(table.streamCol(0), page).map(RectangularShape::getMinX);
+                case 180 -> streamBBoxOfCellsOnPage(table.streamRow(firstRowOnPage), page).map(RectangularShape::getMaxX);
+                case 270 -> streamBBoxOfCellsOnPage(table.streamCol(0), page).map(RectangularShape::getMaxX);
+                default -> streamBBoxOfCellsOnPage(table.streamRow(firstRowOnPage), page).map(RectangularShape::getMinX);
+            };
+            List<Double> xs = xStream.collect(Collectors.toList());
+            xs.remove(0);
+            Stream<Double> yStream = switch (page.getRotation()) {
+                case 90 -> streamBBoxOfCellsOnPage(table.streamRow(firstRowOnPage), page).map(RectangularShape::getMinY);
+                case 180 -> streamBBoxOfCellsOnPage(table.streamCol(0), page).map(RectangularShape::getMinY);
+                case 270 -> streamBBoxOfCellsOnPage(table.streamRow(firstRowOnPage), page).map(RectangularShape::getMaxY);
+                default -> streamBBoxOfCellsOnPage(table.streamCol(0), page).map(RectangularShape::getMaxY);
+            };
+            List<Double> ys = yStream.collect(Collectors.toList());
+            ys.remove(0);
+
+            Rectangle2D tableBBox = table.getBBox().get(table.getFirstPage());
+            List<ColoredLine> coloredLines = layoutGrid.getVisualizationsPerPages().get(page.getNumber() - 1).getColoredLines();
+            xs.forEach(x -> {
+                Line2D line = new Line2D.Double(new Point2D.Double(x, tableBBox.getMaxY()), new Point2D.Double(x, tableBBox.getMinY()));
+                coloredLines.add(new ColoredLine(line, INNER_LINES_COLOR, LINE_WIDTH));
+            });
+            ys.forEach(y -> {
+                Line2D line = new Line2D.Double(new Point2D.Double(tableBBox.getMinX(), y), new Point2D.Double(tableBBox.getMaxX(), y));
+                coloredLines.add(new ColoredLine(line, INNER_LINES_COLOR, LINE_WIDTH));
+            });
+        }
+    }
+
+
+    private static Stream<Rectangle2D> streamBBoxOfCellsOnPage(Stream<TableCell> table, Page page) {
+
+        return table.filter(tableCell -> tableCell.isOnPage(page.getNumber())).map(TableCell::getBBox).map(bBoxMap -> bBoxMap.get(page));
+    }
+
+
+    private void addSection(SemanticNode semanticNode, LayoutGrid layoutGrid, Color color) {
+
+        Map<Page, Rectangle2D> bBoxMap = semanticNode.getBBox();
+        List<SemanticNode> subSections = semanticNode.streamAllSubNodesOfType(NodeType.SECTION).toList();
+        Page firstPage = semanticNode.getFirstPage();
+        if (!subSections.isEmpty()) {
+            addPlacedText(firstPage, bBoxMap.get(firstPage), buildTreeIdString(semanticNode), layoutGrid);
+        } else {
+            bBoxMap.forEach(((page, textBBox) -> addPlacedText(page, textBBox, buildTreeIdString(semanticNode), layoutGrid)));
+        }
+        if (bBoxMap.values().size() == 1) {
+            Rectangle2D r = RectangleTransformations.pad(bBoxMap.get(firstPage), LINE_WIDTH, LINE_WIDTH);
+            List<ColoredLine> coloredLines = layoutGrid.getVisualizationsPerPages().get(firstPage.getNumber() - 1).getColoredLines();
+            List<Line2D> lines = createLinesFromRectangle(r, firstPage.getRotation());
+            // add string to top line
+            var firstLine = lines.remove(0);
+            coloredLines.add(new ColoredLine(firstLine, color, LINE_WIDTH));
+            for (Line2D line : lines) {
+                coloredLines.add(new ColoredLine(line, color, LINE_WIDTH));
+            }
+            return;
+        }
+        List<Page> pagesInOrder = bBoxMap.keySet().stream().sorted(Comparator.comparingInt(Page::getNumber)).collect(Collectors.toList());
+        pagesInOrder.remove(0);
+        addLinesForFirstPageOfSection(semanticNode, color, firstPage, layoutGrid);
+        var lastPage = pagesInOrder.remove(pagesInOrder.size() - 1);
+        addLinesForLastPageOfSection(semanticNode, color, lastPage, layoutGrid);
+        for (Page middlePage : pagesInOrder) {
+            addLinesForMiddlePageOfSection(semanticNode, color, middlePage, layoutGrid);
+        }
+    }
+
+
+    @SneakyThrows
+    private void addPlacedText(Page page, Rectangle2D textBBox, String s, LayoutGrid layoutGrid) {
+
+        // translates text, such that its right edge is a bit to the left of the drawn box
+        float translationAmount = ((FONT.getStringWidth(s) / 1000) * FONT_SIZE + (2 * LINE_WIDTH) + 4);
+
+        Point2D upperLeftCorner;
+        Point2D translationVector;
+        switch (page.getRotation()) {
+            case 90 -> {
+                upperLeftCorner = new Point2D.Double(textBBox.getMinX(), textBBox.getMinY());
+                translationVector = new Point2D.Double(FONT_SIZE, -translationAmount);
+            }
+            case 180 -> {
+                upperLeftCorner = new Point2D.Double(textBBox.getMaxX(), textBBox.getMinY());
+                translationVector = new Point2D.Double(translationAmount, FONT_SIZE);
+            }
+            case 270 -> {
+                upperLeftCorner = new Point2D.Double(textBBox.getMaxX(), textBBox.getMaxY());
+                translationVector = new Point2D.Double(-FONT_SIZE, translationAmount);
+            }
+            default -> {
+                upperLeftCorner = new Point2D.Double(textBBox.getMinX(), textBBox.getMaxY());
+                translationVector = new Point2D.Double(-translationAmount, -FONT_SIZE);
+            }
+        }
+
+        upperLeftCorner = add(upperLeftCorner, translationVector);
+
+        var placedTexts = layoutGrid.getVisualizationsPerPages().get(page.getNumber() - 1).getPlacedTexts();
+        placedTexts.add(PlacedText.textFacingUp(s, upperLeftCorner, FONT_SIZE, Color.BLACK, FONT));
+    }
+
+
+    private void addLinesForMiddlePageOfSection(SemanticNode semanticNode, Color color, Page middlePage, LayoutGrid layoutGrid) {
+
+        List<ColoredLine> coloredLines = layoutGrid.getVisualizationsPerPages().get(middlePage.getNumber() - 1).getColoredLines();
+        Rectangle2D r = RectangleTransformations.pad(semanticNode.getBBox().get(middlePage), LINE_WIDTH, LINE_WIDTH);
+        var midPageLines = createLinesFromRectangle(r, middlePage.getRotation());
+        // remove top line
+        midPageLines.remove(0);
+        // remove top line
+        midPageLines.remove(1);
+        // add string to left line
+        var leftLine = midPageLines.remove(1);
+        coloredLines.add(new ColoredLine(leftLine, color, LINE_WIDTH));
+        for (Line2D line : midPageLines) {
+            coloredLines.add(new ColoredLine(line, color, LINE_WIDTH));
+        }
+    }
+
+
+    private void addLinesForLastPageOfSection(SemanticNode semanticNode, Color color, Page lastPage, LayoutGrid layoutGrid) {
+
+        List<ColoredLine> coloredLines = layoutGrid.getVisualizationsPerPages().get(lastPage.getNumber() - 1).getColoredLines();
+        Rectangle2D r = RectangleTransformations.pad(semanticNode.getBBox().get(lastPage), LINE_WIDTH, LINE_WIDTH);
+        var lastPageLines = createLinesFromRectangle(r, lastPage.getRotation());
+        // remove top line
+        lastPageLines.remove(0);
+        // add string to left line
+        var leftLine = lastPageLines.remove(2);
+        coloredLines.add(new ColoredLine(leftLine, color, LINE_WIDTH));
+        for (Line2D line : lastPageLines) {
+            coloredLines.add(new ColoredLine(line, color, LINE_WIDTH));
+        }
+    }
+
+
+    private void addLinesForFirstPageOfSection(SemanticNode semanticNode, Color color, Page firstPage, LayoutGrid layoutGrid) {
+
+        List<ColoredLine> coloredLines = layoutGrid.getVisualizationsPerPages().get(firstPage.getNumber() - 1).getColoredLines();
+        Rectangle2D r = RectangleTransformations.pad(semanticNode.getBBox().get(firstPage), LINE_WIDTH, LINE_WIDTH);
+        var firstPageLines = createLinesFromRectangle(r, firstPage.getRotation());
+        // remove bottom line
+        firstPageLines.remove(2);
+        // add string to top line
+        var firstLine = firstPageLines.remove(0);
+        coloredLines.add(new ColoredLine(firstLine, color, LINE_WIDTH));
+        for (Line2D line : firstPageLines) {
+            coloredLines.add(new ColoredLine(line, color, LINE_WIDTH));
+        }
+    }
+
+
+    private String buildTreeIdString(SemanticNode semanticNode) {
+
+        return semanticNode.getTreeId().stream().map(Object::toString).collect(Collectors.joining("."));
+    }
+
+
+    /*
+    A __________________ B
+     |                  |
+     |                  |
+     |                  |
+     |                  |
+    D|__________________| C
+    The returned List are the lines [AB, BC, DC, AD]
+    The List is reordered, such that the order of the returned lines are always as viewed on the page.
+     */
+    private List<Line2D> createLinesFromRectangle(Rectangle2D r, int pageRotation) {
+        // +0.5 to join the lines
+        List<Line2D> lines = new ArrayList<>(4);
+        float lineWidthCorrection = LINE_WIDTH * 0.5f;
+        Point2D.Float a = new Point2D.Float((float) r.getMinX(), (float) r.getMaxY());
+        Point2D.Float a1 = new Point2D.Float((float) r.getMinX() - lineWidthCorrection, (float) r.getMaxY());
+        Point2D.Float b = new Point2D.Float((float) r.getMaxX(), (float) r.getMaxY());
+        Point2D.Float b1 = new Point2D.Float((float) r.getMaxX() + lineWidthCorrection, (float) r.getMaxY());
+        Point2D.Float c = new Point2D.Float((float) r.getMaxX(), (float) r.getMinY());
+        Point2D.Float c1 = new Point2D.Float((float) r.getMaxX() + lineWidthCorrection, (float) r.getMinY());
+        Point2D.Float d = new Point2D.Float((float) r.getMinX(), (float) r.getMinY());
+        Point2D.Float d1 = new Point2D.Float((float) r.getMinX() - lineWidthCorrection, (float) r.getMinY());
+        lines.add(new Line2D.Float(a1, b1));
+        lines.add(new Line2D.Float(b, c));
+        lines.add(new Line2D.Float(d1, c1));
+        lines.add(new Line2D.Float(a, d));
+
+        return switch (pageRotation) {
+            case 90 -> {
+                Collections.rotate(lines, 1);
+                yield lines;
+            }
+            case 180 -> {
+                Collections.rotate(lines, 2);
+                yield lines;
+            }
+            case 270 -> {
+                Collections.rotate(lines, 3);
+                yield lines;
+            }
+
+            default -> lines;
+        };
+    }
+
+
+    private static boolean isNotSectionOrTableCellOrDocument(SemanticNode semanticNode) {
+
+        return !(semanticNode.getType().equals(NodeType.DOCUMENT) || semanticNode.getType().equals(NodeType.SECTION) || semanticNode.getType().equals(NodeType.TABLE_CELL));
+    }
+
+
+    private void addAsRectangle(SemanticNode semanticNode, LayoutGrid layoutGrid, Color color) {
+
+        semanticNode.getBBox()
+                .forEach((page, textBBox) -> layoutGrid.getVisualizationsPerPages()
+                        .get(page.getNumber() - 1)
+                        .getColoredRectangles()
+                        .add(new ColoredRectangle(textBBox, color, LINE_WIDTH)));
+    }
+
+
+    private Point2D add(Point2D a, Point2D b) {
+
+        return new Point2D.Double(a.getX() + b.getX(), a.getY() + b.getY());
+    }
+
+}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/utils/DrawingOptions.java

@@ -0,0 +1,28 @@
+package com.knecon.fforesight.service.layoutparser.processor.utils;
+
+import java.awt.Color;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.experimental.FieldDefaults;
+
+@Builder
+@AllArgsConstructor
+@Getter
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+public class DrawingOptions {
+
+    boolean stroke;
+    @Builder.Default
+    Color strokeColor = Color.BLACK;
+    @Builder.Default
+    float strokeWidth = 1f;
+
+    boolean fill;
+    @Builder.Default
+    Color fillColor = Color.BLACK;
+
+}
+

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/utils/GeometricComparators.java

@@ -0,0 +1,88 @@
+package com.knecon.fforesight.service.layoutparser.processor.utils;
+
+import java.awt.geom.Point2D;
+import java.util.Comparator;
+
+import com.knecon.fforesight.service.layoutparser.processor.model.table.Cell;
+import com.knecon.fforesight.service.layoutparser.processor.model.table.Rectangle;
+import com.knecon.fforesight.service.layoutparser.processor.model.table.Ruling;
+
+public class GeometricComparators {
+
+    private static final int COMPARATOR_ROUNDING = 2;
+
+    public static final Comparator<Point2D> X_FIRST_POINT_COMPARATOR = (point1, point2) -> {
+
+        int rv = 0;
+        float point1X = DoubleComparisons.round(point1.getX(), COMPARATOR_ROUNDING);
+        float point1Y = DoubleComparisons.round(point1.getY(), COMPARATOR_ROUNDING);
+        float point2X = DoubleComparisons.round(point2.getX(), COMPARATOR_ROUNDING);
+        float point2Y = DoubleComparisons.round(point2.getY(), COMPARATOR_ROUNDING);
+
+        if (point1X > point2X) {
+            rv = 1;
+        } else if (point1X < point2X) {
+            rv = -1;
+        } else if (point1Y > point2Y) {
+            rv = 1;
+        } else if (point1Y < point2Y) {
+            rv = -1;
+        }
+        return rv;
+    };
+
+    public static final Comparator<Point2D> Y_FIRST_POINT_COMPARATOR = (point1, point2) -> {
+
+        int rv = 0;
+        float point1X = DoubleComparisons.round(point1.getX(), COMPARATOR_ROUNDING);
+        float point1Y = DoubleComparisons.round(point1.getY(), COMPARATOR_ROUNDING);
+        float point2X = DoubleComparisons.round(point2.getX(), COMPARATOR_ROUNDING);
+        float point2Y = DoubleComparisons.round(point2.getY(), COMPARATOR_ROUNDING);
+
+        if (point1Y > point2Y) {
+            rv = 1;
+        } else if (point1Y < point2Y) {
+            rv = -1;
+        } else if (point1X > point2X) {
+            rv = 1;
+        } else if (point1X < point2X) {
+            rv = -1;
+        }
+        return rv;
+    };
+
+    public static final Comparator<Cell> CELL_SIZE_COMPARATOR = (cell1, cell2) -> {
+
+        Double cell1Size = cell1.getHeight() * cell1.getWidth();
+        Double cell2Size = cell2.getHeight() * cell2.getWidth();
+        return cell1Size.compareTo(cell2Size);
+    };
+
+    public static final Comparator<Rectangle> RECTANGLE_SIZE_COMPARATOR = (rect1, rect2) -> {
+
+        Double rect1Size = rect1.getHeight() * rect1.getWidth();
+        Double rect2Size = rect2.getHeight() * rect2.getWidth();
+        return rect1Size.compareTo(rect2Size);
+    };
+
+    public static final Comparator<Ruling> X_FIRST_RULING_COMPARATOR = (ruling1, ruling2) -> {
+
+        int rv = 0;
+        float point1X = DoubleComparisons.round(Math.min(ruling1.getLeft(), ruling1.getRight()), COMPARATOR_ROUNDING);
+        float point1Y = DoubleComparisons.round(Math.min(ruling1.getTop(), ruling1.getBottom()), COMPARATOR_ROUNDING);
+        float point2X = DoubleComparisons.round(Math.min(ruling2.getLeft(), ruling2.getRight()), COMPARATOR_ROUNDING);
+        float point2Y = DoubleComparisons.round(Math.min(ruling2.getTop(), ruling2.getBottom()), COMPARATOR_ROUNDING);
+
+        if (point1X > point2X) {
+            rv = 1;
+        } else if (point1X < point2X) {
+            rv = -1;
+        } else if (point1Y > point2Y) {
+            rv = 1;
+        } else if (point1Y < point2Y) {
+            rv = -1;
+        }
+        return rv;
+    };
+
+}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/utils/MarkedContentUtils.java

@@ -0,0 +1,56 @@
+package com.knecon.fforesight.service.layoutparser.processor.utils;
+
+import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
+import lombok.experimental.UtilityClass;
+import org.apache.pdfbox.cos.COSName;
+import org.apache.pdfbox.pdmodel.documentinterchange.markedcontent.PDMarkedContent;
+import org.apache.pdfbox.text.TextPosition;
+
+import java.awt.geom.Rectangle2D;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@UtilityClass
+public class MarkedContentUtils {
+
+    public static final String HEADER = "Header";
+    public static final String FOOTER = "Footer";
+
+    public List<Rectangle2D> getMarkedContentBboxPerLine(List<PDMarkedContent> markedContents, String subtype) {
+
+        if (markedContents == null) {
+            return Collections.emptyList();
+        }
+
+        var markedContentByYPosition = markedContents.stream()
+                .filter(m -> m.getTag().equals("Artifact"))
+                .filter(m -> m.getProperties() != null)
+                .filter(m -> m.getProperties().getItem("Subtype") != null)
+                .filter(m -> ((COSName) m.getProperties().getItem("Subtype")).getName().equals(subtype))
+                .map(PDMarkedContent::getContents).flatMap(Collection::stream)
+                .filter(t -> t instanceof TextPosition)
+                .map(t -> (TextPosition) t)
+                .filter(t -> !t.getUnicode().equals(" "))
+                .collect(Collectors.groupingBy(TextPosition::getY));
+
+        if (markedContentByYPosition.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        return markedContentByYPosition.values().stream()
+                .map(textPositions -> new TextPositionSequence(textPositions.stream()
+                        .toList(), 0, true)
+                        .getRectangle())
+                .map(t -> new Rectangle2D.Float(t.getTopLeft().getX(), t.getTopLeft().getY() - Math.abs(t.getHeight()), t.getWidth(), Math.abs(t.getHeight()))).collect(Collectors.toList());
+    }
+
+
+    public boolean intersects(TextPageBlock textBlock, Map<String, List<Rectangle2D>> markedContentBboxPerType, String type) {
+        return markedContentBboxPerType.get(type) != null && markedContentBboxPerType.get(type).stream().anyMatch(rectangle -> rectangle.intersects(textBlock.getPdfMinX(), textBlock.getPdfMinY(), textBlock.getWidth(), textBlock.getHeight()));
+    }
+
+}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/utils/PdfVisualisationUtility.java

@@ -21,11 +21,7 @@ import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Pa
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.AtomicTextBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;
 
-import lombok.AccessLevel;
-import lombok.Builder;
-import lombok.Getter;
 import lombok.SneakyThrows;
-import lombok.experimental.FieldDefaults;
 import lombok.experimental.UtilityClass;
 import lombok.extern.slf4j.Slf4j;
 
@@ -41,20 +37,20 @@ public class PdfVisualisationUtility {
 
     public void drawNode(PDDocument document, DocumentTree.Entry entry) {
 
-        Options options = buildStandardOptionsForNodes(entry);
+        DrawingOptions options = buildStandardOptionsForNodes(entry);
 
         drawBBoxAndLabelAndNumberOnPage(document, entry, options);
 
     }
 
 
-    public void drawTextBlock(PDDocument document, TextBlock textBlock, Options options) {
+    public void drawTextBlock(PDDocument document, TextBlock textBlock, DrawingOptions options) {
 
         textBlock.getAtomicTextBlocks().forEach(atb -> drawAtomicTextBlock(document, atb, options));
     }
 
 
-    public void drawAtomicTextBlock(PDDocument document, AtomicTextBlock atomicTextBlock, Options options) {
+    public void drawAtomicTextBlock(PDDocument document, AtomicTextBlock atomicTextBlock, DrawingOptions options) {
 
         drawRectangle2DList(document, atomicTextBlock.getPage().getNumber(), atomicTextBlock.getPositions().stream().toList(), options);
 
@@ -62,7 +58,7 @@ public class PdfVisualisationUtility {
 
 
     @SneakyThrows
-    public void drawText(String string, PDDocument document, Point2D location, Integer pageNumber, Options options) {
+    public void drawText(String string, PDDocument document, Point2D location, Integer pageNumber, DrawingOptions options) {
 
         var pdPage = document.getPage(pageNumber - 1);
         var contentStream = new PDPageContentStream(document, pdPage, PDPageContentStream.AppendMode.APPEND, true);
@@ -80,14 +76,14 @@ public class PdfVisualisationUtility {
 
 
     @SneakyThrows
-    public void drawRectangle2DList(PDDocument document, int pageNumber, List<Rectangle2D> rectCollection, Options options) {
+    public void drawRectangle2DList(PDDocument document, int pageNumber, List<Rectangle2D> rectCollection, DrawingOptions options) {
 
         var pdPage = document.getPage(pageNumber - 1);
         drawRectangle2DList(document, rectCollection, options, pdPage);
     }
 
 
-    private void drawRectangle2DList(PDDocument document, List<Rectangle2D> rectCollection, Options options, PDPage pdPage) throws IOException {
+    private void drawRectangle2DList(PDDocument document, List<Rectangle2D> rectCollection, DrawingOptions options, PDPage pdPage) throws IOException {
 
         var contentStream = new PDPageContentStream(document, pdPage, PDPageContentStream.AppendMode.APPEND, true);
 
@@ -110,9 +106,9 @@ public class PdfVisualisationUtility {
     }
 
 
-    private Options buildStandardOptionsForNodes(DocumentTree.Entry entry) {
+    private DrawingOptions buildStandardOptionsForNodes(DocumentTree.Entry entry) {
 
-        return Options.builder().stroke(true).strokeColor(switch (entry.getType()) {
+        return DrawingOptions.builder().stroke(true).strokeColor(switch (entry.getType()) {
             case DOCUMENT -> Color.LIGHT_GRAY;
             case HEADER, FOOTER -> Color.GREEN;
             case PARAGRAPH -> Color.BLUE;
@@ -125,7 +121,7 @@ public class PdfVisualisationUtility {
     }
 
 
-    private void drawBBoxAndLabelAndNumberOnPage(PDDocument document, DocumentTree.Entry entry, Options options) {
+    private void drawBBoxAndLabelAndNumberOnPage(PDDocument document, DocumentTree.Entry entry, DrawingOptions options) {
 
         Map<Page, Rectangle2D> rectanglesPerPage = entry.getNode().getBBox();
         rectanglesPerPage.forEach((page, rectangle2D) -> {
@@ -152,7 +148,7 @@ public class PdfVisualisationUtility {
 
 
     @SneakyThrows
-    public static void drawLine2DList(PDDocument pdDocument, int pageNumber, List<Line2D> line2DS, Options options) {
+    public static void drawLine2DList(PDDocument pdDocument, int pageNumber, List<? extends Line2D> line2DS, DrawingOptions options) {
 
         var pdPage = pdDocument.getPage(pageNumber - 1);
         var contentStream = new PDPageContentStream(pdDocument, pdPage, PDPageContentStream.AppendMode.APPEND, true);
@@ -176,21 +172,4 @@ public class PdfVisualisationUtility {
         contentStream.close();
     }
 
-
-    @Builder
-    @Getter
-    @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
-    public static class Options {
-
-        boolean fill;
-        boolean stroke;
-        @Builder.Default
-        Color strokeColor = Color.BLACK;
-        @Builder.Default
-        float strokeWidth = 1f;
-        @Builder.Default
-        Color fillColor = Color.BLACK;
-
-    }
-
 }

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/utils/PositionUtils.java

@@ -19,9 +19,10 @@ public final class PositionUtils {
 
         double threshold = textBlock.getMostPopularWordHeight() * 3;
 
-        if (textBlock.getPdfMinX() + threshold > btf.getTopLeft().getX() && textBlock.getPdfMaxX() - threshold < btf.getTopLeft()
-                .getX() + btf.getWidth() && textBlock.getPdfMinY() + threshold > btf.getTopLeft().getY() && textBlock.getPdfMaxY() - threshold < btf.getTopLeft()
-                .getY() + btf.getHeight()) {
+        if (textBlock.getPdfMinX() + threshold > btf.getTopLeft().getX()
+                && textBlock.getPdfMaxX() - threshold < btf.getTopLeft().getX() + btf.getWidth()
+                && textBlock.getPdfMinY() + threshold > btf.getTopLeft().getY()
+                && textBlock.getPdfMaxY() - threshold < btf.getTopLeft().getY() + btf.getHeight()) {
             return true;
         } else {
             return false;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/utils/RectangleTransformations.java

@@ -2,6 +2,7 @@ package com.knecon.fforesight.service.layoutparser.processor.utils;
 
 import static java.lang.String.format;
 
+import java.awt.geom.Area;
 import java.awt.geom.Rectangle2D;
 import java.awt.geom.RectangularShape;
 import java.util.Collections;
@@ -37,15 +38,28 @@ public class RectangleTransformations {
     }
 
 
+    public static double calculateIntersectedArea(Rectangle2D r1, Rectangle2D r2) {
+
+        Area a1 = new Area(r1);
+        Area a2 = new Area(r2);
+        a1.intersect(a2);
+        Rectangle2D intersection = a1.getBounds2D();
+        return intersection.getWidth() * intersection.getHeight();
+    }
+
+
     public static Rectangle2D bBoxUnionAtomicTextBlock(List<AtomicTextBlock> atomicTextBlocks) {
 
         return atomicTextBlocks.stream().flatMap(atomicTextBlock -> atomicTextBlock.getPositions().stream()).collect(new Rectangle2DBBoxCollector());
     }
+
+
     public static Collector<Rectangle2D, Rectangle2DBBoxCollector.BBox, Rectangle2D> collectBBox() {
 
         return new Rectangle2DBBoxCollector();
     }
 
+
     public static PDRectangle toPDRectangleBBox(List<Rectangle> rectangles) {
 
         Rectangle2D rectangle2D = RectangleTransformations.rectangleBBox(rectangles);
@@ -70,6 +84,7 @@ public class RectangleTransformations {
         return format("%f,%f,%f,%f", rectangle2D.getX(), rectangle2D.getY(), rectangle2D.getWidth(), rectangle2D.getHeight());
     }
 
+
     public static Rectangle2D rectangleBBox(List<Rectangle> rectangles) {
 
         return rectangles.stream().map(RectangleTransformations::toRectangle2D).collect(new Rectangle2DBBoxCollector());
@@ -84,6 +99,7 @@ public class RectangleTransformations {
                 -redactionLogRectangle.getHeight());
     }
 
+
     public static Rectangle2D toRectangle2D(PDRectangle rectangle) {
 
         return new Rectangle2D.Double(rectangle.getLowerLeftX(), rectangle.getLowerLeftY(), rectangle.getWidth(), rectangle.getHeight());

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/utils/RectangularIntersectionFinder.java

@@ -0,0 +1,77 @@
+package com.knecon.fforesight.service.layoutparser.processor.utils;
+
+import static com.knecon.fforesight.service.layoutparser.processor.utils.GeometricComparators.Y_FIRST_POINT_COMPARATOR;
+
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import com.knecon.fforesight.service.layoutparser.processor.model.table.Ruling;
+
+public class RectangularIntersectionFinder {
+
+    public static List<Rectangle2D> find(List<Ruling> horizontalRulingLines, List<Ruling> verticalRulingLines) {
+
+        // Fix for 211.pdf
+        for (Ruling r : horizontalRulingLines) {
+            if (r.getX2() < r.getX1()) {
+                double a = r.getX2();
+                r.x2 = (float) r.getX1();
+                r.x1 = (float) a;
+            }
+        }
+
+        List<Rectangle2D> foundRectangles = new ArrayList<>();
+        Map<Point2D, Ruling[]> intersectionPoints = Ruling.findIntersections(horizontalRulingLines, verticalRulingLines);
+        List<Point2D> intersectionPointsList = new ArrayList<>(intersectionPoints.keySet());
+        intersectionPointsList.sort(Y_FIRST_POINT_COMPARATOR);
+
+        for (int i = 0; i < intersectionPointsList.size(); i++) {
+            Point2D topLeft = intersectionPointsList.get(i);
+            Ruling[] hv = intersectionPoints.get(topLeft);
+
+            // CrossingPointsDirectlyBelow( topLeft );
+            List<Point2D> xPoints = new ArrayList<>();
+            // CrossingPointsDirectlyToTheRight( topLeft );
+            List<Point2D> yPoints = new ArrayList<>();
+
+            for (Point2D p : intersectionPointsList.subList(i, intersectionPointsList.size())) {
+                if (p.getX() == topLeft.getX() && p.getY() > topLeft.getY()) {
+                    xPoints.add(p);
+                }
+                if (p.getY() == topLeft.getY() && p.getX() > topLeft.getX()) {
+                    yPoints.add(p);
+                }
+            }
+            outer:
+            for (Point2D xPoint : xPoints) {
+                // is there a vertical edge b/w topLeft and xPoint?
+                if (!hv[1].equals(intersectionPoints.get(xPoint)[1])) {
+                    continue;
+                }
+                for (Point2D yPoint : yPoints) {
+                    // is there a horizontal edge b/w topLeft and yPoint ?
+                    if (!hv[0].equals(intersectionPoints.get(yPoint)[0])) {
+                        continue;
+                    }
+                    Point2D btmRight = new Point2D.Float((float) yPoint.getX(), (float) xPoint.getY());
+                    if (intersectionPoints.containsKey(btmRight)
+                        && intersectionPoints.get(btmRight)[0].equals(intersectionPoints.get(xPoint)[0])
+                        && intersectionPoints.get(btmRight)[1].equals(intersectionPoints.get(yPoint)[1])) {
+                        foundRectangles.add(new Rectangle2D.Double(topLeft.getX(), topLeft.getY(), btmRight.getX() - topLeft.getX(), btmRight.getY() - topLeft.getY()));
+                        break outer;
+                    }
+                }
+            }
+        }
+
+        // TODO create cells for vertical ruling lines with aligned endpoints at the top/bottom of a grid
+        // that aren't connected with an horizontal ruler?
+        // see: https://github.com/jazzido/tabula-extractor/issues/78#issuecomment-41481207
+
+        return foundRectangles;
+    }
+
+}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/utils/SpreadsheetFinder.java

@@ -0,0 +1,172 @@
+package com.knecon.fforesight.service.layoutparser.processor.utils;
+
+import static com.knecon.fforesight.service.layoutparser.processor.utils.GeometricComparators.X_FIRST_POINT_COMPARATOR;
+import static com.knecon.fforesight.service.layoutparser.processor.utils.GeometricComparators.Y_FIRST_POINT_COMPARATOR;
+
+import java.awt.geom.Point2D;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.knecon.fforesight.service.layoutparser.processor.model.table.Rectangle;
+
+public class SpreadsheetFinder {
+
+    private static final int MAX_OUTER_POINT_TOLERANCE = 10;
+    private static final float AREA_TOLERANCE = 0.001f;
+
+
+    public static List<Rectangle> findSpreadsheetsFromCells(List<? extends Rectangle> cells) {
+        // via: http://stackoverflow.com/questions/13746284/merging-multiple-adjacent-rectangles-into-one-polygon
+        List<Rectangle> rectangles = new ArrayList<>();
+        Set<Point2D> pointSet = new HashSet<>();
+        Map<Point2D, Point2D> edgesH = new HashMap<>();
+        Map<Point2D, Point2D> edgesV = new HashMap<>();
+
+        for (Rectangle cell : cells) {
+            for (Point2D pt : cell.getPoints()) {
+                if (pointSet.contains(pt)) { // shared vertex, remove it
+                    pointSet.remove(pt);
+                } else {
+                    pointSet.add(pt);
+                }
+            }
+        }
+
+        // X first sort
+        List<Point2D> pointsSortX = new ArrayList<>(pointSet);
+        pointsSortX.sort(X_FIRST_POINT_COMPARATOR);
+        // Y first sort
+        List<Point2D> pointsSortY = new ArrayList<>(pointSet);
+        pointsSortY.sort(Y_FIRST_POINT_COMPARATOR);
+
+        int i = 0;
+        while (i < pointSet.size()) {
+            float currY = (float) pointsSortY.get(i).getY();
+            while (i < pointSet.size() && DoubleComparisons.feq(pointsSortY.get(i).getY(), currY)) {
+                edgesH.put(pointsSortY.get(i), pointsSortY.get(i + 1));
+                edgesH.put(pointsSortY.get(i + 1), pointsSortY.get(i));
+                i += 2;
+            }
+        }
+
+        i = 0;
+        while (i < pointSet.size()) {
+            float currX = (float) pointsSortX.get(i).getX();
+            while (i < pointSet.size() && DoubleComparisons.feq(pointsSortX.get(i).getX(), currX)) {
+                edgesV.put(pointsSortX.get(i), pointsSortX.get(i + 1));
+                edgesV.put(pointsSortX.get(i + 1), pointsSortX.get(i));
+                i += 2;
+            }
+        }
+
+        // Get all the polygons
+        List<List<PolygonVertex>> polygons = new ArrayList<>();
+        Point2D nextVertex;
+        while (!edgesH.isEmpty()) {
+            ArrayList<PolygonVertex> polygon = new ArrayList<>();
+            Point2D first = edgesH.keySet()
+                    .iterator().next();
+            polygon.add(new PolygonVertex(first, Direction.HORIZONTAL));
+            edgesH.remove(first);
+
+            while (true) {
+                PolygonVertex curr = polygon.get(polygon.size() - 1);
+                PolygonVertex lastAddedVertex;
+                if (curr.direction == Direction.HORIZONTAL) {
+                    nextVertex = edgesV.get(curr.point);
+                    edgesV.remove(curr.point);
+                    lastAddedVertex = new PolygonVertex(nextVertex, Direction.VERTICAL);
+                } else {
+                    nextVertex = edgesH.get(curr.point);
+                    edgesH.remove(curr.point);
+                    lastAddedVertex = new PolygonVertex(nextVertex, Direction.HORIZONTAL);
+                }
+                polygon.add(lastAddedVertex);
+
+                if (lastAddedVertex.equals(polygon.get(0))) {
+                    // closed polygon
+                    polygon.remove(polygon.size() - 1);
+                    break;
+                }
+            }
+
+            for (PolygonVertex vertex : polygon) {
+                edgesH.remove(vertex.point);
+                edgesV.remove(vertex.point);
+            }
+            polygons.add(polygon);
+        }
+
+        // calculate grid-aligned minimum area rectangles for each found polygon
+        for (List<PolygonVertex> poly : polygons) {
+            float top = Float.MAX_VALUE;
+            float left = Float.MAX_VALUE;
+            float bottom = Float.MIN_VALUE;
+            float right = Float.MIN_VALUE;
+            for (PolygonVertex pt : poly) {
+                top = (float) Math.min(top, pt.point.getY());
+                left = (float) Math.min(left, pt.point.getX());
+                bottom = (float) Math.max(bottom, pt.point.getY());
+                right = (float) Math.max(right, pt.point.getX());
+            }
+
+            // do not add polygons with too many outer points as they are unlikely to be tables
+            if (poly.size() <= MAX_OUTER_POINT_TOLERANCE) {
+                rectangles.add(new Rectangle(top - AREA_TOLERANCE, left - AREA_TOLERANCE, right - left + 2 * AREA_TOLERANCE, bottom - top + 2 * AREA_TOLERANCE));
+            }
+        }
+        return rectangles;
+    }
+
+
+    private enum Direction {
+        HORIZONTAL,
+        VERTICAL
+    }
+
+    static class PolygonVertex {
+
+        Point2D point;
+        Direction direction;
+
+
+        PolygonVertex(Point2D point, Direction direction) {
+
+            this.direction = direction;
+            this.point = point;
+        }
+
+
+        @Override
+        public boolean equals(Object other) {
+
+            if (this == other) {
+                return true;
+            }
+            if (!(other instanceof PolygonVertex)) {
+                return false;
+            }
+            return this.point.equals(((PolygonVertex) other).point);
+        }
+
+
+        @Override
+        public int hashCode() {
+
+            return this.point.hashCode();
+        }
+
+
+        @Override
+        public String toString() {
+
+            return String.format("%s[point=%s,direction=%s]", this.getClass().getName(), this.point.toString(), this.direction.toString());
+        }
+
+    }
+
+}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/utils/TableMergingUtility.java

@@ -30,8 +30,6 @@ public class TableMergingUtility {
             if (consecutiveTable.getColCount() == originalTablePageBlock.getColCount() && !hasTableHeader(consecutiveTable) && outerBoundaryAlignsX(originalTablePageBlock,
                     consecutiveTable)) {
                 consecutiveTablesWithSameColCountAndHeaders.add(consecutiveTable);
-            } else {
-                break;
             }
         }
         return Stream.concat(Stream.of(originalTablePageBlock), consecutiveTablesWithSameColCountAndHeaders.stream()).toList();

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/utils/TextPositionOperations.java

@@ -3,7 +3,6 @@ package com.knecon.fforesight.service.layoutparser.processor.utils;
 import java.util.List;
 import java.util.stream.Collectors;
 
-import org.apache.pdfbox.util.QuickSort;
 
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/utils/UnionFind.java

@@ -0,0 +1,44 @@
+package com.knecon.fforesight.service.layoutparser.processor.utils;
+
+import java.util.HashMap;
+import java.util.Map;
+
+// simple implementation of a disjoint-set data structure
+// https://en.wikipedia.org/wiki/Disjoint-set_data_structure
+public class UnionFind<T> {
+
+    Map<T, T> parents = new HashMap<>();
+    Map<T, Integer> numberOfObjects = new HashMap<>();
+
+
+    public T find(T node) {
+
+        if (!parents.containsKey(node)) {
+            parents.put(node, node);
+            numberOfObjects.put(node, 1);
+        }
+        if (!node.equals(parents.get(node))) {
+            parents.put(node, find(parents.get(node)));
+        }
+        return parents.get(node);
+    }
+
+
+    public void union(T node1, T node2) {
+
+        T root1 = find(node1);
+        T root2 = find(node2);
+
+        if (!root1.equals(root2)) {
+            if (numberOfObjects.getOrDefault(root1, 1) < numberOfObjects.getOrDefault(root2, 1)) {
+                parents.put(root1, root2);
+                numberOfObjects.put(root2, numberOfObjects.get(root2) + numberOfObjects.get(root1));
+            } else {
+                parents.put(root2, root1);
+                numberOfObjects.put(root1, numberOfObjects.get(root1) + numberOfObjects.get(root2));
+            }
+        }
+    }
+
+}
+