RED-10714: fix IndexOutOfBoundsException

(cherry picked from commit 0b6a292c75)

.gitattributes

@@ -0,0 +1 @@
+*.pdf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -18,6 +18,7 @@ target/
 .settings
 .springBeans
 .sts4-cache
+.gradle
 
 ### IntelliJ IDEA ###
 .idea
@@ -37,3 +38,9 @@ build/
 
 ### VS Code ###
 .vscode/
+gradlew.bat
+gradlew
+gradle.properties
+gradle/
+.DS_Store
+.DS_Store/

.gitlab-ci.yml

@@ -1,4 +1,26 @@
+variables:
+  #  SONAR_PROJECT_KEY: 'fforesight_layout-parser_AYd5quv2mRkBOCG22hvF'
+  GIT_SUBMODULE_STRATEGY: recursive
+  GIT_SUBMODULE_FORCE_HTTPS: 'true'
 include:
   - project: 'gitlab/gitlab'
     ref: 'main'
-    file: 'ci-templates/maven_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 =~ /^feature/ && $CI_COMMIT_TAG == ""
+    - if: $CI_COMMIT_BRANCH =~ /^release/
+    - if: $CI_COMMIT_TAG

.gitmodules

@@ -0,0 +1,8 @@
+[submodule "layoutparser-service/layoutparser-service-server/src/test/resources/files/basf"]
+	path = layoutparser-service/layoutparser-service-server/src/test/resources/files/basf
+	url = ssh://git@git.knecon.com:22222/fforesight/documents/basf.git
+	update = merge
+[submodule "layoutparser-service/layoutparser-service-server/src/test/resources/files/syngenta"]
+	path = layoutparser-service/layoutparser-service-server/src/test/resources/files/syngenta
+	url = ssh://git@git.knecon.com:22222/fforesight/documents/syngenta.git
+	update = merge

.mvn/wrapper/maven-wrapper.properties

@@ -1,18 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.7/apache-maven-3.8.7-bin.zip
-wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.1/maven-wrapper-3.1.1.jar

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/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+    `kotlin-dsl`
+}
+
+repositories {
+    gradlePluginPortal()
+}

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

@@ -0,0 +1,91 @@
+plugins {
+    `java-library`
+    `maven-publish`
+    pmd
+    checkstyle
+    jacoco
+}
+
+group = "com.knecon.fforesight"
+
+java.sourceCompatibility = JavaVersion.VERSION_17
+java.targetCompatibility = JavaVersion.VERSION_17
+
+tasks.pmdMain {
+    pmd.ruleSetFiles = files("${rootDir}/config/pmd/pmd.xml")
+}
+
+tasks.pmdTest {
+    pmd.ruleSetFiles = files("${rootDir}/config/pmd/test_pmd.xml")
+}
+
+tasks.named<Test>("test") {
+    useJUnitPlatform()
+    reports {
+        junitXml.outputLocation.set(layout.buildDirectory.dir("reports/junit"))
+    }
+    minHeapSize = "512m"
+    maxHeapSize = "2048m"
+}
+
+tasks.test {
+    finalizedBy(tasks.jacocoTestReport) // report is always generated after tests run
+}
+
+tasks.jacocoTestReport {
+    dependsOn(tasks.test) // tests are required to run before generating the report
+    reports {
+        xml.required.set(true)
+        csv.required.set(false)
+        html.outputLocation.set(layout.buildDirectory.dir("jacocoHtml"))
+    }
+}
+
+allprojects {
+
+    tasks.withType<Javadoc> {
+        options {
+            this as StandardJavadocDocletOptions
+            addBooleanOption("Xdoclint:none", true)
+            addStringOption("Xmaxwarns", "1")
+        }
+    }
+
+    pmd {
+        setConsoleOutput(true)
+    }
+
+    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/")
+        credentials {
+            username = providers.gradleProperty("mavenUser").getOrNull();
+            password = providers.gradleProperty("mavenPassword").getOrNull();
+        }
+    }
+}

config/checkstyle/checkstyle.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE module PUBLIC "-//Puppy Crawl//DTD Check Configuration 1.3//EN"
+        "http://www.puppycrawl.com/dtds/configuration_1_3.dtd">
+<module name="Checker">
+    <property
+            name="severity"
+            value="error"/>
+    <module name="TreeWalker">
+        <module name="SuppressWarningsHolder"/>
+        <module name="MissingDeprecated"/>
+        <module name="MissingOverride"/>
+        <module name="AnnotationLocation"/>
+        <module name="JavadocStyle"/>
+        <module name="NonEmptyAtclauseDescription"/>
+        <module name="IllegalImport"/>
+        <module name="RedundantImport"/>
+        <module name="RedundantModifier"/>
+        <module name="EmptyBlock"/>
+        <module name="DefaultComesLast"/>
+        <module name="EmptyStatement"/>
+        <module name="EqualsHashCode"/>
+        <module name="ExplicitInitialization"/>
+        <module name="IllegalInstantiation"/>
+        <module name="ModifiedControlVariable"/>
+        <module name="MultipleVariableDeclarations"/>
+        <module name="PackageDeclaration"/>
+        <module name="ParameterAssignment"/>
+        <module name="SimplifyBooleanExpression"/>
+        <module name="SimplifyBooleanReturn"/>
+        <module name="StringLiteralEquality"/>
+        <module name="OneStatementPerLine"/>
+        <module name="FinalClass"/>
+        <module name="ArrayTypeStyle"/>
+        <module name="UpperEll"/>
+        <module name="OuterTypeFilename"/>
+    </module>
+    <module name="FileTabCharacter"/>
+    <module name="SuppressWarningsFilter"/>
+</module>

config/pmd/pmd.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0"?>
+<ruleset name="Custom ruleset"
+         xmlns="http://pmd.sourceforge.net/ruleset/2.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 http://pmd.sourceforge.net/ruleset_2_0_0.xsd">
+
+    <description>
+        Knecon ruleset checks the code for bad stuff
+    </description>
+
+    <rule ref="category/java/errorprone.xml">
+        <exclude name="MissingSerialVersionUID"/>
+        <exclude name="AvoidLiteralsInIfCondition"/>
+        <exclude name="AvoidDuplicateLiterals"/>
+        <exclude name="NullAssignment"/>
+        <exclude name="AssignmentInOperand"/>
+        <exclude name="BeanMembersShouldSerialize"/>
+    </rule>
+
+</ruleset>
+

config/pmd/test_pmd.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0"?>
+<ruleset name="Custom ruleset"
+         xmlns="http://pmd.sourceforge.net/ruleset/2.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 http://pmd.sourceforge.net/ruleset_2_0_0.xsd">
+
+    <description>
+        Knecon test ruleset checks the code for bad stuff
+    </description>
+
+
+    <rule ref="category/java/errorprone.xml">
+        <exclude name="MissingSerialVersionUID"/>
+        <exclude name="AvoidLiteralsInIfCondition"/>
+        <exclude name="AvoidDuplicateLiterals"/>
+        <exclude name="AvoidFieldNameMatchingMethodName"/>
+        <exclude name="NullAssignment"/>
+        <exclude name="AssignmentInOperand"/>
+        <exclude name="TestClassWithoutTestCases"/>
+        <exclude name="BeanMembersShouldSerialize"/>
+    </rule>
+
+</ruleset>

gradle.properties.kts

@@ -0,0 +1 @@
+version = 0.1-SNAPSHOT

layoutparser-service-image/pom.xml

@@ -1,100 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-
-
-    <parent>
-        <groupId>com.knecon.fforesight</groupId>
-        <artifactId>platform-docker-dependency</artifactId>
-        <version>0.1.0</version>
-        <relativePath/>
-    </parent>
-
-    <groupId>com.knecon.fforesight</groupId>
-    <artifactId>layoutparser-service-image</artifactId>
-    <version>1.0.0</version>
-    <packaging>pom</packaging>
-
-    <properties>
-        <service.server>layoutparser-service-server</service.server>
-        <platform.jar>${service.server}.jar</platform.jar>
-        <docker.skip.push>false</docker.skip.push>
-        <docker.image.prefix>ff</docker.image.prefix>
-        <docker.image.name>${docker.image.prefix}/${service.server}</docker.image.name>
-    </properties>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-dependency-plugin</artifactId>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-resources-plugin</artifactId>
-            </plugin>
-            <plugin>
-                <groupId>org.codehaus.mojo</groupId>
-                <artifactId>exec-maven-plugin</artifactId>
-            </plugin>
-            <plugin>
-                <groupId>io.fabric8</groupId>
-                <artifactId>docker-maven-plugin</artifactId>
-            </plugin>
-        </plugins>
-
-        <pluginManagement>
-            <plugins>
-                <plugin>
-                    <groupId>org.apache.maven.plugins</groupId>
-                    <artifactId>maven-dependency-plugin</artifactId>
-                    <executions>
-                        <execution>
-                            <id>download-platform-jar</id>
-                            <phase>prepare-package</phase>
-                            <goals>
-                                <goal>copy</goal>
-                            </goals>
-                            <configuration>
-                                <artifactItems>
-                                    <dependency>
-                                        <groupId>${project.groupId}</groupId>
-                                        <artifactId>${service.server}</artifactId>
-                                        <version>${project.version}</version>
-                                        <type>jar</type>
-                                        <overWrite>true</overWrite>
-                                        <destFileName>${platform.jar}</destFileName>
-                                    </dependency>
-                                </artifactItems>
-                                <outputDirectory>${docker.build.directory}</outputDirectory>
-                            </configuration>
-                        </execution>
-                    </executions>
-                </plugin>
-                <plugin>
-                    <groupId>io.fabric8</groupId>
-                    <artifactId>docker-maven-plugin</artifactId>
-                    <configuration>
-                        <images>
-                            <image>
-                                <name>${docker.image.name}</name>
-                                <build>
-                                    <dockerFileDir>${docker.build.directory}</dockerFileDir>
-                                    <args>
-                                        <PLATFORM_JAR>${platform.jar}</PLATFORM_JAR>
-                                    </args>
-                                    <tags>
-                                        <tag>${docker.image.version}</tag>
-                                        <tag>latest</tag>
-                                    </tags>
-                                </build>
-                            </image>
-                        </images>
-                    </configuration>
-                </plugin>
-            </plugins>
-        </pluginManagement>
-    </build>
-</project>

layoutparser-service-image/src/main/docker/Dockerfile

@@ -1,9 +0,0 @@
-FROM red/base-image:2.0.2
-
-ARG PLATFORM_JAR
-
-ENV PLATFORM_JAR ${PLATFORM_JAR}
-
-ENV USES_ELASTICSEARCH false
-
-COPY ["${PLATFORM_JAR}", "/"]

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

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

layoutparser-service/layoutparser-service-internal-api/pom.xml

@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xmlns="http://maven.apache.org/POM/4.0.0"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>com.knecon.fforesight</groupId>
-        <artifactId>layoutparser-service</artifactId>
-        <version>1.0.0</version>
-    </parent>
-
-    <artifactId>layoutparser-service-internal-api</artifactId>
-
-    <dependencies>
-        <dependency>
-            <groupId>com.google.guava</groupId>
-            <artifactId>guava</artifactId>
-            <version>${guava.version}</version>
-        </dependency>
-    </dependencies>
-
-</project>

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

@@ -1,19 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.internal.api.data;
-
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.experimental.FieldDefaults;
-
-@Data
-@Builder
-@AllArgsConstructor
-@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
-public class AtomicPositionBlockData {
-
-    Long id;
-    int[] stringIdxToPositionIdx;
-    float[][] positions;
-
-}

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

@@ -1,27 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.internal.api.data;
-
-
-
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.experimental.FieldDefaults;
-
-@Data
-@Builder
-@AllArgsConstructor
-@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
-public class AtomicTextBlockData {
-
-    Long id;
-    Long page;
-    String searchText;
-    int numberOnPage;
-    int start;
-    int end;
-    int[] lineBreaks;
-
-
-
-}

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

@@ -1,21 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.internal.api.data;
-
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.experimental.FieldDefaults;
-
-@Data
-@Builder
-@AllArgsConstructor
-@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
-public class DocumentData {
-
-    PageData[] pages;
-    AtomicTextBlockData[] atomicTextBlocks;
-    AtomicPositionBlockData[] atomicPositionBlocks;
-    DocumentTreeData documentTreeData;
-
-
-}

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

@@ -1,90 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.internal.api.data;
-
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Stream;
-
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.experimental.FieldDefaults;
-
-@Data
-@Builder
-@AllArgsConstructor
-@NoArgsConstructor
-@FieldDefaults(level = AccessLevel.PRIVATE)
-public class DocumentTreeData {
-
-    EntryData root;
-
-
-    public EntryData get(List<Integer> tocId) {
-
-        if (tocId.isEmpty()) {
-            return root;
-        }
-        EntryData entry = root.children.get(tocId.get(0));
-        for (int id : tocId.subList(1, tocId.size())) {
-            entry = entry.children.get(id);
-        }
-        return entry;
-    }
-
-
-    public Stream<EntryData> streamAllEntries() {
-
-        return Stream.concat(Stream.of(root), root.children.stream()).flatMap(DocumentTreeData::flatten);
-    }
-
-
-    public String toString() {
-
-        return String.join("\n", streamAllEntries().map(EntryData::toString).toList());
-    }
-
-
-    private static Stream<EntryData> flatten(EntryData entry) {
-
-        return Stream.concat(Stream.of(entry), entry.children.stream().flatMap(DocumentTreeData::flatten));
-    }
-
-
-    @Builder
-    @Getter
-    @AllArgsConstructor
-    @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
-    public static class EntryData {
-
-        NodeType type;
-        int[] treeId;
-        Long[] atomicBlockIds;
-        Long[] pageNumbers;
-        Map<String, String> properties;
-        List<EntryData> children;
-
-        @Override
-        public String toString() {
-
-            StringBuilder sb = new StringBuilder();
-            sb.append("[");
-            for (int i : treeId) {
-                sb.append(i);
-                sb.append(",");
-            }
-            sb.delete(sb.length() - 1, sb.length());
-            sb.append("]: ");
-
-            sb.append(type);
-            sb.append(" atbs = ");
-            sb.append(atomicBlockIds.length);
-
-            return sb.toString();
-        }
-
-    }
-
-}

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

@@ -1,20 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.internal.api.data;
-
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.experimental.FieldDefaults;
-
-@Data
-@Builder
-@AllArgsConstructor
-@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
-public class PageData {
-
-    int number;
-    int height;
-    int width;
-    int rotation;
-
-}

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

@@ -0,0 +1,43 @@
+package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
+
+import java.io.Serializable;
+
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentPageProto.AllDocumentPages;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentPositionDataProto.AllDocumentPositionData;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentStructureProto.DocumentStructure;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentTextDataProto.AllDocumentTextData;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.experimental.FieldDefaults;
+
+@Data
+@Builder
+@AllArgsConstructor
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+@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.")
+    AllDocumentPages documentPages;
+    @Schema(description = "Contains information about the document's text.")
+    AllDocumentTextData documentTextData;
+    @Schema(description = "Contains information about the document's text positions.")
+    AllDocumentPositionData documentPositions;
+    @Schema(description = "Contains information about the document's semantic structure.")
+    DocumentStructureWrapper documentStructureWrapper;
+
+
+    public DocumentStructure getDocumentStructure() {
+
+        return documentStructureWrapper.getDocumentStructure();
+    }
+
+}

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

@@ -0,0 +1,31 @@
+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;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+@Deprecated
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE)
+@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

@@ -0,0 +1,29 @@
+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;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+@Deprecated
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE)
+@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

@@ -0,0 +1,173 @@
+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.Set;
+import java.util.stream.Stream;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+@Deprecated
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE)
+@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";
+
+        public static final String REPRESENTATION_HASH = "representationHash";
+
+    }
+
+    @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";
+
+    }
+
+    @Schema(description = "Object containing the extra field names, a duplicate paragraph has in its properties field.")
+    public static class DuplicateParagraphProperties implements Serializable {
+
+        public static final String UNSORTED_TEXTBLOCK_ID = "utbid";
+
+    }
+
+    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 static double[] parseRepresentationVector(String representationHash) {
+
+        String[] stringArray = representationHash.split("[,\\s]+");
+        double[] doubleArray = new double[stringArray.length];
+        for (int i = 0; i < stringArray.length; i++) {
+            doubleArray[i] = Double.parseDouble(stringArray[i]);
+        }
+
+        return doubleArray;
+    }
+
+
+    public EntryData get(List<Integer> tocId) {
+
+        if (tocId.isEmpty()) {
+            return root;
+        }
+        EntryData entry = root.children.get(tocId.get(0));
+        for (int id : tocId.subList(1, tocId.size())) {
+            entry = entry.children.get(id);
+        }
+        return entry;
+    }
+
+
+    public Stream<EntryData> streamAllEntries() {
+
+        return Stream.concat(Stream.of(root), root.children.stream())
+                .flatMap(DocumentStructure::flatten);
+    }
+
+
+    public String toString() {
+
+        return String.join("\n",
+                           streamAllEntries().map(EntryData::toString)
+                                   .toList());
+    }
+
+
+    private static Stream<EntryData> flatten(EntryData entry) {
+
+        return Stream.concat(Stream.of(entry),
+                             entry.children.stream()
+                                     .flatMap(DocumentStructure::flatten));
+    }
+
+
+    @Data
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    @FieldDefaults(level = AccessLevel.PRIVATE)
+    @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;
+        @Schema(description = "Describes the origin of the semantic node", example = "[ALGORITHM]")
+        Set<LayoutEngine> engines;
+
+
+        @Override
+        public String toString() {
+
+            StringBuilder sb = new StringBuilder();
+            sb.append("[");
+            for (int i : treeId) {
+                sb.append(i);
+                sb.append(",");
+            }
+            sb.delete(sb.length() - 1, sb.length());
+            sb.append("]: ");
+
+            sb.append(type);
+            sb.append(" atbs = ");
+            sb.append(atomicBlockIds.length);
+
+            return sb.toString();
+        }
+
+    }
+
+}

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

@@ -0,0 +1,799 @@
+package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
+
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// NO CHECKED-IN PROTOBUF GENCODE
+// source: DocumentStructure.proto
+// Protobuf Java Version: 4.27.1
+@SuppressWarnings("all")
+public final class DocumentStructureProto {
+
+    private DocumentStructureProto() {}
+
+
+    static {
+        com.google.protobuf.RuntimeVersion.validateProtobufGencodeVersion(com.google.protobuf.RuntimeVersion.RuntimeDomain.PUBLIC,
+                /* major= */ 4,
+                /* minor= */ 27,
+                /* patch= */ 1,
+                /* suffix= */ "", DocumentStructureProto.class.getName());
+    }
+
+    public static void registerAllExtensions(com.google.protobuf.ExtensionRegistryLite registry) {
+
+    }
+
+
+    public static void registerAllExtensions(com.google.protobuf.ExtensionRegistry registry) {
+
+        registerAllExtensions((com.google.protobuf.ExtensionRegistryLite) registry);
+    }
+
+
+    public interface DocumentStructureOrBuilder extends
+            // @@protoc_insertion_point(interface_extends:DocumentStructure)
+            com.google.protobuf.MessageOrBuilder {
+
+        /**
+         * <pre>
+         * The root EntryData represents the Document.
+         * </pre>
+         *
+         * <code>.EntryData root = 1;</code>
+         *
+         * @return Whether the root field is set.
+         */
+        boolean hasRoot();
+
+
+        /**
+         * <pre>
+         * The root EntryData represents the Document.
+         * </pre>
+         *
+         * <code>.EntryData root = 1;</code>
+         *
+         * @return The root.
+         */
+        EntryDataProto.EntryData getRoot();
+
+
+        /**
+         * <pre>
+         * The root EntryData represents the Document.
+         * </pre>
+         *
+         * <code>.EntryData root = 1;</code>
+         */
+        EntryDataProto.EntryDataOrBuilder getRootOrBuilder();
+
+    }
+
+    /**
+     * Protobuf type {@code DocumentStructure}
+     */
+    public static final class DocumentStructure extends com.google.protobuf.GeneratedMessage implements
+            // @@protoc_insertion_point(message_implements:DocumentStructure)
+            DocumentStructureOrBuilder {
+
+        private static final long serialVersionUID = 0L;
+
+        static {
+            com.google.protobuf.RuntimeVersion.validateProtobufGencodeVersion(com.google.protobuf.RuntimeVersion.RuntimeDomain.PUBLIC,
+                    /* major= */ 4,
+                    /* minor= */ 27,
+                    /* patch= */ 1,
+                    /* suffix= */ "", DocumentStructure.class.getName());
+        }
+
+        // Use DocumentStructure.newBuilder() to construct.
+        private DocumentStructure(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+
+            super(builder);
+        }
+
+
+        private DocumentStructure() {
+
+        }
+
+
+        public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
+
+            return DocumentStructureProto.internal_static_DocumentStructure_descriptor;
+        }
+
+
+        @Override
+        protected FieldAccessorTable internalGetFieldAccessorTable() {
+
+            return DocumentStructureProto.internal_static_DocumentStructure_fieldAccessorTable.ensureFieldAccessorsInitialized(DocumentStructure.class, Builder.class);
+        }
+
+
+        private int bitField0_;
+        public static final int ROOT_FIELD_NUMBER = 1;
+        private EntryDataProto.EntryData root_;
+
+
+        /**
+         * <pre>
+         * The root EntryData represents the Document.
+         * </pre>
+         *
+         * <code>.EntryData root = 1;</code>
+         *
+         * @return Whether the root field is set.
+         */
+        @Override
+        public boolean hasRoot() {
+
+            return ((bitField0_ & 0x00000001) != 0);
+        }
+
+
+        /**
+         * <pre>
+         * The root EntryData represents the Document.
+         * </pre>
+         *
+         * <code>.EntryData root = 1;</code>
+         *
+         * @return The root.
+         */
+        @Override
+        public EntryDataProto.EntryData getRoot() {
+
+            return root_ == null ? EntryDataProto.EntryData.getDefaultInstance() : root_;
+        }
+
+
+        /**
+         * <pre>
+         * The root EntryData represents the Document.
+         * </pre>
+         *
+         * <code>.EntryData root = 1;</code>
+         */
+        @Override
+        public EntryDataProto.EntryDataOrBuilder getRootOrBuilder() {
+
+            return root_ == null ? EntryDataProto.EntryData.getDefaultInstance() : root_;
+        }
+
+
+        private byte memoizedIsInitialized = -1;
+
+
+        @Override
+        public final boolean isInitialized() {
+
+            byte isInitialized = memoizedIsInitialized;
+          if (isInitialized == 1) {
+            return true;
+          }
+          if (isInitialized == 0) {
+            return false;
+          }
+
+            memoizedIsInitialized = 1;
+            return true;
+        }
+
+
+        @Override
+        public void writeTo(com.google.protobuf.CodedOutputStream output) throws java.io.IOException {
+
+            if (((bitField0_ & 0x00000001) != 0)) {
+                output.writeMessage(1, getRoot());
+            }
+            getUnknownFields().writeTo(output);
+        }
+
+
+        @Override
+        public int getSerializedSize() {
+
+            int size = memoizedSize;
+          if (size != -1) {
+            return size;
+          }
+
+            size = 0;
+            if (((bitField0_ & 0x00000001) != 0)) {
+                size += com.google.protobuf.CodedOutputStream.computeMessageSize(1, getRoot());
+            }
+            size += getUnknownFields().getSerializedSize();
+            memoizedSize = size;
+            return size;
+        }
+
+
+        @Override
+        public boolean equals(final Object obj) {
+
+            if (obj == this) {
+                return true;
+            }
+            if (!(obj instanceof DocumentStructure)) {
+                return super.equals(obj);
+            }
+            DocumentStructure other = (DocumentStructure) obj;
+
+          if (hasRoot() != other.hasRoot()) {
+            return false;
+          }
+            if (hasRoot()) {
+              if (!getRoot().equals(other.getRoot())) {
+                return false;
+              }
+            }
+          if (!getUnknownFields().equals(other.getUnknownFields())) {
+            return false;
+          }
+            return true;
+        }
+
+
+        @Override
+        public int hashCode() {
+
+            if (memoizedHashCode != 0) {
+                return memoizedHashCode;
+            }
+            int hash = 41;
+            hash = (19 * hash) + getDescriptor().hashCode();
+            if (hasRoot()) {
+                hash = (37 * hash) + ROOT_FIELD_NUMBER;
+                hash = (53 * hash) + getRoot().hashCode();
+            }
+            hash = (29 * hash) + getUnknownFields().hashCode();
+            memoizedHashCode = hash;
+            return hash;
+        }
+
+
+        public static DocumentStructure parseFrom(java.nio.ByteBuffer data) throws com.google.protobuf.InvalidProtocolBufferException {
+
+            return PARSER.parseFrom(data);
+        }
+
+
+        public static DocumentStructure parseFrom(java.nio.ByteBuffer data,
+                                                  com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException {
+
+            return PARSER.parseFrom(data, extensionRegistry);
+        }
+
+
+        public static DocumentStructure parseFrom(com.google.protobuf.ByteString data) throws com.google.protobuf.InvalidProtocolBufferException {
+
+            return PARSER.parseFrom(data);
+        }
+
+
+        public static DocumentStructure parseFrom(com.google.protobuf.ByteString data,
+                                                  com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException {
+
+            return PARSER.parseFrom(data, extensionRegistry);
+        }
+
+
+        public static DocumentStructure parseFrom(byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+
+            return PARSER.parseFrom(data);
+        }
+
+
+        public static DocumentStructure parseFrom(byte[] data,
+                                                  com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException {
+
+            return PARSER.parseFrom(data, extensionRegistry);
+        }
+
+
+        public static DocumentStructure parseFrom(java.io.InputStream input) throws java.io.IOException {
+
+            return com.google.protobuf.GeneratedMessage.parseWithIOException(PARSER, input);
+        }
+
+
+        public static DocumentStructure parseFrom(java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException {
+
+            return com.google.protobuf.GeneratedMessage.parseWithIOException(PARSER, input, extensionRegistry);
+        }
+
+
+        public static DocumentStructure parseDelimitedFrom(java.io.InputStream input) throws java.io.IOException {
+
+            return com.google.protobuf.GeneratedMessage.parseDelimitedWithIOException(PARSER, input);
+        }
+
+
+        public static DocumentStructure parseDelimitedFrom(java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException {
+
+            return com.google.protobuf.GeneratedMessage.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+        }
+
+
+        public static DocumentStructure parseFrom(com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+
+            return com.google.protobuf.GeneratedMessage.parseWithIOException(PARSER, input);
+        }
+
+
+        public static DocumentStructure parseFrom(com.google.protobuf.CodedInputStream input,
+                                                  com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException {
+
+            return com.google.protobuf.GeneratedMessage.parseWithIOException(PARSER, input, extensionRegistry);
+        }
+
+
+        @Override
+        public Builder newBuilderForType() {return newBuilder();}
+
+
+        public static Builder newBuilder() {
+
+            return DEFAULT_INSTANCE.toBuilder();
+        }
+
+
+        public static Builder newBuilder(DocumentStructure prototype) {
+
+            return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+        }
+
+
+        @Override
+        public Builder toBuilder() {
+
+            return this == DEFAULT_INSTANCE ? new Builder() : new Builder().mergeFrom(this);
+        }
+
+
+        @Override
+        protected Builder newBuilderForType(BuilderParent parent) {
+
+            Builder builder = new Builder(parent);
+            return builder;
+        }
+
+
+        /**
+         * Protobuf type {@code DocumentStructure}
+         */
+        public static final class Builder extends com.google.protobuf.GeneratedMessage.Builder<Builder> implements
+                // @@protoc_insertion_point(builder_implements:DocumentStructure)
+                DocumentStructureOrBuilder {
+
+            public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
+
+                return DocumentStructureProto.internal_static_DocumentStructure_descriptor;
+            }
+
+
+            @Override
+            protected FieldAccessorTable internalGetFieldAccessorTable() {
+
+                return DocumentStructureProto.internal_static_DocumentStructure_fieldAccessorTable.ensureFieldAccessorsInitialized(DocumentStructure.class, Builder.class);
+            }
+
+
+            // Construct using DocumentStructureOuterClass.DocumentStructure.newBuilder()
+            private Builder() {
+
+                maybeForceBuilderInitialization();
+            }
+
+
+            private Builder(BuilderParent parent) {
+
+                super(parent);
+                maybeForceBuilderInitialization();
+            }
+
+
+            private void maybeForceBuilderInitialization() {
+
+                if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+                    getRootFieldBuilder();
+                }
+            }
+
+
+            @Override
+            public Builder clear() {
+
+                super.clear();
+                bitField0_ = 0;
+                root_ = null;
+                if (rootBuilder_ != null) {
+                    rootBuilder_.dispose();
+                    rootBuilder_ = null;
+                }
+                return this;
+            }
+
+
+            @Override
+            public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
+
+                return DocumentStructureProto.internal_static_DocumentStructure_descriptor;
+            }
+
+
+            @Override
+            public DocumentStructure getDefaultInstanceForType() {
+
+                return DocumentStructure.getDefaultInstance();
+            }
+
+
+            @Override
+            public DocumentStructure build() {
+
+                DocumentStructure result = buildPartial();
+                if (!result.isInitialized()) {
+                    throw newUninitializedMessageException(result);
+                }
+                return result;
+            }
+
+
+            @Override
+            public DocumentStructure buildPartial() {
+
+                DocumentStructure result = new DocumentStructure(this);
+                if (bitField0_ != 0) {
+                    buildPartial0(result);
+                }
+                onBuilt();
+                return result;
+            }
+
+
+            private void buildPartial0(DocumentStructure result) {
+
+                int from_bitField0_ = bitField0_;
+                int to_bitField0_ = 0;
+                if (((from_bitField0_ & 0x00000001) != 0)) {
+                    result.root_ = rootBuilder_ == null ? root_ : rootBuilder_.build();
+                    to_bitField0_ |= 0x00000001;
+                }
+                result.bitField0_ |= to_bitField0_;
+            }
+
+
+            @Override
+            public Builder mergeFrom(com.google.protobuf.Message other) {
+
+                if (other instanceof DocumentStructure) {
+                    return mergeFrom((DocumentStructure) other);
+                } else {
+                    super.mergeFrom(other);
+                    return this;
+                }
+            }
+
+
+            public Builder mergeFrom(DocumentStructure other) {
+
+              if (other == DocumentStructure.getDefaultInstance()) {
+                return this;
+              }
+                if (other.hasRoot()) {
+                    mergeRoot(other.getRoot());
+                }
+                this.mergeUnknownFields(other.getUnknownFields());
+                onChanged();
+                return this;
+            }
+
+
+            @Override
+            public final boolean isInitialized() {
+
+                return true;
+            }
+
+
+            @Override
+            public Builder mergeFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException {
+
+                if (extensionRegistry == null) {
+                    throw new NullPointerException();
+                }
+                try {
+                    boolean done = false;
+                    while (!done) {
+                        int tag = input.readTag();
+                        switch (tag) {
+                            case 0:
+                                done = true;
+                                break;
+                            case 10: {
+                                input.readMessage(getRootFieldBuilder().getBuilder(), extensionRegistry);
+                                bitField0_ |= 0x00000001;
+                                break;
+                            } // case 10
+                            default: {
+                                if (!super.parseUnknownField(input, extensionRegistry, tag)) {
+                                    done = true; // was an endgroup tag
+                                }
+                                break;
+                            } // default:
+                        } // switch (tag)
+                    } // while (!done)
+                } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+                    throw e.unwrapIOException();
+                } finally {
+                    onChanged();
+                } // finally
+                return this;
+            }
+
+
+            private int bitField0_;
+
+            private EntryDataProto.EntryData root_;
+            private com.google.protobuf.SingleFieldBuilder<EntryDataProto.EntryData, EntryDataProto.EntryData.Builder, EntryDataProto.EntryDataOrBuilder> rootBuilder_;
+
+
+            /**
+             * <pre>
+             * The root EntryData represents the Document.
+             * </pre>
+             *
+             * <code>.EntryData root = 1;</code>
+             *
+             * @return Whether the root field is set.
+             */
+            public boolean hasRoot() {
+
+                return ((bitField0_ & 0x00000001) != 0);
+            }
+
+
+            /**
+             * <pre>
+             * The root EntryData represents the Document.
+             * </pre>
+             *
+             * <code>.EntryData root = 1;</code>
+             *
+             * @return The root.
+             */
+            public EntryDataProto.EntryData getRoot() {
+
+                if (rootBuilder_ == null) {
+                    return root_ == null ? EntryDataProto.EntryData.getDefaultInstance() : root_;
+                } else {
+                    return rootBuilder_.getMessage();
+                }
+            }
+
+
+            /**
+             * <pre>
+             * The root EntryData represents the Document.
+             * </pre>
+             *
+             * <code>.EntryData root = 1;</code>
+             */
+            public Builder setRoot(EntryDataProto.EntryData value) {
+
+                if (rootBuilder_ == null) {
+                    if (value == null) {
+                        throw new NullPointerException();
+                    }
+                    root_ = value;
+                } else {
+                    rootBuilder_.setMessage(value);
+                }
+                bitField0_ |= 0x00000001;
+                onChanged();
+                return this;
+            }
+
+
+            /**
+             * <pre>
+             * The root EntryData represents the Document.
+             * </pre>
+             *
+             * <code>.EntryData root = 1;</code>
+             */
+            public Builder setRoot(EntryDataProto.EntryData.Builder builderForValue) {
+
+                if (rootBuilder_ == null) {
+                    root_ = builderForValue.build();
+                } else {
+                    rootBuilder_.setMessage(builderForValue.build());
+                }
+                bitField0_ |= 0x00000001;
+                onChanged();
+                return this;
+            }
+
+
+            /**
+             * <pre>
+             * The root EntryData represents the Document.
+             * </pre>
+             *
+             * <code>.EntryData root = 1;</code>
+             */
+            public Builder mergeRoot(EntryDataProto.EntryData value) {
+
+                if (rootBuilder_ == null) {
+                    if (((bitField0_ & 0x00000001) != 0) && root_ != null && root_ != EntryDataProto.EntryData.getDefaultInstance()) {
+                        getRootBuilder().mergeFrom(value);
+                    } else {
+                        root_ = value;
+                    }
+                } else {
+                    rootBuilder_.mergeFrom(value);
+                }
+                if (root_ != null) {
+                    bitField0_ |= 0x00000001;
+                    onChanged();
+                }
+                return this;
+            }
+
+
+            /**
+             * <pre>
+             * The root EntryData represents the Document.
+             * </pre>
+             *
+             * <code>.EntryData root = 1;</code>
+             */
+            public Builder clearRoot() {
+
+                bitField0_ = (bitField0_ & ~0x00000001);
+                root_ = null;
+                if (rootBuilder_ != null) {
+                    rootBuilder_.dispose();
+                    rootBuilder_ = null;
+                }
+                onChanged();
+                return this;
+            }
+
+
+            /**
+             * <pre>
+             * The root EntryData represents the Document.
+             * </pre>
+             *
+             * <code>.EntryData root = 1;</code>
+             */
+            public EntryDataProto.EntryData.Builder getRootBuilder() {
+
+                bitField0_ |= 0x00000001;
+                onChanged();
+                return getRootFieldBuilder().getBuilder();
+            }
+
+
+            /**
+             * <pre>
+             * The root EntryData represents the Document.
+             * </pre>
+             *
+             * <code>.EntryData root = 1;</code>
+             */
+            public EntryDataProto.EntryDataOrBuilder getRootOrBuilder() {
+
+                if (rootBuilder_ != null) {
+                    return rootBuilder_.getMessageOrBuilder();
+                } else {
+                    return root_ == null ? EntryDataProto.EntryData.getDefaultInstance() : root_;
+                }
+            }
+
+
+            /**
+             * <pre>
+             * The root EntryData represents the Document.
+             * </pre>
+             *
+             * <code>.EntryData root = 1;</code>
+             */
+            private com.google.protobuf.SingleFieldBuilder<EntryDataProto.EntryData, EntryDataProto.EntryData.Builder, EntryDataProto.EntryDataOrBuilder> getRootFieldBuilder() {
+
+                if (rootBuilder_ == null) {
+                    rootBuilder_ = new com.google.protobuf.SingleFieldBuilder<EntryDataProto.EntryData, EntryDataProto.EntryData.Builder, EntryDataProto.EntryDataOrBuilder>(getRoot(),
+                                                                                                                                                                             getParentForChildren(),
+                                                                                                                                                                             isClean());
+                    root_ = null;
+                }
+                return rootBuilder_;
+            }
+
+            // @@protoc_insertion_point(builder_scope:DocumentStructure)
+        }
+
+        // @@protoc_insertion_point(class_scope:DocumentStructure)
+        private static final DocumentStructure DEFAULT_INSTANCE;
+
+        static {
+            DEFAULT_INSTANCE = new DocumentStructure();
+        }
+
+        public static DocumentStructure getDefaultInstance() {
+
+            return DEFAULT_INSTANCE;
+        }
+
+
+        private static final com.google.protobuf.Parser<DocumentStructure> PARSER = new com.google.protobuf.AbstractParser<DocumentStructure>() {
+            @Override
+            public DocumentStructure parsePartialFrom(com.google.protobuf.CodedInputStream input,
+                                                      com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException {
+
+                Builder builder = newBuilder();
+                try {
+                    builder.mergeFrom(input, extensionRegistry);
+                } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+                    throw e.setUnfinishedMessage(builder.buildPartial());
+                } catch (com.google.protobuf.UninitializedMessageException e) {
+                    throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
+                } catch (java.io.IOException e) {
+                    throw new com.google.protobuf.InvalidProtocolBufferException(e).setUnfinishedMessage(builder.buildPartial());
+                }
+                return builder.buildPartial();
+            }
+        };
+
+
+        public static com.google.protobuf.Parser<DocumentStructure> parser() {
+
+            return PARSER;
+        }
+
+
+        @Override
+        public com.google.protobuf.Parser<DocumentStructure> getParserForType() {
+
+            return PARSER;
+        }
+
+
+        @Override
+        public DocumentStructure getDefaultInstanceForType() {
+
+            return DEFAULT_INSTANCE;
+        }
+
+    }
+
+    private static final com.google.protobuf.Descriptors.Descriptor internal_static_DocumentStructure_descriptor;
+    private static final com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_DocumentStructure_fieldAccessorTable;
+
+
+    public static com.google.protobuf.Descriptors.FileDescriptor getDescriptor() {
+
+        return descriptor;
+    }
+
+
+    private static com.google.protobuf.Descriptors.FileDescriptor descriptor;
+
+    static {
+        String[] descriptorData = {"\n\027DocumentStructure.proto\032\017EntryData.pro"
+                                   + "to\"-\n\021DocumentStructure\022\030\n\004root\030\001 \001(\0132\n."
+                                   + "EntryDatab\006proto3"};
+        descriptor = com.google.protobuf.Descriptors.FileDescriptor.internalBuildGeneratedFileFrom(descriptorData,
+                                                                                                   new com.google.protobuf.Descriptors.FileDescriptor[]{EntryDataProto.getDescriptor(),});
+        internal_static_DocumentStructure_descriptor = getDescriptor().getMessageTypes()
+                .get(0);
+        internal_static_DocumentStructure_fieldAccessorTable = new com.google.protobuf.GeneratedMessage.FieldAccessorTable(internal_static_DocumentStructure_descriptor,
+                                                                                                                           new String[]{"Root",});
+        descriptor.resolveAllFeaturesImmutable();
+        EntryDataProto.getDescriptor();
+    }
+
+    // @@protoc_insertion_point(outer_class_scope)
+}

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

@@ -0,0 +1,126 @@
+package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
+
+import static com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentStructureProto.DocumentStructure;
+
+import java.awt.geom.Rectangle2D;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.EntryDataProto.EntryData;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class DocumentStructureWrapper implements Serializable {
+
+    private final DocumentStructure documentStructure;
+
+
+    @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";
+
+        public static final String REPRESENTATION_HASH = "representationHash";
+
+    }
+
+    @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";
+
+    }
+
+    @Schema(description = "Object containing the extra field names, a duplicate paragraph has in its properties field.")
+    public static class DuplicateParagraphProperties implements Serializable {
+
+        public static final String UNSORTED_TEXTBLOCK_ID = "utbid";
+
+    }
+
+    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 static double[] parseRepresentationVector(String representationHash) {
+
+        String[] stringArray = representationHash.split("[,\\s]+");
+        double[] doubleArray = new double[stringArray.length];
+        for (int i = 0; i < stringArray.length; i++) {
+            doubleArray[i] = Double.parseDouble(stringArray[i]);
+        }
+
+        return doubleArray;
+    }
+
+
+    public EntryData get(List<Integer> tocId) {
+
+        if (tocId.isEmpty()) {
+            return documentStructure.getRoot();
+        }
+        EntryData entry = documentStructure.getRoot().getChildrenList()
+                .get(tocId.get(0));
+        for (int id : tocId.subList(1, tocId.size())) {
+            entry = entry.getChildrenList()
+                    .get(id);
+        }
+        return entry;
+    }
+
+
+    public Stream<EntryData> streamAllEntries() {
+
+        return Stream.concat(Stream.of(documentStructure.getRoot()),
+                             documentStructure.getRoot().getChildrenList()
+                                     .stream())
+                .flatMap(DocumentStructureWrapper::flatten);
+    }
+
+
+    public String toString() {
+
+        return String.join("\n",
+                           streamAllEntries().map(EntryData::toString)
+                                   .toList());
+    }
+
+
+    private static Stream<EntryData> flatten(EntryData entry) {
+
+        return Stream.concat(Stream.of(entry),
+                             entry.getChildrenList()
+                                     .stream()
+                                     .flatMap(DocumentStructureWrapper::flatten));
+    }
+
+}

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

@@ -0,0 +1,37 @@
+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;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+@Deprecated
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE)
+@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/LayoutEngine.java

@@ -0,0 +1,8 @@
+package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
+
+@Deprecated
+public enum LayoutEngine {
+    ALGORITHM,
+    AI,
+    OUTLINE
+}

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

@@ -0,0 +1,193 @@
+package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
+
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// NO CHECKED-IN PROTOBUF GENCODE
+// source: LayoutEngine.proto
+// Protobuf Java Version: 4.27.1
+@SuppressWarnings("all")
+public final class LayoutEngineProto {
+
+    private LayoutEngineProto() {}
+
+
+    static {
+        com.google.protobuf.RuntimeVersion.validateProtobufGencodeVersion(com.google.protobuf.RuntimeVersion.RuntimeDomain.PUBLIC,
+                /* major= */ 4,
+                /* minor= */ 27,
+                /* patch= */ 1,
+                /* suffix= */ "", LayoutEngineProto.class.getName());
+    }
+
+    public static void registerAllExtensions(com.google.protobuf.ExtensionRegistryLite registry) {
+
+    }
+
+
+    public static void registerAllExtensions(com.google.protobuf.ExtensionRegistry registry) {
+
+        registerAllExtensions((com.google.protobuf.ExtensionRegistryLite) registry);
+    }
+
+
+    /**
+     * Protobuf enum {@code LayoutEngine}
+     */
+    public enum LayoutEngine implements com.google.protobuf.ProtocolMessageEnum {
+        /**
+         * <code>ALGORITHM = 0;</code>
+         */
+        ALGORITHM(0),
+        /**
+         * <code>AI = 1;</code>
+         */
+        AI(1),
+        /**
+         * <code>OUTLINE = 2;</code>
+         */
+        OUTLINE(2),
+        UNRECOGNIZED(-1),
+        ;
+
+
+        static {
+            com.google.protobuf.RuntimeVersion.validateProtobufGencodeVersion(com.google.protobuf.RuntimeVersion.RuntimeDomain.PUBLIC,
+                    /* major= */ 4,
+                    /* minor= */ 27,
+                    /* patch= */ 1,
+                    /* suffix= */ "", LayoutEngine.class.getName());
+        }
+
+        /**
+         * <code>ALGORITHM = 0;</code>
+         */
+        public static final int ALGORITHM_VALUE = 0;
+        /**
+         * <code>AI = 1;</code>
+         */
+        public static final int AI_VALUE = 1;
+        /**
+         * <code>OUTLINE = 2;</code>
+         */
+        public static final int OUTLINE_VALUE = 2;
+
+
+        public final int getNumber() {
+
+            if (this == UNRECOGNIZED) {
+                throw new IllegalArgumentException("Can't get the number of an unknown enum value.");
+            }
+            return value;
+        }
+
+
+        /**
+         * @param value The numeric wire value of the corresponding enum entry.
+         * @return The enum associated with the given numeric wire value.
+         * @deprecated Use {@link #forNumber(int)} instead.
+         */
+        @Deprecated
+        public static LayoutEngine valueOf(int value) {
+
+            return forNumber(value);
+        }
+
+
+        /**
+         * @param value The numeric wire value of the corresponding enum entry.
+         * @return The enum associated with the given numeric wire value.
+         */
+        public static LayoutEngine forNumber(int value) {
+
+            switch (value) {
+                case 0:
+                    return ALGORITHM;
+                case 1:
+                    return AI;
+                case 2:
+                    return OUTLINE;
+                default:
+                    return null;
+            }
+        }
+
+
+        public static com.google.protobuf.Internal.EnumLiteMap<LayoutEngine> internalGetValueMap() {
+
+            return internalValueMap;
+        }
+
+
+        private static final com.google.protobuf.Internal.EnumLiteMap<LayoutEngine> internalValueMap = new com.google.protobuf.Internal.EnumLiteMap<LayoutEngine>() {
+            public LayoutEngine findValueByNumber(int number) {
+
+                return LayoutEngine.forNumber(number);
+            }
+        };
+
+
+        public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() {
+
+            if (this == UNRECOGNIZED) {
+                throw new IllegalStateException("Can't get the descriptor of an unrecognized enum value.");
+            }
+            return getDescriptor().getValues()
+                    .get(ordinal());
+        }
+
+
+        public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() {
+
+            return getDescriptor();
+        }
+
+
+        public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() {
+
+            return LayoutEngineProto.getDescriptor().getEnumTypes()
+                    .get(0);
+        }
+
+
+        private static final LayoutEngine[] VALUES = values();
+
+
+        public static LayoutEngine valueOf(com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
+
+            if (desc.getType() != getDescriptor()) {
+                throw new IllegalArgumentException("EnumValueDescriptor is not for this type.");
+            }
+            if (desc.getIndex() == -1) {
+                return UNRECOGNIZED;
+            }
+            return VALUES[desc.getIndex()];
+        }
+
+
+        private final int value;
+
+
+        private LayoutEngine(int value) {
+
+            this.value = value;
+        }
+
+        // @@protoc_insertion_point(enum_scope:LayoutEngine)
+    }
+
+
+    public static com.google.protobuf.Descriptors.FileDescriptor getDescriptor() {
+
+        return descriptor;
+    }
+
+
+    private static com.google.protobuf.Descriptors.FileDescriptor descriptor;
+
+    static {
+        String[] descriptorData = {"\n\022LayoutEngine.proto*2\n\014LayoutEngine\022\r\n\t" + "ALGORITHM\020\000\022\006\n\002AI\020\001\022\013\n\007OUTLINE\020\002b\006proto3"};
+        descriptor = com.google.protobuf.Descriptors.FileDescriptor.internalBuildGeneratedFileFrom(descriptorData, new com.google.protobuf.Descriptors.FileDescriptor[]{});
+        descriptor.resolveAllFeaturesImmutable();
+    }
+
+    // @@protoc_insertion_point(outer_class_scope)
+}

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

@@ -1,10 +1,13 @@
-package com.knecon.fforesight.service.layoutparser.internal.api.data;
+package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
 
+import java.io.Serializable;
 import java.util.Locale;
 
-public enum NodeType {
+@Deprecated
+public enum NodeType implements Serializable {
     DOCUMENT,
     SECTION,
+    SUPER_SECTION,
     HEADLINE,
     PARAGRAPH,
     TABLE,

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

@@ -0,0 +1,274 @@
+package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
+
+import java.util.Locale;
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// NO CHECKED-IN PROTOBUF GENCODE
+// source: NodeType.proto
+// Protobuf Java Version: 4.27.1
+@SuppressWarnings("all")
+public final class NodeTypeProto {
+
+    private NodeTypeProto() {}
+
+
+    static {
+        com.google.protobuf.RuntimeVersion.validateProtobufGencodeVersion(com.google.protobuf.RuntimeVersion.RuntimeDomain.PUBLIC,
+                /* major= */ 4,
+                /* minor= */ 27,
+                /* patch= */ 1,
+                /* suffix= */ "", NodeTypeProto.class.getName());
+    }
+
+    public static void registerAllExtensions(com.google.protobuf.ExtensionRegistryLite registry) {
+
+    }
+
+
+    public static void registerAllExtensions(com.google.protobuf.ExtensionRegistry registry) {
+
+        registerAllExtensions((com.google.protobuf.ExtensionRegistryLite) registry);
+    }
+
+
+    /**
+     * Protobuf enum {@code NodeType}
+     */
+    public enum NodeType implements com.google.protobuf.ProtocolMessageEnum {
+        /**
+         * <code>DOCUMENT = 0;</code>
+         */
+        DOCUMENT(0),
+        /**
+         * <code>SECTION = 1;</code>
+         */
+        SECTION(1),
+        /**
+         * <code>SUPER_SECTION = 2;</code>
+         */
+        SUPER_SECTION(2),
+        /**
+         * <code>HEADLINE = 3;</code>
+         */
+        HEADLINE(3),
+        /**
+         * <code>PARAGRAPH = 4;</code>
+         */
+        PARAGRAPH(4),
+        /**
+         * <code>TABLE = 5;</code>
+         */
+        TABLE(5),
+        /**
+         * <code>TABLE_CELL = 6;</code>
+         */
+        TABLE_CELL(6),
+        /**
+         * <code>IMAGE = 7;</code>
+         */
+        IMAGE(7),
+        /**
+         * <code>HEADER = 8;</code>
+         */
+        HEADER(8),
+        /**
+         * <code>FOOTER = 9;</code>
+         */
+        FOOTER(9),
+        UNRECOGNIZED(-1),
+        ;
+
+
+        public String toString() {
+
+            return this.name().charAt(0) + this.name().substring(1).toLowerCase(Locale.ROOT);
+        }
+
+
+        static {
+            com.google.protobuf.RuntimeVersion.validateProtobufGencodeVersion(com.google.protobuf.RuntimeVersion.RuntimeDomain.PUBLIC,
+                    /* major= */ 4,
+                    /* minor= */ 27,
+                    /* patch= */ 1,
+                    /* suffix= */ "", NodeType.class.getName());
+        }
+
+        /**
+         * <code>DOCUMENT = 0;</code>
+         */
+        public static final int DOCUMENT_VALUE = 0;
+        /**
+         * <code>SECTION = 1;</code>
+         */
+        public static final int SECTION_VALUE = 1;
+        /**
+         * <code>SUPER_SECTION = 2;</code>
+         */
+        public static final int SUPER_SECTION_VALUE = 2;
+        /**
+         * <code>HEADLINE = 3;</code>
+         */
+        public static final int HEADLINE_VALUE = 3;
+        /**
+         * <code>PARAGRAPH = 4;</code>
+         */
+        public static final int PARAGRAPH_VALUE = 4;
+        /**
+         * <code>TABLE = 5;</code>
+         */
+        public static final int TABLE_VALUE = 5;
+        /**
+         * <code>TABLE_CELL = 6;</code>
+         */
+        public static final int TABLE_CELL_VALUE = 6;
+        /**
+         * <code>IMAGE = 7;</code>
+         */
+        public static final int IMAGE_VALUE = 7;
+        /**
+         * <code>HEADER = 8;</code>
+         */
+        public static final int HEADER_VALUE = 8;
+        /**
+         * <code>FOOTER = 9;</code>
+         */
+        public static final int FOOTER_VALUE = 9;
+
+
+        public final int getNumber() {
+
+            if (this == UNRECOGNIZED) {
+                throw new IllegalArgumentException("Can't get the number of an unknown enum value.");
+            }
+            return value;
+        }
+
+
+        /**
+         * @param value The numeric wire value of the corresponding enum entry.
+         * @return The enum associated with the given numeric wire value.
+         * @deprecated Use {@link #forNumber(int)} instead.
+         */
+        @Deprecated
+        public static NodeType valueOf(int value) {
+
+            return forNumber(value);
+        }
+
+
+        /**
+         * @param value The numeric wire value of the corresponding enum entry.
+         * @return The enum associated with the given numeric wire value.
+         */
+        public static NodeType forNumber(int value) {
+
+            switch (value) {
+                case 0:
+                    return DOCUMENT;
+                case 1:
+                    return SECTION;
+                case 2:
+                    return SUPER_SECTION;
+                case 3:
+                    return HEADLINE;
+                case 4:
+                    return PARAGRAPH;
+                case 5:
+                    return TABLE;
+                case 6:
+                    return TABLE_CELL;
+                case 7:
+                    return IMAGE;
+                case 8:
+                    return HEADER;
+                case 9:
+                    return FOOTER;
+                default:
+                    return null;
+            }
+        }
+
+
+        public static com.google.protobuf.Internal.EnumLiteMap<NodeType> internalGetValueMap() {
+
+            return internalValueMap;
+        }
+
+
+        private static final com.google.protobuf.Internal.EnumLiteMap<NodeType> internalValueMap = new com.google.protobuf.Internal.EnumLiteMap<NodeType>() {
+            public NodeType findValueByNumber(int number) {
+
+                return NodeType.forNumber(number);
+            }
+        };
+
+
+        public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() {
+
+            if (this == UNRECOGNIZED) {
+                throw new IllegalStateException("Can't get the descriptor of an unrecognized enum value.");
+            }
+            return getDescriptor().getValues()
+                    .get(ordinal());
+        }
+
+
+        public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() {
+
+            return getDescriptor();
+        }
+
+
+        public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() {
+
+            return NodeTypeProto.getDescriptor().getEnumTypes()
+                    .get(0);
+        }
+
+
+        private static final NodeType[] VALUES = values();
+
+
+        public static NodeType valueOf(com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
+
+            if (desc.getType() != getDescriptor()) {
+                throw new IllegalArgumentException("EnumValueDescriptor is not for this type.");
+            }
+            if (desc.getIndex() == -1) {
+                return UNRECOGNIZED;
+            }
+            return VALUES[desc.getIndex()];
+        }
+
+
+        private final int value;
+
+
+        private NodeType(int value) {
+
+            this.value = value;
+        }
+
+        // @@protoc_insertion_point(enum_scope:NodeType)
+    }
+
+
+    public static com.google.protobuf.Descriptors.FileDescriptor getDescriptor() {
+
+        return descriptor;
+    }
+
+
+    private static com.google.protobuf.Descriptors.FileDescriptor descriptor;
+
+    static {
+        String[] descriptorData = {"\n\016NodeType.proto*\223\001\n\010NodeType\022\014\n\010DOCUMEN"
+                                   + "T\020\000\022\013\n\007SECTION\020\001\022\021\n\rSUPER_SECTION\020\002\022\014\n\010H"
+                                   + "EADLINE\020\003\022\r\n\tPARAGRAPH\020\004\022\t\n\005TABLE\020\005\022\016\n\nT"
+                                   + "ABLE_CELL\020\006\022\t\n\005IMAGE\020\007\022\n\n\006HEADER\020\010\022\n\n\006FO"
+                                   + "OTER\020\tb\006proto3"};
+        descriptor = com.google.protobuf.Descriptors.FileDescriptor.internalBuildGeneratedFileFrom(descriptorData, new com.google.protobuf.Descriptors.FileDescriptor[]{});
+        descriptor.resolveAllFeaturesImmutable();
+    }
+
+    // @@protoc_insertion_point(outer_class_scope)
+}

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 String 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,34 @@
+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.")
+    @Builder.Default
+    private List<SimplifiedSectionText> sectionTexts = new ArrayList<>();
+    @Schema(description = "A list of the main section numbers ")
+    @Builder.Default
+    private List<String> mainSectionNumbers = new ArrayList<>();
+    @Schema(description = "A list of the header section numbers ")
+    @Builder.Default
+    private List<String> headerSectionNumbers = new ArrayList<>();
+    @Schema(description = "A list of the footer section numbers ")
+    @Builder.Default
+    private List<String> footerSectionNumbers = new ArrayList<>();
+
+}

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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +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

@@ -0,0 +1,21 @@
+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;
+
+@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

@@ -0,0 +1,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 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

@@ -0,0 +1,31 @@
+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;
+
+@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 = "The Tree ID of this StructureObject.")
+    List<Integer> treeId;
+    @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

@@ -0,0 +1,21 @@
+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/LayoutParsingQueueNames.java

@@ -2,7 +2,9 @@ package com.knecon.fforesight.service.layoutparser.internal.api.queue;
 
 public class LayoutParsingQueueNames {
 
-    public static final String LAYOUT_PARSING_REQUEST_QUEUE = "LAYOUTPARSING_REQUEST_QUEUE";
-    public static final String LAYOUT_PARSING_DLQ = "LAYOUTPARSING_DLQ";
-    public static final String LAYOUT_PARSING_FINISHED_EVENT_QUEUE = "LAYOUTPARSING_FINISHED_EVENT_QUEUE";
+    public static final String LAYOUT_PARSING_REQUEST_QUEUE_PREFIX = "layout_parsing_request";
+    public static final String LAYOUT_PARSING_REQUEST_EXCHANGE = "layout_parsing_request_exchange";
+    public static final String LAYOUT_PARSING_RESPONSE_QUEUE_PREFIX = "layout_parsing_response";
+    public static final String LAYOUT_PARSING_RESPONSE_EXCHANGE = "layout_parsing_response_exchange";
+    public static final String LAYOUT_PARSING_DLQ = "layout_parsing_error";
 }

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

@@ -3,18 +3,45 @@ 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(
+        @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 textBlockFileStorageId,
-        String positionBlockFileStorageId,
-        String pageFileStorageId) {
+
+        @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 = "Optional Path to the the visual layout parsing service file") Optional<String> visualLayoutParsingFileId,//
+
+        @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 Document Markdown File will be stored.")//
+        Optional<String> documentMarkdownFileStorageId,//
+        @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-internal-api/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/queue/LayoutParsingType.java

@@ -0,0 +1,12 @@
+package com.knecon.fforesight.service.layoutparser.internal.api.queue;
+
+public enum LayoutParsingType {
+    REDACT_MANAGER,
+    REDACT_MANAGER_OLD,
+    REDACT_MANAGER_PARAGRAPH_DEBUG,
+    REDACT_MANAGER_WITHOUT_DUPLICATE_PARAGRAPH,
+    DOCUMINE,
+    DOCUMINE_OLD,
+    CLARIFYND,
+    CLARIFYND_PARAGRAPH_DEBUG
+}

layoutparser-service/layoutparser-service-internal-api/src/main/resources/DocumentPage.proto

@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+message AllDocumentPages {
+
+  repeated DocumentPage documentPages = 1;
+}
+
+message DocumentPage {
+  // The page number, starting with 1.
+  int32 number = 1;
+
+  // The page height in PDF user units.
+  int32 height = 2;
+
+  // The page width in PDF user units.
+  int32 width = 3;
+
+  // The page rotation as specified by the PDF.
+  int32 rotation = 4;
+}
+

layoutparser-service/layoutparser-service-internal-api/src/main/resources/DocumentPositionData.proto

@@ -0,0 +1,25 @@
+syntax = "proto3";
+
+message AllDocumentPositionData {
+
+  repeated DocumentPositionData documentPositionData = 1;
+}
+
+message DocumentPositionData {
+  // Identifier of the text block.
+  int64 id = 1;
+
+  // 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.
+  repeated int32 stringIdxToPositionIdx = 2;
+
+  // 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.
+  repeated Position positions = 3;
+
+  // Definition of a BoundingBox that contains x, y, width, and height.
+  message Position {
+    repeated float value = 1;
+  }
+}

layoutparser-service/layoutparser-service-internal-api/src/main/resources/DocumentStructure.proto

@@ -0,0 +1,8 @@
+syntax = "proto3";
+
+import "EntryData.proto";
+
+message DocumentStructure {
+  // The root EntryData represents the Document.
+  EntryData root = 1;
+}

layoutparser-service/layoutparser-service-internal-api/src/main/resources/DocumentTextData.proto

@@ -0,0 +1,29 @@
+syntax = "proto3";
+
+message AllDocumentTextData {
+
+  repeated DocumentTextData documentTextData = 1;
+}
+
+message DocumentTextData {
+  // Identifier of the text block.
+  int64 id = 1;
+
+  // The page the text block occurs on.
+  int64 page = 2;
+
+  // The text of the text block.
+  string searchText = 3;
+
+  // Each text block is assigned a number on a page, starting from 0.
+  int32 numberOnPage = 4;
+
+  // The text blocks are ordered, this number represents the start of the text block as a string offset.
+  int32 start = 5;
+
+  // The text blocks are ordered, this number represents the end of the text block as a string offset.
+  int32 end = 6;
+
+  // 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.
+  repeated int32 lineBreaks = 7;
+}

layoutparser-service/layoutparser-service-internal-api/src/main/resources/EntryData.proto

@@ -0,0 +1,27 @@
+syntax = "proto3";
+
+import "LayoutEngine.proto";
+import "NodeType.proto";
+
+message EntryData {
+  // Type of the semantic node.
+  NodeType type = 1;
+
+  // Specifies the position in the parsed tree structure.
+  repeated int32 treeId = 2;
+
+  // Specifies the text block IDs associated with this semantic node.
+  repeated int64 atomicBlockIds = 3;
+
+  // Specifies the pages this semantic node appears on.
+  repeated int64 pageNumbers = 4;
+
+  // Some semantic nodes have additional information, this information is stored in this Map.
+  map<string, string> properties = 5;
+
+  // All child Entries of this Entry.
+  repeated EntryData children = 6;
+
+  // Describes the origin of the semantic node.
+  repeated LayoutEngine engines = 7;
+}

layoutparser-service/layoutparser-service-internal-api/src/main/resources/LayoutEngine.proto

@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+enum LayoutEngine {
+  ALGORITHM = 0;
+  AI = 1;
+  OUTLINE = 2;
+}

layoutparser-service/layoutparser-service-internal-api/src/main/resources/NodeType.proto

@@ -0,0 +1,14 @@
+syntax = "proto3";
+
+enum NodeType {
+  DOCUMENT = 0;
+  SECTION = 1;
+  SUPER_SECTION = 2;
+  HEADLINE = 3;
+  PARAGRAPH = 4;
+  TABLE = 5;
+  TABLE_CELL = 6;
+  IMAGE = 7;
+  HEADER = 8;
+  FOOTER = 9;
+}

layoutparser-service/layoutparser-service-internal-api/src/test/resources/log4j2-test.xml

@@ -0,0 +1,16 @@
+<Configuration>
+
+    <Appenders>
+        <Console name="CONSOLE" target="SYSTEM_OUT">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
+        </Console>
+    </Appenders>
+
+    <Loggers>
+        <Root level="warn">
+            <AppenderRef ref="CONSOLE"/>
+        </Root>
+        <Logger name="com.iqser" level="info"/>
+    </Loggers>
+
+</Configuration>

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

@@ -0,0 +1,40 @@
+plugins {
+    id("com.knecon.fforesight.java-conventions")
+    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.564.0-RED9010.0") {
+        exclude("org.springframework.boot", "spring-boot-starter-security")
+        exclude("org.springframework.boot", "spring-boot-starter-validation")
+    }
+    implementation("com.knecon.fforesight:tenant-commons:0.30.0") {
+        exclude("com.iqser.red.commons", "storage-commons")
+    }
+    implementation("com.iqser.red.commons:storage-commons:2.50.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")
+    implementation("org.jgrapht:jgrapht-core:1.5.2")
+    implementation("org.apache.pdfbox:jbig2-imageio:3.0.4")
+    implementation("com.github.jai-imageio:jai-imageio-core:1.4.0")
+    implementation("com.github.jai-imageio:jai-imageio-jpeg2000:1.4.0")
+    implementation("org.tinspin:tinspin-indexes:2.1.3")
+    implementation("org.commonmark:commonmark:0.22.0")
+    implementation("org.commonmark:commonmark-ext-gfm-tables:0.22.0")
+    implementation("com.pdftron:PDFNet:10.11.0")
+    implementation("org.apache.commons:commons-text:1.12.0")
+
+    implementation("com.google.protobuf:protobuf-java-util:4.27.1")
+}

layoutparser-service/layoutparser-service-processor/pom.xml

@@ -1,65 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>com.knecon.fforesight</groupId>
-        <artifactId>layoutparser-service</artifactId>
-        <version>1.0.0</version>
-    </parent>
-
-    <artifactId>layoutparser-service-processor</artifactId>
-
-    <dependencies>
-        <dependency>
-            <groupId>com.iqser.red.service</groupId>
-            <artifactId>persistence-service-shared-api-v1</artifactId>
-            <version>2.36.0</version>
-        </dependency>
-        <dependency>
-            <groupId>com.knecon.fforesight</groupId>
-            <artifactId>tenant-commons</artifactId>
-            <version>${tennat-commons.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.knecon.fforesight</groupId>
-            <artifactId>layoutparser-service-internal-api</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.iqser.red.commons</groupId>
-            <artifactId>storage-commons</artifactId>
-            <version>${storage-commons.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.apache.pdfbox</groupId>
-            <artifactId>pdfbox</artifactId>
-            <version>${pdfbox.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.apache.pdfbox</groupId>
-            <artifactId>pdfbox-tools</artifactId>
-            <version>${pdfbox.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.fasterxml.jackson.module</groupId>
-            <artifactId>jackson-module-afterburner</artifactId>
-            <version>${jackson.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.fasterxml.jackson.datatype</groupId>
-            <artifactId>jackson-datatype-jsr310</artifactId>
-            <version>${jackson.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-web</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-amqp</artifactId>
-        </dependency>
-    </dependencies>
-
-</project>

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

@@ -0,0 +1,461 @@
+package com.knecon.fforesight.service.layoutparser.processor;
+
+import static java.lang.String.format;
+
+import java.awt.geom.AffineTransform;
+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.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+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.NodeTypeProto.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.docstrum.model.Character;
+import com.knecon.fforesight.service.layoutparser.processor.model.table.Ruling;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.RedTextPosition;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.TextDirection;
+import com.knecon.fforesight.service.layoutparser.processor.services.classification.ClassificationService;
+import com.knecon.fforesight.service.layoutparser.processor.services.mapper.MarkdownMapper;
+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.graph.nodes.ImageType;
+import com.knecon.fforesight.service.layoutparser.processor.model.image.ClassifiedImage;
+import com.knecon.fforesight.service.layoutparser.processor.model.outline.OutlineExtractorService;
+import com.knecon.fforesight.service.layoutparser.processor.model.outline.OutlineObject;
+import com.knecon.fforesight.service.layoutparser.processor.model.outline.OutlineValidationService;
+import com.knecon.fforesight.service.layoutparser.processor.model.outline.TOCEnrichmentService;
+import com.knecon.fforesight.service.layoutparser.processor.model.outline.TableOfContents;
+import com.knecon.fforesight.service.layoutparser.processor.model.table.Cell;
+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.Word;
+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.adapter.VisualLayoutParsingAdapter;
+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.python_api.model.table.VisualLayoutParsingResponse;
+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.TextRulingsClassifier;
+import com.knecon.fforesight.service.layoutparser.processor.services.blockification.BlockificationPostprocessingService;
+import com.knecon.fforesight.service.layoutparser.processor.services.blockification.DocstrumBlockificationService;
+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.factory.DocumentGraphFactory;
+import com.knecon.fforesight.service.layoutparser.processor.services.graphics.Box;
+import com.knecon.fforesight.service.layoutparser.processor.services.graphics.GraphicExtractorService;
+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 com.knecon.fforesight.service.layoutparser.processor.utils.PageInformation;
+import com.knecon.fforesight.service.layoutparser.processor.utils.TextPositionOperations;
+
+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 {
+
+    ImageServiceResponseAdapter imageServiceResponseAdapter;
+    CvTableParsingAdapter cvTableParsingAdapter;
+    LayoutParsingStorageService layoutParsingStorageService;
+    SectionsBuilderService sectionsBuilderService;
+    SimplifiedSectionTextService simplifiedSectionTextService;
+    RulingCleaningService rulingCleaningService;
+    TableExtractionService tableExtractionService;
+    DocuMineBlockificationService docuMineBlockificationService;
+    RedactManagerBlockificationService redactManagerBlockificationService;
+    BlockificationPostprocessingService blockificationPostprocessingService;
+    DocstrumBlockificationService docstrumBlockificationService;
+    LayoutGridService layoutGridService;
+    ObservationRegistry observationRegistry;
+    VisualLayoutParsingAdapter visualLayoutParsingAdapter;
+    GraphicExtractorService graphicExtractorService;
+    OutlineExtractorService outlineExtractorService;
+    OutlineValidationService outlineValidationService;
+    TOCEnrichmentService tocEnrichmentService;
+    LayoutparserSettings settings;
+    ClassificationService classificationService;
+
+
+    public LayoutParsingFinishedEvent parseLayoutAndSaveFilesToStorage(LayoutParsingRequest layoutParsingRequest) throws IOException {
+
+        long start = System.currentTimeMillis();
+        log.info("Starting layout parsing for {}", layoutParsingRequest.identifier());
+
+        File originFile = layoutParsingStorageService.getOriginFile(layoutParsingRequest.originFileStorageId());
+        File viewerDocumentFile = layoutParsingStorageService.getViewerDocFile(layoutParsingRequest.viewerDocumentStorageId()).orElse(originFile);
+
+        VisualLayoutParsingResponse visualLayoutParsingResponse = layoutParsingRequest.visualLayoutParsingFileId()
+                .map(layoutParsingStorageService::getVisualLayoutParsingFile).orElse(new VisualLayoutParsingResponse());
+        ImageServiceResponse imageServiceResponse = layoutParsingRequest.imagesFileStorageId()
+                .map(layoutParsingStorageService::getImagesFile).orElse(new ImageServiceResponse());
+        TableServiceResponse tableServiceResponse = layoutParsingRequest.tablesFileStorageId()
+                .map(layoutParsingStorageService::getTablesFile).orElse(new TableServiceResponse());
+
+        ClassificationDocument classificationDocument = parseLayout(settings.getLayoutParsingTypeOverride() == null //
+                                                                            ? layoutParsingRequest.layoutParsingType() : settings.getLayoutParsingTypeOverride(),
+                                                                    originFile,
+                                                                    imageServiceResponse,
+                                                                    tableServiceResponse,
+                                                                    visualLayoutParsingResponse,
+                                                                    layoutParsingRequest.identifier());
+
+        log.info("Building document graph for {}", layoutParsingRequest.identifier());
+
+        Document documentGraph = observeBuildDocumentGraph(settings.getLayoutParsingTypeOverride() == null //
+                                                                   ? layoutParsingRequest.layoutParsingType() : settings.getLayoutParsingTypeOverride(), 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));
+        if (layoutParsingRequest.documentMarkdownFileStorageId().isPresent()) {
+            layoutParsingStorageService.storeMarkdownFile(layoutParsingRequest.documentMarkdownFileStorageId().get(), new MarkdownMapper().toMarkdownContent(documentGraph));
+        }
+        layoutParsingStorageService.storeSimplifiedText(layoutParsingRequest, simplifiedSectionTextService.toSimplifiedText(documentGraph));
+        layoutParsingStorageService.storeViewerDocument(layoutParsingRequest, viewerDocumentFile);
+
+        if (layoutParsingRequest.researchDocumentStorageId() != null) {
+            log.info("Building research document data for {}", layoutParsingRequest.identifier());
+            var researchDocumentData = TaasDocumentDataMapper.fromDocument(documentGraph);
+            layoutParsingStorageService.storeResearchDocumentData(layoutParsingRequest, researchDocumentData);
+        }
+
+        if (!viewerDocumentFile.equals(originFile)) {
+            assert !viewerDocumentFile.exists() || viewerDocumentFile.delete();
+        }
+        assert !originFile.exists() || 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();
+
+    }
+
+
+    private Document observeBuildDocumentGraph(LayoutParsingType layoutParsingType, ClassificationDocument classificationDocument) {
+
+        AtomicReference<Document> documentReference = new AtomicReference<>();
+
+        Observation.createNotStarted("LayoutParsingPipeline", observationRegistry)
+                .contextualName("build-document-graph")
+                .observe(() -> documentReference.set(DocumentGraphFactory.buildDocumentGraph(layoutParsingType, classificationDocument)));
+
+        return documentReference.get();
+    }
+
+
+    private String buildSemanticNodeCountMessage(int numberOfPages, Map<NodeType, Long> semanticNodeCounts) {
+
+        return 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,
+                                              VisualLayoutParsingResponse visualLayoutParsingResponse,
+                                              Map<String, 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);
+        Map<Integer, List<ClassifiedImage>> signatures = visualLayoutParsingAdapter.buildExtractedSignaturesPerPage(visualLayoutParsingResponse);
+
+        ClassificationDocument classificationDocument = new ClassificationDocument();
+
+        if (settings.isDebug() || identifier.containsKey("debug")) {
+            classificationDocument.getLayoutDebugLayer().setActive(true);
+        }
+
+        List<ClassificationPage> classificationPages = new ArrayList<>();
+
+        classificationDocument.setOutlineObjectTree(outlineExtractorService.getOutlineObjectTree(originDocument));
+
+        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);
+            stripper.getText(originDocument);
+            List<Word> words = stripper.getWords();
+
+//            rotateDirAdjExactly(words, pdPage); // works really well for many highly rotated documents (e.g. VV-331340.pdf), but it decreases the headline performance by 1.3%, so I am leaving it out for now
+
+            if (layoutParsingType.equals(LayoutParsingType.DOCUMINE_OLD)) {
+                var lines = TextPositionOperations.groupByLine(new HashSet<>(words));
+                classificationDocument.getLayoutDebugLayer().addLineVisualizationsFromNestedTextPosition(lines, pageNumber);
+                words = TextPositionOperations.sortWords(lines);
+            }
+            classificationDocument.getLayoutDebugLayer().addTextVisualizations(words, pageNumber);
+
+            PDRectangle pdr = pdPage.getMediaBox();
+
+            List<Ruling> rulings = stripper.getRulings();
+            classificationDocument.getLayoutDebugLayer().addRulingVisualization(rulings, pageNumber);
+            CleanRulings cleanRulings = rulingCleaningService.deduplicateAndStraightenRulings(pdfTableCells.get(pageNumber), rulings);
+
+            PageInformation pageInformation = PageInformation.fromPDPage(pageNumber, pdPage);
+            List<Cell> emptyTableCells = TableExtractionService.findCells(cleanRulings.getHorizontals(), cleanRulings.getVerticals(), pageInformation);
+            classificationDocument.getLayoutDebugLayer().addCellVisualizations(emptyTableCells, pageNumber);
+
+            TextRulingsClassifier.classifyUnderlinedAndStrikethroughText(words, cleanRulings);
+
+            List<Box> graphics = graphicExtractorService.extractPathElementGraphics(originDocument, pdPage, pageNumber, cleanRulings, stripper.getWords(), false);
+
+            pdfImages.computeIfAbsent(pageNumber, x -> new ArrayList<>())
+                    .addAll(graphics.stream()
+                                    .map(g -> new ClassifiedImage(new Rectangle2D.Double(g.x1, g.y1, g.width(), g.height()),
+                                                                  ImageType.GRAPHIC,
+                                                                  false,
+                                                                  stripper.getPageNumber(),
+                                                                  ""))
+                                    .toList());
+
+            ClassificationPage classificationPage = switch (layoutParsingType) {
+                case REDACT_MANAGER_OLD -> redactManagerBlockificationService.blockify(stripper.getWords(), cleanRulings, classificationDocument.getLayoutDebugLayer());
+                case DOCUMINE_OLD -> docuMineBlockificationService.blockify(words, cleanRulings);
+                case DOCUMINE, REDACT_MANAGER, REDACT_MANAGER_PARAGRAPH_DEBUG, REDACT_MANAGER_WITHOUT_DUPLICATE_PARAGRAPH ->
+                        docstrumBlockificationService.blockify(words, cleanRulings, true, classificationDocument.getLayoutDebugLayer(), layoutParsingType);
+                case CLARIFYND, CLARIFYND_PARAGRAPH_DEBUG ->
+                        docstrumBlockificationService.blockify(words, cleanRulings, false, classificationDocument.getLayoutDebugLayer(), layoutParsingType);
+            };
+
+            updateClassificationPage(pdPage, pdr, classificationPage, cleanRulings, pageNumber, pageInformation);
+
+            blockificationPostprocessingService.findHeadlinesFromOutline(classificationDocument, pageNumber, classificationPage, pageInformation);
+
+            classificationDocument.getLayoutDebugLayer().addMarkedContentVisualizations(stripper.getMarkedContents(), pageNumber);
+            // 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.containsKey(pageNumber)) {
+                classificationPage.setImages(pdfImages.get(pageNumber));
+                imageServiceResponseAdapter.findOcr(classificationPage);
+            }
+
+            if (signatures.containsKey(pageNumber)) {
+                if (classificationPage.getImages() == null || classificationPage.getImages().isEmpty()) {
+                    classificationPage.setImages(signatures.get(pageNumber));
+                } else {
+                    classificationPage.getImages().addAll(signatures.get(pageNumber));
+                }
+            }
+
+            tableExtractionService.extractTables(emptyTableCells, classificationPage);
+
+            buildPageStatistics(classificationPage);
+            increaseDocumentStatistics(classificationPage, classificationDocument);
+
+            classificationPages.add(classificationPage);
+        }
+
+        originDocument.close();
+
+        classificationService.classify(classificationDocument, layoutParsingType, identifier);
+
+        TableOfContents tableOfContents = outlineValidationService.createToC(classificationDocument);
+        classificationDocument.setTableOfContents(tableOfContents);
+
+        log.info("Building Sections for {}", identifier);
+
+        switch (layoutParsingType) {
+            case CLARIFYND_PARAGRAPH_DEBUG, REDACT_MANAGER_PARAGRAPH_DEBUG -> sectionsBuilderService.buildParagraphDebugSections(classificationDocument);
+            default -> tocEnrichmentService.assignSectionBlocksAndImages(classificationDocument);
+        }
+
+        return classificationDocument;
+    }
+
+
+    private static void updateClassificationPage(PDPage pdPage,
+                                                 PDRectangle pdr,
+                                                 ClassificationPage classificationPage,
+                                                 CleanRulings cleanRulings,
+                                                 int pageNumber,
+                                                 PageInformation pageInformation) {
+
+        int rotation = pdPage.getRotation();
+        boolean isLandscape = pdr.getWidth() > pdr.getHeight() && (rotation == 0 || rotation == 180) || pdr.getHeight() > pdr.getWidth() && (rotation == 90 || rotation == 270);
+        classificationPage.setCleanRulings(cleanRulings);
+        classificationPage.setRotation(rotation);
+        classificationPage.setLandscape(isLandscape);
+        classificationPage.setPageNumber(pageNumber);
+        classificationPage.setPageWidth((float) pageInformation.width());
+        classificationPage.setPageHeight((float) pageInformation.height());
+    }
+
+
+    private static void rotateDirAdjExactly(List<Word> words, PDPage pdPage) {
+
+        for (TextDirection dir : TextDirection.values()) {
+            double averageRotation = words.stream()
+                    .map(Word::getCharacters)
+                    .flatMap(Collection::stream)
+                    .map(Character::getTextPosition)
+                    .filter(pos -> pos.getDir().equals(dir))
+                    .mapToDouble(RedTextPosition::getExactDir).average().orElse(0);
+
+            if (averageRotation == 0) {
+                continue;
+            }
+
+            AffineTransform rotateInstance = AffineTransform.getRotateInstance(averageRotation, pdPage.getMediaBox().getWidth() / 2, pdPage.getMediaBox().getHeight() / 2);
+
+            for (Word word : words) {
+                if (!dir.equals(word.getDir())) {
+                    continue;
+                }
+                word.transform(rotateInstance);
+            }
+        }
+    }
+
+
+    private void addNumberOfPagesToTrace(int numberOfPages, long size) {
+
+        if (observationRegistry.getCurrentObservation() != null) {
+            observationRegistry.getCurrentObservation().highCardinalityKeyValue("numberOfPages", String.valueOf(numberOfPages));
+            observationRegistry.getCurrentObservation().highCardinalityKeyValue("fileSize", String.valueOf(size));
+        }
+    }
+
+
+    @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).getWords() == null) {
+                    continue;
+                }
+                for (Word word : ((TextPageBlock) textBlock).getWords()) {
+                    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/LayoutParsingService.java

@@ -1,87 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor;
-
-import static java.lang.String.format;
-
-import java.io.IOException;
-
-import org.apache.pdfbox.pdmodel.PDDocument;
-import org.springframework.stereotype.Service;
-
-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.processor.adapter.CvTableParsingAdapter;
-import com.knecon.fforesight.service.layoutparser.processor.adapter.ImageServiceResponseAdapter;
-import com.knecon.fforesight.service.layoutparser.processor.adapter.model.image.ImageServiceResponse;
-import com.knecon.fforesight.service.layoutparser.processor.adapter.model.table.TableServiceResponse;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.ClassificationDocument;
-import com.knecon.fforesight.service.layoutparser.processor.classification.service.ClassificationService;
-import com.knecon.fforesight.service.layoutparser.processor.classification.service.PdfParsingService;
-import com.knecon.fforesight.service.layoutparser.processor.classification.service.SectionsBuilderService;
-import com.knecon.fforesight.service.layoutparser.processor.factory.DocumentGraphFactory;
-import com.knecon.fforesight.service.layoutparser.processor.graph.nodes.Document;
-import com.knecon.fforesight.service.layoutparser.processor.mapper.DocumentDataMapper;
-
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-@Service
-@RequiredArgsConstructor
-public class LayoutParsingService {
-
-    private final ImageServiceResponseAdapter imageServiceResponseAdapter;
-    private final CvTableParsingAdapter cvTableParsingAdapter;
-    private final LayoutParsingStorageService layoutParsingStorageService;
-    private final PdfParsingService pdfParsingService;
-    private final ClassificationService classificationService;
-    private final SectionsBuilderService sectionsBuilderService;
-
-
-    public LayoutParsingFinishedEvent parseLayoutAndSaveFilesToStorage(LayoutParsingRequest layoutParsingRequest) throws IOException {
-
-        long start = System.currentTimeMillis();
-        PDDocument originDocument = layoutParsingStorageService.getOriginFile(layoutParsingRequest.originFileStorageId());
-
-        ImageServiceResponse imageServiceResponse = new ImageServiceResponse();
-        if (layoutParsingRequest.imagesFileStorageId().isPresent()) {
-            imageServiceResponse = layoutParsingStorageService.getImagesFile(layoutParsingRequest.pageFileStorageId());
-        }
-
-        TableServiceResponse tableServiceResponse = new TableServiceResponse();
-        if (layoutParsingRequest.tablesFileStorageId().isPresent()) {
-            tableServiceResponse = layoutParsingStorageService.getTablesFile(layoutParsingRequest.pageFileStorageId());
-        }
-
-        Document documentGraph = parseLayout(originDocument, imageServiceResponse, tableServiceResponse);
-        int numberOfPages = originDocument.getNumberOfPages();
-        originDocument.close();
-
-        layoutParsingStorageService.storeDocumentData(layoutParsingRequest, DocumentDataMapper.toDocumentData(documentGraph));
-
-        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();
-    }
-
-
-    public Document parseLayout(PDDocument originDocument, ImageServiceResponse imageServiceResponse, TableServiceResponse tableServiceResponse) {
-
-        ClassificationDocument classificationDocument = pdfParsingService.parseDocument(originDocument,
-                cvTableParsingAdapter.buildCvParsedTablesPerPage(tableServiceResponse),
-                imageServiceResponseAdapter.buildClassifiedImagesPerPage(imageServiceResponse));
-
-        classificationService.classifyDocument(classificationDocument);
-
-        sectionsBuilderService.buildSections(classificationDocument);
-
-        return DocumentGraphFactory.buildDocumentGraph(classificationDocument);
-    }
-
-}

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

@@ -1,10 +1,23 @@
 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.PDFTronViewerDocumentService;
+
+import io.micrometer.observation.ObservationRegistry;
+
 @Configuration
 @ComponentScan
 public class LayoutParsingServiceProcessorConfiguration {
 
+    @Bean
+    @Autowired
+    public PDFTronViewerDocumentService viewerDocumentService(ObservationRegistry registry) {
+
+        return new PDFTronViewerDocumentService(registry);
+    }
+
 }

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

@@ -1,30 +1,36 @@
 package com.knecon.fforesight.service.layoutparser.processor;
 
+import java.io.ByteArrayInputStream;
 import java.io.File;
-import java.io.FileOutputStream;
+import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
 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 java.util.concurrent.CompletableFuture;
 
-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.core.task.TaskExecutor;
 import org.springframework.stereotype.Service;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.iqser.red.storage.commons.service.StorageService;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.AtomicPositionBlockData;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.AtomicTextBlockData;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.DocumentData;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.DocumentTreeData;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.PageData;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentData;
+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.adapter.model.image.ImageServiceResponse;
-import com.knecon.fforesight.service.layoutparser.processor.adapter.model.table.TableServiceResponse;
+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.service.layoutparser.processor.python_api.model.table.VisualLayoutParsingResponse;
+import com.knecon.fforesight.service.viewerdoc.service.ViewerDocVersioningUtility;
 import com.knecon.fforesight.tenantcommons.TenantContext;
 
+import io.micrometer.observation.annotation.Observed;
 import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 
 @Slf4j
@@ -35,67 +41,104 @@ public class LayoutParsingStorageService {
     private final StorageService storageService;
     private final ObjectMapper objectMapper;
 
+    private final TaskExecutor taskExecutor;
 
-    public PDDocument getOriginFile(String storageId) throws IOException {
 
-        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-origin-file")
+    public File getOriginFile(String storageId) throws IOException {
+
+        File tempFile = createTempFile("document", ".pdf");
+        storageService.downloadTo(TenantContext.getTenantId(), storageId, tempFile);
+        return tempFile;
+    }
+
+
+    @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);
+
+        if (!ViewerDocVersioningUtility.isCurrentVersion(tempFile)) {
+            assert tempFile.delete();
+            return Optional.empty();
+        }
+
+        return Optional.of(tempFile);
+    }
+
+
+    @SneakyThrows
+    public ImageServiceResponse getImagesFile(String storageId) {
+
+        try (InputStream inputStream = getObject(storageId)) {
+
+            ImageServiceResponse imageServiceResponse = objectMapper.readValue(inputStream, ImageServiceResponse.class);
+            inputStream.close();
+            return imageServiceResponse;
         }
     }
 
 
-    public ImageServiceResponse getImagesFile(String storageId) throws IOException {
+    @SneakyThrows
+    public TableServiceResponse getTablesFile(String storageId) {
 
-        try (InputStream inputStream = storageService.getObject(TenantContext.getTenantId(), storageId).getInputStream()) {
+        try (var tableClassificationStream = getObject(storageId)) {
 
-            return objectMapper.readValue(inputStream, ImageServiceResponse.class);
+            TableServiceResponse tableServiceResponse = objectMapper.readValue(tableClassificationStream, TableServiceResponse.class);
+            tableClassificationStream.close();
+            return tableServiceResponse;
         }
     }
 
 
-    public TableServiceResponse getTablesFile(String storageId) throws IOException {
-
-        try (var tableClassificationStream = storageService.getObject(TenantContext.getTenantId(), storageId).getInputStream()) {
-
-            return objectMapper.readValue(tableClassificationStream, TableServiceResponse.class);
+@SneakyThrows
+    public VisualLayoutParsingResponse getVisualLayoutParsingFile(String storageId) {
 
+        try (InputStream inputStream = getObject(storageId)) {
+            return objectMapper.readValue(inputStream, VisualLayoutParsingResponse.class);
         }
     }
 
 
-    public void storeDocumentData(LayoutParsingRequest layoutParsingRequest, DocumentData documentData) throws IOException {
+    @SneakyThrows
+    @Observed(name = "LayoutParsingStorageService", contextualName = "store-document-data")
+    public void storeDocumentData(LayoutParsingRequest layoutParsingRequest, DocumentData documentData) {
 
-        storageService.storeJSONObject(TenantContext.getTenantId(), layoutParsingRequest.structureFileStorageId(), documentData.getDocumentTreeData());
-        storageService.storeJSONObject(TenantContext.getTenantId(), layoutParsingRequest.textBlockFileStorageId(), documentData.getAtomicTextBlocks());
-        storageService.storeJSONObject(TenantContext.getTenantId(), layoutParsingRequest.positionBlockFileStorageId(), documentData.getAtomicPositionBlocks());
-        storageService.storeJSONObject(TenantContext.getTenantId(), layoutParsingRequest.pageFileStorageId(), documentData.getPages());
+        Runnable storeDocumentStructureRunnable = () -> storageService.storeProtoObject(TenantContext.getTenantId(),
+                                                                                       layoutParsingRequest.structureFileStorageId(),
+                                                                                       documentData.getDocumentStructure());
 
+        CompletableFuture<Void> storeDocumentStructureFuture = CompletableFuture.runAsync(storeDocumentStructureRunnable, taskExecutor);
+
+        Runnable storeDocumentTextDataRunnable = () -> storageService.storeProtoObject(TenantContext.getTenantId(),
+                                                                                      layoutParsingRequest.textBlockFileStorageId(),
+                                                                                      documentData.getDocumentTextData());
+
+        CompletableFuture<Void> storeDocumentTextDataFuture = CompletableFuture.runAsync(storeDocumentTextDataRunnable, taskExecutor);
+
+        Runnable storeDocumentPositionsRunnable = () -> storageService.storeProtoObject(TenantContext.getTenantId(),
+                                                                                       layoutParsingRequest.positionBlockFileStorageId(),
+                                                                                       documentData.getDocumentPositions());
+
+        CompletableFuture<Void> storeDocumentPositionsFuture = CompletableFuture.runAsync(storeDocumentPositionsRunnable, taskExecutor);
+
+        Runnable storeDocumentPagesRunnable = () -> storageService.storeProtoObject(TenantContext.getTenantId(),
+                                                                                   layoutParsingRequest.pageFileStorageId(),
+                                                                                   documentData.getDocumentPages());
+
+        CompletableFuture<Void> storeDocumentPagesFuture = CompletableFuture.runAsync(storeDocumentPagesRunnable, taskExecutor);
+
+        CompletableFuture.allOf(storeDocumentStructureFuture, storeDocumentTextDataFuture, storeDocumentPositionsFuture, storeDocumentPagesFuture).join();
     }
 
 
-    public DocumentData readDocumentData(LayoutParsingRequest layoutParsingRequest) throws IOException {
+    public void storeResearchDocumentData(LayoutParsingRequest layoutParsingRequest, ResearchDocumentData researchDocumentData) {
 
-        PageData[] pageData = storageService.readJSONObject(TenantContext.getTenantId(), layoutParsingRequest.pageFileStorageId(), PageData[].class);
-        AtomicTextBlockData[] atomicTextBlockData = storageService.readJSONObject(TenantContext.getTenantId(),
-                layoutParsingRequest.textBlockFileStorageId(),
-                AtomicTextBlockData[].class);
-        AtomicPositionBlockData[] atomicPositionBlockData = storageService.readJSONObject(TenantContext.getTenantId(),
-                layoutParsingRequest.positionBlockFileStorageId(),
-                AtomicPositionBlockData[].class);
-        DocumentTreeData tableOfContentsData = storageService.readJSONObject(TenantContext.getTenantId(),
-                layoutParsingRequest.structureFileStorageId(),
-                DocumentTreeData.class);
-
-        return DocumentData.builder()
-                .documentTreeData(tableOfContentsData)
-                .atomicPositionBlocks(atomicPositionBlockData)
-                .atomicTextBlocks(atomicTextBlockData)
-                .pages(pageData)
-                .build();
+        storageService.storeJSONObject(TenantContext.getTenantId(), layoutParsingRequest.researchDocumentStorageId(), researchDocumentData);
     }
 
 
@@ -123,4 +166,43 @@ 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);
+        }
+    }
+
+
+    @SneakyThrows
+    @Observed(name = "LayoutParsingStorageService", contextualName = "store-markdown-file")
+    public void storeMarkdownFile(String markdownFileStorageId, String markdownContent) {
+
+        try (InputStream inputStream = new ByteArrayInputStream(markdownContent.getBytes(StandardCharsets.UTF_8))) {
+
+            storageService.storeObject(TenantContext.getTenantId(), markdownFileStorageId, inputStream);
+        }
+
+    }
+
 }

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

@@ -0,0 +1,21 @@
+package com.knecon.fforesight.service.layoutparser.processor;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingType;
+
+import lombok.AccessLevel;
+import lombok.Data;
+import lombok.experimental.FieldDefaults;
+
+@Data
+@Configuration
+@ConfigurationProperties("layoutparser")
+@FieldDefaults(level = AccessLevel.PRIVATE)
+public class LayoutparserSettings {
+
+    boolean debug;
+    LayoutParsingType layoutParsingTypeOverride;
+    String pdftronLicense;
+}

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

@@ -1,49 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.adapter;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.springframework.stereotype.Service;
-
-import com.knecon.fforesight.service.layoutparser.processor.adapter.model.table.TableCells;
-import com.knecon.fforesight.service.layoutparser.processor.adapter.model.table.TableServiceResponse;
-
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-@Service
-@RequiredArgsConstructor
-public class CvTableParsingAdapter {
-
-    public Map<Integer, List<TableCells>> buildCvParsedTablesPerPage(TableServiceResponse tableServiceResponse) {
-
-        Map<Integer, List<TableCells>> tableCells = new HashMap<>();
-        tableServiceResponse.getData()
-                .forEach(tableData -> tableCells.computeIfAbsent(tableData.getPageInfo().getNumber(), tableCell -> new ArrayList<>())
-                        .addAll(convertTableCells(tableData.getTableCells())));
-
-        return tableCells;
-    }
-
-
-    private Collection<TableCells> convertTableCells(List<TableCells> tableCells) {
-
-        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()));
-
-        return cvParsedTableCells;
-    }
-
-}

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

@@ -1,14 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.adapter.model.image;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import lombok.Data;
-
-@Data
-public class Classification {
-
-    private Map<String, Float> probabilities = new HashMap<>();
-    private String label;
-
-}

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

@@ -1,11 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.adapter.model.image;
-
-import lombok.Data;
-
-@Data
-public class FilterGeometry {
-
-    private ImageSize imageSize;
-    private ImageFormat imageFormat;
-
-}

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

@@ -1,12 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.adapter.model.image;
-
-import lombok.Data;
-
-@Data
-public class Filters {
-
-    private FilterGeometry geometry;
-    private Probability probability;
-    private boolean allPassed;
-
-}

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

@@ -1,11 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.adapter.model.image;
-
-import lombok.Data;
-
-@Data
-public class Geometry {
-
-    private float width;
-    private float height;
-
-}

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

@@ -1,12 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.adapter.model.image;
-
-import lombok.Data;
-
-@Data
-public class ImageFormat {
-
-    private float quotient;
-    private boolean tooTall;
-    private boolean tooWide;
-
-}

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

@@ -1,14 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.adapter.model.image;
-
-import lombok.Data;
-
-@Data
-public class ImageMetadata {
-
-    private Classification classification;
-    private Position position;
-    private Geometry geometry;
-    private Filters filters;
-    private boolean alpha;
-
-}

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

@@ -1,12 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.adapter.model.image;
-
-import lombok.Data;
-
-@Data
-public class ImageSize {
-
-    private float quotient;
-    private boolean tooLarge;
-    private boolean tooSmall;
-
-}

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

@@ -1,14 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.adapter.model.image;
-
-import lombok.Data;
-
-@Data
-public class Position {
-
-    private float x1;
-    private float x2;
-    private float y1;
-    private float y2;
-    private int pageNumber;
-
-}

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

@@ -1,10 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.adapter.model.image;
-
-import lombok.Data;
-
-@Data
-public class Probability {
-
-    private boolean unconfident;
-
-}

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

@@ -1,13 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.adapter.model.table;
-
-import lombok.Data;
-
-@Data
-public class PageInfo {
-
-    private int number;
-    private int rotation;
-    private float width;
-    private float height;
-
-}

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

@@ -1,14 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.adapter.model.table;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import lombok.Data;
-
-@Data
-public class TableData {
-
-    private PageInfo pageInfo;
-    private List<TableCells> tableCells = new ArrayList<>();
-
-}

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

@@ -1,80 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.model;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Rectangle;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.text.TextPageBlock;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public abstract class AbstractPageBlock {
-
-    @JsonIgnore
-    protected float minX;
-    @JsonIgnore
-    protected float maxX;
-    @JsonIgnore
-    protected float minY;
-    @JsonIgnore
-    protected float maxY;
-    @JsonIgnore
-    protected PageBlockType classification;
-    @JsonIgnore
-    protected int page;
-
-    @JsonIgnore
-    private Orientation orientation = Orientation.NONE;
-
-
-    public abstract String getText();
-
-
-    public boolean isHeadline() {
-
-        return this instanceof TextPageBlock && this.getClassification() != null && this.getClassification().isHeadline();
-    }
-
-
-    public boolean containsBlock(TextPageBlock other) {
-
-        return this.minX <= other.getPdfMinX() && this.maxX >= other.getPdfMaxX() && this.minY >= other.getPdfMinY() && this.maxY <= other.getPdfMaxY();
-    }
-
-
-    public boolean contains(AbstractPageBlock other) {
-
-        return this.minX <= other.minX && this.maxX >= other.maxX && this.minY >= other.minY && this.maxY <= other.maxY;
-    }
-
-
-    public boolean contains(Rectangle other) {
-
-        return page == other.getPage() && this.minX <= other.getTopLeft().getX() && this.maxX >= other.getTopLeft().getX() + other.getWidth() && this.minY <= other.getTopLeft()
-                .getY() && this.maxY >= other.getTopLeft().getY() + other.getHeight();
-    }
-
-
-    @JsonIgnore
-    public float getHeight() {
-
-        return maxY - minY;
-    }
-
-
-    @JsonIgnore
-    public float getWidth() {
-
-        return maxX - minX;
-    }
-
-
-    public boolean intersectsY(AbstractPageBlock atc) {
-
-        return this.minY <= atc.getMaxY() && this.maxY >= atc.getMinY();
-    }
-
-}

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

@@ -1,77 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.model;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-import lombok.Getter;
-
-@Getter
-public class FloatFrequencyCounter {
-
-    Map<Float, Integer> countPerValue = new HashMap<>();
-
-
-    public void add(float value) {
-
-        if (!countPerValue.containsKey(value)) {
-            countPerValue.put(value, 1);
-        } else {
-            countPerValue.put(value, countPerValue.get(value) + 1);
-        }
-    }
-
-
-    public void addAll(Map<Float, Integer> otherCounter) {
-
-        for (Map.Entry<Float, Integer> entry : otherCounter.entrySet()) {
-            if (countPerValue.containsKey(entry.getKey())) {
-                countPerValue.put(entry.getKey(), countPerValue.get(entry.getKey()) + entry.getValue());
-            } else {
-                countPerValue.put(entry.getKey(), entry.getValue());
-            }
-        }
-    }
-
-
-    public Float getMostPopular() {
-
-        Map.Entry<Float, Integer> mostPopular = null;
-        for (Map.Entry<Float, Integer> entry : countPerValue.entrySet()) {
-            if (mostPopular == null || entry.getValue() >= mostPopular.getValue()) {
-                mostPopular = entry;
-            }
-        }
-        return mostPopular != null ? mostPopular.getKey() : null;
-    }
-
-
-    public List<Float> getHighterThanMostPopular() {
-
-        Float mostPopular = getMostPopular();
-        List<Float> higher = new ArrayList<>();
-        for (Float value : countPerValue.keySet()) {
-            if (value > mostPopular) {
-                higher.add(value);
-            }
-        }
-
-        return higher.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());
-    }
-
-
-    public Float getHighest() {
-
-        Float highest = null;
-        for (Float value : countPerValue.keySet()) {
-            if (highest == null || value > highest) {
-                highest = value;
-            }
-        }
-        return highest;
-    }
-
-}

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

@@ -1,8 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.model;
-
-public enum Orientation {
-
-    NONE,
-    LEFT,
-    RIGHT
-}

layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/classification/model/image/ClassifiedImage.java

@@ -1,25 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.model.image;
-
-import java.awt.geom.Rectangle2D;
-
-import com.knecon.fforesight.service.layoutparser.processor.graph.nodes.ImageType;
-
-import lombok.Data;
-import lombok.NonNull;
-import lombok.RequiredArgsConstructor;
-
-@Data
-@RequiredArgsConstructor
-public class ClassifiedImage {
-
-    @NonNull
-    private Rectangle2D position;
-    @NonNull
-    private ImageType imageType;
-    private boolean isAppendedToSection;
-    @NonNull
-    private boolean hasTransparency;
-    @NonNull
-    private int page;
-
-}

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

@@ -1,15 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.model.table;
-
-import java.util.List;
-
-import lombok.Builder;
-import lombok.Data;
-
-@Data
-@Builder
-public class CleanRulings {
-
-    List<Ruling> horizontal;
-    List<Ruling> vertical;
-
-}

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

@@ -1,218 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.model.table;
-
-import java.awt.geom.Point2D;
-import java.awt.geom.Rectangle2D;
-import java.util.Comparator;
-import java.util.List;
-
-@SuppressWarnings("all")
-public class Rectangle extends Rectangle2D.Float {
-
-    protected static final float VERTICAL_COMPARISON_THRESHOLD = 0.4f;
-    /**
-     * Ill-defined comparator, from when Rectangle was Comparable.
-     * <p>
-     * see https://github.com/tabulapdf/tabula-java/issues/116
-     *
-     * @deprecated with no replacement
-     */
-    @Deprecated
-    public static final Comparator<Rectangle> ILL_DEFINED_ORDER = new Comparator<Rectangle>() {
-        @Override
-        public int compare(Rectangle o1, Rectangle o2) {
-
-            if (o1.equals(o2)) {
-                return 0;
-            }
-            if (o1.verticalOverlap(o2) > VERTICAL_COMPARISON_THRESHOLD) {
-                return o1.isLtrDominant() == -1 && o2.isLtrDominant() == -1 ? -java.lang.Double.compare(o1.getX(), o2.getX()) : java.lang.Double.compare(o1.getX(), o2.getX());
-            } else {
-                return java.lang.Float.compare(o1.getBottom(), o2.getBottom());
-            }
-        }
-    };
-
-
-    public Rectangle() {
-
-        super();
-    }
-
-
-    public Rectangle(float top, float left, float width, float height) {
-
-        super();
-        this.setRect(left, top, width, height);
-    }
-
-
-    /**
-     * @param rectangles
-     * @return minimum bounding box that contains all the rectangles
-     */
-    public static Rectangle boundingBoxOf(List<? extends Rectangle> rectangles) {
-
-        float minx = java.lang.Float.MAX_VALUE;
-        float miny = java.lang.Float.MAX_VALUE;
-        float maxx = java.lang.Float.MIN_VALUE;
-        float maxy = java.lang.Float.MIN_VALUE;
-
-        for (Rectangle r : rectangles) {
-            minx = (float) Math.min(r.getMinX(), minx);
-            miny = (float) Math.min(r.getMinY(), miny);
-            maxx = (float) Math.max(r.getMaxX(), maxx);
-            maxy = (float) Math.max(r.getMaxY(), maxy);
-        }
-        return new Rectangle(miny, minx, maxx - minx, maxy - miny);
-    }
-
-
-    public int compareTo(Rectangle other) {
-
-        return ILL_DEFINED_ORDER.compare(this, other);
-    }
-
-
-    // I'm bad at Java and need this for fancy sorting in
-    // technology.tabula.TextChunk.
-    public int isLtrDominant() {
-
-        return 0;
-    }
-
-
-    public float getArea() {
-
-        return this.width * this.height;
-    }
-
-
-    public float verticalOverlap(Rectangle other) {
-
-        return Math.max(0, Math.min(this.getBottom(), other.getBottom()) - Math.max(this.getTop(), other.getTop()));
-    }
-
-
-    public boolean verticallyOverlaps(Rectangle other) {
-
-        return verticalOverlap(other) > 0;
-    }
-
-
-    public float horizontalOverlap(Rectangle other) {
-
-        return Math.max(0, Math.min(this.getRight(), other.getRight()) - Math.max(this.getLeft(), other.getLeft()));
-    }
-
-
-    public boolean horizontallyOverlaps(Rectangle other) {
-
-        return horizontalOverlap(other) > 0;
-    }
-
-
-    public float verticalOverlapRatio(Rectangle other) {
-
-        float rv = 0, delta = Math.min(this.getBottom() - this.getTop(), other.getBottom() - other.getTop());
-
-        if (other.getTop() <= this.getTop() && this.getTop() <= other.getBottom() && other.getBottom() <= this.getBottom()) {
-            rv = (other.getBottom() - this.getTop()) / delta;
-        } else if (this.getTop() <= other.getTop() && other.getTop() <= this.getBottom() && this.getBottom() <= other.getBottom()) {
-            rv = (this.getBottom() - other.getTop()) / delta;
-        } else if (this.getTop() <= other.getTop() && other.getTop() <= other.getBottom() && other.getBottom() <= this.getBottom()) {
-            rv = (other.getBottom() - other.getTop()) / delta;
-        } else if (other.getTop() <= this.getTop() && this.getTop() <= this.getBottom() && this.getBottom() <= other.getBottom()) {
-            rv = (this.getBottom() - this.getTop()) / delta;
-        }
-
-        return rv;
-
-    }
-
-
-    public float overlapRatio(Rectangle other) {
-
-        double intersectionWidth = Math.max(0, Math.min(this.getRight(), other.getRight()) - Math.max(this.getLeft(), other.getLeft()));
-        double intersectionHeight = Math.max(0, Math.min(this.getBottom(), other.getBottom()) - Math.max(this.getTop(), other.getTop()));
-        double intersectionArea = Math.max(0, intersectionWidth * intersectionHeight);
-        double unionArea = this.getArea() + other.getArea() - intersectionArea;
-
-        return (float) (intersectionArea / unionArea);
-    }
-
-
-    public Rectangle merge(Rectangle other) {
-
-        this.setRect(this.createUnion(other));
-        return this;
-    }
-
-
-    public float getTop() {
-
-        return (float) this.getMinY();
-    }
-
-
-    public void setTop(float top) {
-
-        float deltaHeight = top - this.y;
-        this.setRect(this.x, top, this.width, this.height - deltaHeight);
-    }
-
-
-    public float getRight() {
-
-        return (float) this.getMaxX();
-    }
-
-
-    public void setRight(float right) {
-
-        this.setRect(this.x, this.y, right - this.x, this.height);
-    }
-
-
-    public float getLeft() {
-
-        return (float) this.getMinX();
-    }
-
-
-    public void setLeft(float left) {
-
-        float deltaWidth = left - this.x;
-        this.setRect(left, this.y, this.width - deltaWidth, this.height);
-    }
-
-
-    public float getBottom() {
-
-        return (float) this.getMaxY();
-    }
-
-
-    public void setBottom(float bottom) {
-
-        this.setRect(this.x, this.y, this.width, bottom - this.y);
-    }
-
-
-    public Point2D[] getPoints() {
-
-        return new Point2D[]{new Point2D.Float(this.getLeft(), this.getTop()), new Point2D.Float(this.getRight(), this.getTop()), new Point2D.Float(this.getRight(),
-                this.getBottom()), new Point2D.Float(this.getLeft(), this.getBottom())};
-    }
-
-
-    @Override
-    public String toString() {
-
-        StringBuilder sb = new StringBuilder();
-        String s = super.toString();
-        sb.append(s.substring(0, s.length() - 1));
-        sb.append(String.format(",bottom=%f,right=%f]", this.getBottom(), this.getRight()));
-        return sb.toString();
-    }
-
-}

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

@@ -1,437 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.model.table;
-
-import java.awt.geom.Line2D;
-import java.awt.geom.Point2D;
-import java.awt.geom.Rectangle2D;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.Formatter;
-import java.util.List;
-import java.util.Map;
-import java.util.TreeMap;
-
-import com.knecon.fforesight.service.layoutparser.processor.classification.utils.CohenSutherlandClipping;
-import com.knecon.fforesight.service.layoutparser.processor.classification.utils.DoubleComparisons;
-
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-@SuppressWarnings("all")
-public class Ruling extends Line2D.Float {
-
-    private static int PERPENDICULAR_PIXEL_EXPAND_AMOUNT = 2;
-
-
-    public Ruling(Point2D p1, Point2D p2) {
-
-        super(p1, p2);
-    }
-
-
-    public static List<Ruling> cropRulingsToArea(List<Ruling> rulings, Rectangle2D area) {
-
-        ArrayList<Ruling> rv = new ArrayList<>();
-        for (Ruling r : rulings) {
-            if (r.intersects(area)) {
-                rv.add(r.intersect(area));
-            }
-        }
-        return rv;
-    }
-
-
-    // log(n) implementation of find_intersections
-    // based on http://people.csail.mit.edu/indyk/6.838-old/handouts/lec2.pdf
-    public static Map<Point2D, Ruling[]> findIntersections(List<Ruling> horizontals, List<Ruling> verticals) {
-
-        class SortObject {
-
-            protected SOType type;
-            protected float position;
-            protected Ruling ruling;
-
-
-            public SortObject(SOType type, float position, Ruling ruling) {
-
-                this.type = type;
-                this.position = position;
-                this.ruling = ruling;
-            }
-
-        }
-
-        List<SortObject> sos = new ArrayList<>();
-
-        TreeMap<Ruling, Boolean> tree = new TreeMap<>(new Comparator<Ruling>() {
-            @Override
-            public int compare(Ruling o1, Ruling o2) {
-
-                return java.lang.Double.compare(o1.getTop(), o2.getTop());
-            }
-        });
-
-        TreeMap<Point2D, Ruling[]> rv = new TreeMap<>(new Comparator<Point2D>() {
-            @Override
-            public int compare(Point2D o1, Point2D o2) {
-
-                if (o1.getY() > o2.getY()) {
-                    return 1;
-                }
-                if (o1.getY() < o2.getY()) {
-                    return -1;
-                }
-                if (o1.getX() > o2.getX()) {
-                    return 1;
-                }
-                if (o1.getX() < o2.getX()) {
-                    return -1;
-                }
-                return 0;
-            }
-        });
-
-        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));
-        }
-
-        for (Ruling v : verticals) {
-            sos.add(new SortObject(SOType.VERTICAL, v.getLeft(), v));
-        }
-
-        Collections.sort(sos, new Comparator<SortObject>() {
-            @Override
-            public int compare(SortObject a, SortObject b) {
-
-                int rv;
-                if (DoubleComparisons.feq(a.position, b.position)) {
-                    if (a.type == SOType.VERTICAL && b.type == SOType.HLEFT) {
-                        rv = 1;
-                    } else if (a.type == SOType.VERTICAL && b.type == SOType.HRIGHT) {
-                        rv = -1;
-                    } else if (a.type == SOType.HLEFT && b.type == SOType.VERTICAL) {
-                        rv = -1;
-                    } else if (a.type == SOType.HRIGHT && b.type == SOType.VERTICAL) {
-                        rv = 1;
-                    } else {
-                        rv = java.lang.Double.compare(a.position, b.position);
-                    }
-                } else {
-                    return java.lang.Double.compare(a.position, b.position);
-                }
-                return rv;
-            }
-        });
-
-        for (SortObject so : sos) {
-            switch (so.type) {
-                case VERTICAL:
-                    for (Map.Entry<Ruling, Boolean> h : tree.entrySet()) {
-                        try {
-                            Point2D i = h.getKey().intersectionPoint(so.ruling);
-                            if (i == null) {
-                                continue;
-                            }
-                            rv.put(i, new Ruling[]{h.getKey().expand(PERPENDICULAR_PIXEL_EXPAND_AMOUNT), so.ruling.expand(PERPENDICULAR_PIXEL_EXPAND_AMOUNT)});
-                        } catch (UnsupportedOperationException e) {
-                            log.info("Some line are oblique, ignoring...");
-                            continue;
-                        }
-                    }
-                    break;
-                case HRIGHT:
-                    tree.remove(so.ruling);
-                    break;
-                case HLEFT:
-                    tree.put(so.ruling, true);
-                    break;
-            }
-        }
-
-        return rv;
-
-    }
-
-
-    public boolean vertical() {
-
-        return this.length() > 0 && DoubleComparisons.feq(this.x1, this.x2); //diff < ORIENTATION_CHECK_THRESHOLD;
-    }
-
-
-    public boolean horizontal() {
-
-        return this.length() > 0 && DoubleComparisons.feq(this.y1, this.y2); //diff < ORIENTATION_CHECK_THRESHOLD;
-    }
-
-    // attributes that make sense only for non-oblique lines
-    // these are used to have a single collapse method (in page, currently)
-
-
-    public boolean oblique() {
-
-        return !(this.vertical() || this.horizontal());
-    }
-
-
-    public float getPosition() {
-
-        if (this.oblique()) {
-            throw new UnsupportedOperationException();
-        }
-        return this.vertical() ? this.getLeft() : this.getTop();
-    }
-
-
-    public float getStart() {
-
-        if (this.oblique()) {
-            throw new UnsupportedOperationException();
-        }
-        return this.vertical() ? this.getTop() : this.getLeft();
-    }
-
-
-    public void setStart(float v) {
-
-        if (this.oblique()) {
-            throw new UnsupportedOperationException();
-        }
-        if (this.vertical()) {
-            this.setTop(v);
-        } else {
-            this.setLeft(v);
-        }
-    }
-
-
-    public float getEnd() {
-
-        if (this.oblique()) {
-            throw new UnsupportedOperationException();
-        }
-        return this.vertical() ? this.getBottom() : this.getRight();
-    }
-
-
-    public void setEnd(float v) {
-
-        if (this.oblique()) {
-            throw new UnsupportedOperationException();
-        }
-        if (this.vertical()) {
-            this.setBottom(v);
-        } else {
-            this.setRight(v);
-        }
-    }
-
-
-    public void setStartEnd(float start, float end) {
-
-        if (this.oblique()) {
-            throw new UnsupportedOperationException();
-        }
-        if (this.vertical()) {
-            this.setTop(start);
-            this.setBottom(end);
-        } else {
-            this.setLeft(start);
-            this.setRight(end);
-        }
-    }
-
-
-    public boolean perpendicularTo(Ruling other) {
-
-        return this.vertical() == other.horizontal();
-    }
-
-
-    public boolean nearlyIntersects(Ruling another, int colinearOrParallelExpandAmount) {
-
-        if (this.intersectsLine(another)) {
-            return true;
-        }
-
-        boolean rv = false;
-
-        if (this.perpendicularTo(another)) {
-            rv = this.expand(PERPENDICULAR_PIXEL_EXPAND_AMOUNT).intersectsLine(another);
-        } else {
-            rv = this.expand(colinearOrParallelExpandAmount).intersectsLine(another.expand(colinearOrParallelExpandAmount));
-        }
-
-        return rv;
-    }
-
-
-    public double length() {
-
-        return Math.sqrt(Math.pow(this.x1 - this.x2, 2) + Math.pow(this.y1 - this.y2, 2));
-    }
-
-
-    public Ruling intersect(Rectangle2D clip) {
-
-        Float clipee = (Float) this.clone();
-        boolean clipped = new CohenSutherlandClipping(clip).clip(clipee);
-
-        if (clipped) {
-            return new Ruling(clipee.getP1(), clipee.getP2());
-        } else {
-            return this;
-        }
-    }
-
-
-    public Ruling expand(float amount) {
-
-        Ruling r = (Ruling) this.clone();
-        try {
-            r.setStart(this.getStart() - amount);
-            r.setEnd(this.getEnd() + amount);
-        } catch (UnsupportedOperationException e) {
-            log.warn("Could not expand ruling!");
-        }
-        return r;
-    }
-
-
-    public Point2D intersectionPoint(Ruling other) {
-
-        Ruling this_l = this.expand(PERPENDICULAR_PIXEL_EXPAND_AMOUNT);
-        Ruling other_l = other.expand(PERPENDICULAR_PIXEL_EXPAND_AMOUNT);
-        Ruling horizontal, vertical;
-
-        if (!this_l.intersectsLine(other_l)) {
-            return null;
-        }
-
-        if (this_l.horizontal() && other_l.vertical()) {
-            horizontal = this_l;
-            vertical = other_l;
-        } else if (this_l.vertical() && other_l.horizontal()) {
-            vertical = this_l;
-            horizontal = other_l;
-        } else {
-            log.warn("lines must be orthogonal, vertical and horizontal");
-            return null;
-        }
-        return new Point2D.Float(vertical.getLeft(), horizontal.getTop());
-    }
-
-
-    @Override
-    public boolean equals(Object other) {
-
-        if (this == other) {
-            return true;
-        }
-
-        if (!(other instanceof Ruling)) {
-            return false;
-        }
-
-        Ruling o = (Ruling) other;
-        return this.getP1().equals(o.getP1()) && this.getP2().equals(o.getP2());
-    }
-
-
-    @Override
-    public int hashCode() {
-
-        return super.hashCode();
-    }
-
-
-    public float getTop() {
-
-        return this.y1;
-    }
-
-
-    public void setTop(float v) {
-
-        setLine(this.getLeft(), v, this.getRight(), this.getBottom());
-    }
-
-
-    public float getLeft() {
-
-        return this.x1;
-    }
-
-
-    public void setLeft(float v) {
-
-        setLine(v, this.getTop(), this.getRight(), this.getBottom());
-    }
-
-
-    public float getBottom() {
-
-        return this.y2;
-    }
-
-
-    public void setBottom(float v) {
-
-        setLine(this.getLeft(), this.getTop(), this.getRight(), v);
-    }
-
-
-    public float getRight() {
-
-        return this.x2;
-    }
-
-
-    public void setRight(float v) {
-
-        setLine(this.getLeft(), this.getTop(), v, this.getBottom());
-    }
-
-
-    public float getWidth() {
-
-        return this.getRight() - this.getLeft();
-    }
-
-
-    public float getHeight() {
-
-        return this.getBottom() - this.getTop();
-    }
-
-
-    public double getAngle() {
-
-        double angle = Math.toDegrees(Math.atan2(this.getP2().getY() - this.getP1().getY(), this.getP2().getX() - this.getP1().getX()));
-
-        if (angle < 0) {
-            angle += 360;
-        }
-        return angle;
-    }
-
-
-    @Override
-    public String toString() {
-
-        StringBuilder sb = new StringBuilder();
-        Formatter formatter = new Formatter(sb);
-        String rv = formatter.format("%s[minX=%f minY=%f maxX=%f maxY=%f]", this.getClass().toString(), this.x1, this.y1, this.x2, this.y2).toString();
-        formatter.close();
-        return rv;
-    }
-
-
-    private enum SOType {
-        VERTICAL,
-        HRIGHT,
-        HLEFT
-    }
-
-}

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

@@ -1,100 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.model.text;
-
-import org.apache.pdfbox.text.TextPosition;
-import org.springframework.beans.BeanUtils;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import lombok.SneakyThrows;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-public class RedTextPosition {
-
-    private String textMatrix;
-    private float[] position;
-
-    @JsonIgnore
-    private int rotation;
-
-    @JsonIgnore
-    private float pageHeight;
-
-    @JsonIgnore
-    private float pageWidth;
-
-    private String unicode;
-
-    @JsonIgnore
-    private float dir;
-
-    // not used in reanalysis
-    @JsonIgnore
-    private float widthOfSpace;
-
-    // not used in reanalysis
-    @JsonIgnore
-    private float fontSizeInPt;
-
-    // not used in reanalysis
-    @JsonIgnore
-    private String fontName;
-
-
-    @SneakyThrows
-    public static RedTextPosition fromTextPosition(TextPosition textPosition) {
-
-        var pos = new RedTextPosition();
-        BeanUtils.copyProperties(textPosition, pos);
-        pos.setFontName(textPosition.getFont().getName());
-
-        pos.setFontSizeInPt(textPosition.getFontSizeInPt());
-
-        pos.setTextMatrix(textPosition.getTextMatrix().toString());
-
-        var position = new float[4];
-
-        position[0] = textPosition.getXDirAdj();
-        position[1] = textPosition.getYDirAdj();
-        position[2] = textPosition.getWidthDirAdj();
-        position[3] = textPosition.getHeightDir();
-
-        pos.setPosition(position);
-        return pos;
-    }
-
-
-    @JsonIgnore
-    public float getXDirAdj() {
-
-        return position[0];
-    }
-
-
-    @JsonIgnore
-    public float getYDirAdj() {
-
-        return position[1];
-    }
-
-
-    @JsonIgnore
-    public float getWidthDirAdj() {
-
-        return position[2];
-    }
-
-
-    @JsonIgnore
-    public float getHeightDir() {
-
-        return position[3];
-    }
-
-}

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

@@ -1,48 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.model.text;
-
-import java.util.ArrayList;
-import java.util.List;
-import com.knecon.fforesight.service.layoutparser.processor.classification.utils.TextNormalizationUtilities;
-
-import lombok.Getter;
-
-@Getter
-public class SearchableText {
-
-    private final List<TextPositionSequence> sequences = new ArrayList<>();
-
-
-    public void add(TextPositionSequence textPositionSequence) {
-
-        sequences.add(textPositionSequence);
-    }
-
-
-    public void addAll(List<TextPositionSequence> textPositionSequences) {
-
-        sequences.addAll(textPositionSequences);
-    }
-
-
-    @Override
-    public String toString() {
-
-        return buildString(sequences);
-    }
-
-
-    public static String buildString(List<TextPositionSequence> sequences) {
-
-        StringBuilder sb = new StringBuilder();
-        for (TextPositionSequence word : sequences) {
-            sb.append(word);
-            sb.append(' ');
-        }
-        String text = sb.toString();
-        text = TextNormalizationUtilities.removeHyphenLineBreaks(text);
-        text = TextNormalizationUtilities.removeLineBreaks(text);
-        text = TextNormalizationUtilities.removeRepeatingWhitespaces(text);
-        return text;
-    }
-
-}

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

@@ -1,17 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.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/classification/model/text/SimplifiedText.java

@@ -1,20 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.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/classification/model/text/TextPageBlock.java

@@ -1,302 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.model.text;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.AbstractPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.PageBlockType;
-import com.knecon.fforesight.service.layoutparser.processor.classification.utils.TextNormalizationUtilities;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@AllArgsConstructor
-@Builder
-@Data
-@NoArgsConstructor
-public class TextPageBlock extends AbstractPageBlock {
-
-    @Builder.Default
-    private List<TextPositionSequence> sequences = new ArrayList<>();
-
-    @JsonIgnore
-    private int rotation;
-
-    @JsonIgnore
-    private String mostPopularWordFont;
-
-    @JsonIgnore
-    private String mostPopularWordStyle;
-
-    @JsonIgnore
-    private float mostPopularWordFontSize;
-
-    @JsonIgnore
-    private float mostPopularWordHeight;
-
-    @JsonIgnore
-    private float mostPopularWordSpaceWidth;
-
-    @JsonIgnore
-    private float highestFontSize;
-
-    @JsonIgnore
-    private PageBlockType classification;
-
-
-    @JsonIgnore
-    public TextDirection getDir() {
-
-        return sequences.get(0).getDir();
-    }
-
-
-    @JsonIgnore
-    private float getPageHeight() {
-
-        return sequences.get(0).getPageHeight();
-    }
-
-
-    @JsonIgnore
-    private float getPageWidth() {
-
-        return sequences.get(0).getPageWidth();
-    }
-
-
-    /**
-     * Returns the minX value in pdf coordinate system.
-     * Note: This needs to use Pdf Coordinate System where {0,0} rotated with the page rotation.
-     * 0 -> LowerLeft
-     * 90 -> UpperLeft
-     * 180 -> UpperRight
-     * 270 -> LowerRight
-     *
-     * @return the minX value in pdf coordinate system
-     */
-    @JsonIgnore
-    public float getPdfMinX() {
-
-        if (getDir().getDegrees() == 90) {
-            return minY;
-        } else if (getDir().getDegrees() == 180) {
-            return getPageWidth() - maxX;
-
-        } else if (getDir().getDegrees() == 270) {
-
-            return getPageWidth() - maxY;
-        } else {
-            return minX;
-        }
-    }
-
-
-    /**
-     * Returns the maxX value in pdf coordinate system.
-     * Note: This needs to use Pdf Coordinate System where {0,0} rotated with the page rotation.
-     * 0 -> LowerLeft
-     * 90 -> UpperLeft
-     * 180 -> UpperRight
-     * 270 -> LowerRight
-     *
-     * @return the maxX value in pdf coordinate system
-     */
-    @JsonIgnore
-    public float getPdfMaxX() {
-
-        if (getDir().getDegrees() == 90) {
-            return maxY;
-        } else if (getDir().getDegrees() == 180) {
-            return getPageWidth() - minX;
-        } else if (getDir().getDegrees() == 270) {
-            return getPageWidth() - minY;
-
-        } else {
-            return maxX;
-        }
-    }
-
-
-    /**
-     * Returns the minY value in pdf coordinate system.
-     * Note: This needs to use Pdf Coordinate System where {0,0} rotated with the page rotation.
-     * 0 -> LowerLeft
-     * 90 -> UpperLeft
-     * 180 -> UpperRight
-     * 270 -> LowerRight
-     *
-     * @return the minY value in pdf coordinate system
-     */
-    @JsonIgnore
-    public float getPdfMinY() {
-
-        if (getDir().getDegrees() == 90) {
-            return minX;
-        } else if (getDir().getDegrees() == 180) {
-            return maxY;
-
-        } else if (getDir().getDegrees() == 270) {
-            return getPageHeight() - maxX;
-
-        } else {
-            return getPageHeight() - maxY;
-        }
-    }
-
-
-    /**
-     * Returns the maxY value in pdf coordinate system.
-     * Note: This needs to use Pdf Coordinate System where {0,0} rotated with the page rotation.
-     * 0 -> LowerLeft
-     * 90 -> UpperLeft
-     * 180 -> UpperRight
-     * 270 -> LowerRight
-     *
-     * @return the maxY value in pdf coordinate system
-     */
-    @JsonIgnore
-    public float getPdfMaxY() {
-
-        if (getDir().getDegrees() == 90) {
-            return maxX;
-        } else if (getDir().getDegrees() == 180) {
-
-            return minY;
-        } else if (getDir().getDegrees() == 270) {
-            return getPageHeight() - minX;
-        } else {
-            return getPageHeight() - minY;
-        }
-    }
-
-
-    public TextPageBlock(float minX, float maxX, float minY, float maxY, List<TextPositionSequence> sequences, int rotation) {
-
-        this.minX = minX;
-        this.maxX = maxX;
-        this.minY = minY;
-        this.maxY = maxY;
-        this.sequences = sequences;
-        this.rotation = rotation;
-    }
-
-
-    public TextPageBlock union(TextPositionSequence r) {
-
-        TextPageBlock union = this.copy();
-        union.add(r);
-        return union;
-    }
-
-
-    public TextPageBlock union(TextPageBlock r) {
-
-        TextPageBlock union = this.copy();
-        union.add(r);
-        return union;
-    }
-
-
-    public void add(TextPageBlock r) {
-
-        if (r.getMinX() < minX) {
-            minX = r.getMinX();
-        }
-        if (r.getMaxX() > maxX) {
-            maxX = r.getMaxX();
-        }
-        if (r.getMinY() < minY) {
-            minY = r.getMinY();
-        }
-        if (r.getMaxY() > maxY) {
-            maxY = r.getMaxY();
-        }
-        sequences.addAll(r.getSequences());
-    }
-
-
-    public void add(TextPositionSequence r) {
-
-        if (r.getMinXDirAdj() < minX) {
-            minX = r.getMinXDirAdj();
-        }
-        if (r.getMaxXDirAdj() > maxX) {
-            maxX = r.getMaxXDirAdj();
-        }
-        if (r.getMinYDirAdj() < minY) {
-            minY = r.getMinYDirAdj();
-        }
-        if (r.getMaxYDirAdj() > maxY) {
-            maxY = r.getMaxYDirAdj();
-        }
-    }
-
-
-    public TextPageBlock copy() {
-
-        return new TextPageBlock(minX, maxX, minY, maxY, sequences, rotation);
-    }
-
-
-    public void resize(float x1, float y1, float width, float height) {
-
-        set(x1, y1, x1 + width, y1 + height);
-    }
-
-
-    public void set(float x1, float y1, float x2, float y2) {
-
-        this.minX = Math.min(x1, x2);
-        this.maxX = Math.max(x1, x2);
-        this.minY = Math.min(y1, y2);
-        this.maxY = Math.max(y1, y2);
-    }
-
-
-    @Override
-    public String toString() {
-
-        StringBuilder builder = new StringBuilder();
-
-        for (int i = 0; i < sequences.size(); i++) {
-            String sequenceAsString = sequences.get(i).toString();
-            // Fix for missing Whitespace. This is recognized in getSequences method. See PDFTextStripper Line 1730.
-            if (i != 0 && sequences.get(i - 1).charAt(sequences.get(i - 1).length() - 1) != ' ' && sequenceAsString.charAt(0) != ' ') {
-                builder.append(' ');
-            }
-            builder.append(sequenceAsString);
-        }
-
-        return builder.toString();
-
-    }
-
-
-    @Override
-    @JsonIgnore
-    public String getText() {
-
-        StringBuilder sb = new StringBuilder();
-
-        TextPositionSequence previous = null;
-        for (TextPositionSequence word : sequences) {
-            if (previous != null) {
-                if (Math.abs(previous.getMaxYDirAdj() - word.getMaxYDirAdj()) > word.getTextHeight()) {
-                    sb.append('\n');
-                } else {
-                    sb.append(' ');
-                }
-            }
-            sb.append(word.toString());
-            previous = word;
-        }
-
-        return TextNormalizationUtilities.removeHyphenLineBreaks(sb.toString());
-
-    }
-
-}

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

@@ -1,301 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.model.text;
-
-import java.awt.geom.AffineTransform;
-import java.awt.geom.Point2D;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import org.apache.pdfbox.text.TextPosition;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-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;
-
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import lombok.SneakyThrows;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@JsonIgnoreProperties({"empty"})
-public class TextPositionSequence implements CharSequence {
-
-    public static final int HEIGHT_PADDING = 2;
-    private int page;
-    private List<RedTextPosition> textPositions = new ArrayList<>();
-
-    private TextDirection dir;
-    private int rotation;
-    private float pageHeight;
-    private float pageWidth;
-
-
-    public TextPositionSequence(int page) {
-
-        this.page = page;
-    }
-
-
-    public TextPositionSequence(List<TextPosition> textPositions, int page) {
-
-        this.textPositions = textPositions.stream().map(RedTextPosition::fromTextPosition).collect(Collectors.toList());
-        this.page = page;
-        this.dir = TextDirection.fromDegrees(textPositions.get(0).getDir());
-        this.rotation = textPositions.get(0).getRotation();
-        this.pageHeight = textPositions.get(0).getPageHeight();
-        this.pageWidth = textPositions.get(0).getPageWidth();
-    }
-
-
-    @Override
-    public int length() {
-
-        return textPositions.size();
-    }
-
-
-    @Override
-    public char charAt(int index) {
-
-        RedTextPosition textPosition = textPositionAt(index);
-        String text = textPosition.getUnicode();
-        return text.charAt(0);
-    }
-
-
-    public char charAt(int index, boolean caseInSensitive) {
-
-        RedTextPosition textPosition = textPositionAt(index);
-        String text = textPosition.getUnicode();
-        return caseInSensitive ? text.toLowerCase().charAt(0) : text.charAt(0);
-    }
-
-
-    @Override
-    public TextPositionSequence subSequence(int start, int end) {
-
-        var textPositionSequence = new TextPositionSequence();
-        textPositionSequence.textPositions = textPositions.subList(start, end);
-        textPositionSequence.page = page;
-        textPositionSequence.dir = dir;
-        textPositionSequence.rotation = rotation;
-        textPositionSequence.pageHeight = pageHeight;
-        textPositionSequence.pageWidth = pageWidth;
-
-        return textPositionSequence;
-    }
-
-
-    @Override
-    public String toString() {
-
-        StringBuilder builder = new StringBuilder(length());
-        for (int i = 0; i < length(); i++) {
-            builder.append(charAt(i));
-        }
-        return builder.toString();
-    }
-
-
-    public RedTextPosition textPositionAt(int index) {
-
-        return textPositions.get(index);
-    }
-
-
-    public void add(TextPositionSequence textPositionSequence, RedTextPosition textPosition) {
-
-        this.textPositions.add(textPosition);
-        this.page = textPositionSequence.getPage();
-        this.dir = textPositionSequence.getDir();
-        this.rotation = textPositionSequence.getRotation();
-        this.pageHeight = textPositionSequence.getPageHeight();
-        this.pageWidth = textPositionSequence.getPageWidth();
-    }
-
-
-    public void add(TextPosition textPosition) {
-
-        this.textPositions.add(RedTextPosition.fromTextPosition(textPosition));
-
-        this.dir = TextDirection.fromDegrees(textPositions.get(0).getDir());
-        this.rotation = textPositions.get(0).getRotation();
-        this.pageHeight = textPositions.get(0).getPageHeight();
-        this.pageWidth = textPositions.get(0).getPageWidth();
-
-    }
-
-
-    /**
-     * This value is adjusted so that 0,0 is upper left and it is adjusted based on the text direction.
-     * This method ignores the page rotation but takes the text rotation and adjusts the coordinates to awt.
-     *
-     * @return the text direction adjusted minX value
-     */
-    @JsonIgnore
-    public float getMinXDirAdj() {
-
-        return textPositions.get(0).getXDirAdj();
-
-    }
-
-
-    /**
-     * This value is adjusted so that 0,0 is upper left and it is adjusted based on the text direction.
-     * This method ignores the page rotation but takes the text rotation and adjusts the coordinates to awt.
-     *
-     * @return the text direction adjusted maxX value
-     */
-    @JsonIgnore
-    public float getMaxXDirAdj() {
-
-        return textPositions.get(textPositions.size() - 1).getXDirAdj() + textPositions.get(textPositions.size() - 1).getWidthDirAdj() + HEIGHT_PADDING;
-
-    }
-
-
-    /**
-     * This value is adjusted so that 0,0 is upper left and it is adjusted based on the text direction.
-     * This method ignores the page rotation but takes the text rotation and adjusts the coordinates to awt.
-     *
-     * @return the text direction adjusted minY value. The upper border of the bounding box of the word.
-     */
-    @JsonIgnore
-    public float getMinYDirAdj() {
-
-        return textPositions.get(0).getYDirAdj() - getTextHeight();
-
-    }
-
-
-    /**
-     * This value is adjusted so that 0,0 is upper left and it is adjusted based on the text direction.
-     * This method ignores the page rotation but takes the text rotation and adjusts the coordinates to awt.
-     *
-     * @return the text direction adjusted maxY value. The lower border of the bounding box of the word.
-     */
-    @JsonIgnore
-    public float getMaxYDirAdj() {
-
-        return textPositions.get(0).getYDirAdj();
-
-    }
-
-
-    @JsonIgnore
-    public float getTextHeight() {
-
-        return textPositions.get(0).getHeightDir() + HEIGHT_PADDING;
-    }
-
-
-    @JsonIgnore
-    public float getHeight() {
-
-        return getMaxYDirAdj() - getMinYDirAdj();
-    }
-
-
-    @JsonIgnore
-    public float getWidth() {
-
-        return getMaxXDirAdj() - getMinXDirAdj();
-    }
-
-
-    @JsonIgnore
-    public String getFont() {
-
-        return textPositions.get(0).getFontName().toLowerCase().replaceAll(",bold", "").replaceAll(",italic", "");
-    }
-
-
-    @JsonIgnore
-    public String getFontStyle() {
-
-        String lowercaseFontName = textPositions.get(0).getFontName().toLowerCase();
-
-        if (lowercaseFontName.contains("bold") && lowercaseFontName.contains("italic")) {
-            return "bold, italic";
-        } else if (lowercaseFontName.contains("bold")) {
-            return "bold";
-        } else if (lowercaseFontName.contains("italic")) {
-            return "italic";
-        } else {
-            return "standard";
-        }
-
-    }
-
-
-    @JsonIgnore
-    public float getFontSize() {
-
-        return textPositions.get(0).getFontSizeInPt();
-    }
-
-
-    @JsonIgnore
-    public float getSpaceWidth() {
-
-        return textPositions.get(0).getWidthOfSpace();
-    }
-
-
-    /**
-     * This returns the bounding box of the word in Pdf Coordinate System where {0,0} rotated with the page rotation.
-     * 0 -> LowerLeft
-     * 90 -> UpperLeft
-     * 180 -> UpperRight
-     * 270 -> LowerRight
-     *
-     * @return bounding box of the word in Pdf Coordinate System
-     */
-    @JsonIgnore
-    @SneakyThrows
-    public Rectangle getRectangle() {
-
-        log.debug("Page: '{}', Word: '{}', Rotation: '{}', textRotation {}", page, this, rotation, dir);
-
-        float textHeight = getTextHeight();
-
-        RedTextPosition firstTextPos = textPositions.get(0);
-        RedTextPosition lastTextPos = textPositions.get(textPositions.size() - 1);
-
-        Point2D bottomLeft = new Point2D.Double(firstTextPos.getXDirAdj(), firstTextPos.getYDirAdj() - HEIGHT_PADDING);
-        Point2D topRight = new Point2D.Double(lastTextPos.getXDirAdj() + lastTextPos.getWidthDirAdj(), lastTextPos.getYDirAdj() + textHeight + HEIGHT_PADDING);
-
-        AffineTransform transform = new AffineTransform();
-        if (dir == TextDirection.ZERO || dir == TextDirection.HALF_CIRCLE) {
-            transform.rotate(dir.getRadians(), pageWidth / 2f, pageHeight / 2f);
-            transform.translate(0f, pageHeight + textHeight);
-            transform.scale(1., -1.);
-        } else if (dir == TextDirection.QUARTER_CIRCLE) {
-            transform.rotate(dir.getRadians(), pageWidth / 2f, pageWidth / 2f);
-            transform.translate(0f, pageWidth + textHeight);
-            transform.scale(1., -1.);
-        } else {
-            transform.rotate(dir.getRadians(), pageHeight / 2f, pageHeight / 2f);
-            transform.translate(0f, pageWidth + textHeight);
-            transform.scale(1., -1.);
-        }
-
-        bottomLeft = transform.transform(bottomLeft, null);
-        topRight = transform.transform(topRight, null);
-
-        return new Rectangle( //
-                new Point((float) bottomLeft.getX(), (float) bottomLeft.getY()),
-                (float) (topRight.getX() - bottomLeft.getX()),
-                (float) (topRight.getY() - bottomLeft.getY()),
-                page);
-    }
-
-}

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

@@ -1,278 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.service;
-
-import static java.util.stream.Collectors.toSet;
-
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.List;
-
-import org.springframework.stereotype.Service;
-
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.AbstractPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.ClassificationPage;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.FloatFrequencyCounter;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.Orientation;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.table.Ruling;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.text.StringFrequencyCounter;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.text.TextPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.text.TextPositionSequence;
-import com.knecon.fforesight.service.layoutparser.processor.classification.utils.RulingTextDirAdjustUtil;
-
-@Service
-@SuppressWarnings("all")
-public class BlockificationService {
-
-    static final float THRESHOLD = 1f;
-
-
-    /**
-     * This method is building blocks by expanding the minX/maxX and minY/maxY value on each word that is not split by the conditions.
-     * This method must use text direction adjusted postions (DirAdj). Where {0,0} is on the upper left. Never try to change this!
-     * Rulings (TablePageBlock lines) must be adjusted to the text directions as well, when checking if a block is split by a ruling.
-     *
-     * @param textPositions         The words of a page.
-     * @param horizontalRulingLines Horizontal table lines.
-     * @param verticalRulingLines   Vertical table lines.
-     * @return Page object that contains the Textblock and text statistics.
-     */
-    public ClassificationPage blockify(List<TextPositionSequence> textPositions, List<Ruling> horizontalRulingLines, List<Ruling> verticalRulingLines) {
-
-        int indexOnPage = 0;
-        List<TextPositionSequence> chunkWords = new ArrayList<>();
-        List<AbstractPageBlock> chunkBlockList = new ArrayList<>();
-
-        float minX = 1000, maxX = 0, minY = 1000, maxY = 0;
-        TextPositionSequence prev = null;
-
-        boolean wasSplitted = false;
-        Float splitX1 = null;
-        for (TextPositionSequence word : textPositions) {
-
-            boolean lineSeparation = word.getMinYDirAdj() - maxY > word.getHeight() * 1.25;
-            boolean startFromTop = prev != null && word.getMinYDirAdj() < prev.getMinYDirAdj() - prev.getTextHeight();
-            boolean splitByX = prev != null && maxX + 50 < word.getMinXDirAdj() && prev.getMinYDirAdj() == word.getMinYDirAdj();
-            boolean xIsBeforeFirstX = prev != null && word.getMinXDirAdj() < minX;
-            boolean newLineAfterSplit = prev != null && word.getMinYDirAdj() != prev.getMinYDirAdj() && wasSplitted && splitX1 != word.getMinXDirAdj();
-            boolean isSplitByRuling = isSplitByRuling(minX, minY, maxX, maxY, word, horizontalRulingLines, verticalRulingLines);
-            boolean splitByDir = prev != null && !prev.getDir().equals(word.getDir());
-
-            if (prev != null && (lineSeparation || startFromTop || splitByX || splitByDir || isSplitByRuling)) {
-
-                Orientation prevOrientation = null;
-                if (!chunkBlockList.isEmpty()) {
-                    prevOrientation = chunkBlockList.get(chunkBlockList.size() - 1).getOrientation();
-                }
-
-                TextPageBlock cb1 = buildTextBlock(chunkWords, indexOnPage);
-                indexOnPage++;
-
-                chunkBlockList.add(cb1);
-                chunkWords = new ArrayList<>();
-
-                if (splitByX && !isSplitByRuling) {
-                    wasSplitted = true;
-                    cb1.setOrientation(Orientation.LEFT);
-                    splitX1 = word.getMinXDirAdj();
-                } else if (newLineAfterSplit && !isSplitByRuling) {
-                    wasSplitted = false;
-                    cb1.setOrientation(Orientation.RIGHT);
-                    splitX1 = null;
-                } else if (prevOrientation != null && prevOrientation.equals(Orientation.RIGHT) && (lineSeparation || !startFromTop || !splitByX || !newLineAfterSplit || !isSplitByRuling)) {
-                    cb1.setOrientation(Orientation.LEFT);
-                }
-
-                minX = 1000;
-                maxX = 0;
-                minY = 1000;
-                maxY = 0;
-                prev = null;
-            }
-
-            chunkWords.add(word);
-
-            prev = word;
-            if (word.getMinXDirAdj() < minX) {
-                minX = word.getMinXDirAdj();
-            }
-            if (word.getMaxXDirAdj() > maxX) {
-                maxX = word.getMaxXDirAdj();
-            }
-            if (word.getMinYDirAdj() < minY) {
-                minY = word.getMinYDirAdj();
-            }
-            if (word.getMaxYDirAdj() > maxY) {
-                maxY = word.getMaxYDirAdj();
-            }
-        }
-
-        TextPageBlock cb1 = buildTextBlock(chunkWords, indexOnPage);
-        if (cb1 != null) {
-            chunkBlockList.add(cb1);
-        }
-
-        Iterator<AbstractPageBlock> itty = chunkBlockList.iterator();
-
-        TextPageBlock previousLeft = null;
-        TextPageBlock previousRight = null;
-        while (itty.hasNext()) {
-            TextPageBlock block = (TextPageBlock) itty.next();
-
-            if (previousLeft != null && block.getOrientation().equals(Orientation.LEFT)) {
-                if (previousLeft.getMinY() > block.getMinY() && block.getMaxY() + block.getMostPopularWordHeight() > previousLeft.getMinY()) {
-                    previousLeft.add(block);
-                    itty.remove();
-                    continue;
-                }
-            }
-
-            if (previousRight != null && block.getOrientation().equals(Orientation.RIGHT)) {
-                if (previousRight.getMinY() > block.getMinY() && block.getMaxY() + block.getMostPopularWordHeight() > previousRight.getMinY()) {
-                    previousRight.add(block);
-                    itty.remove();
-                    continue;
-                }
-            }
-
-            if (block.getOrientation().equals(Orientation.LEFT)) {
-                previousLeft = block;
-            } else if (block.getOrientation().equals(Orientation.RIGHT)) {
-                previousRight = block;
-            }
-        }
-
-        itty = chunkBlockList.iterator();
-        TextPageBlock previous = null;
-        while (itty.hasNext()) {
-            TextPageBlock block = (TextPageBlock) itty.next();
-
-            if (previous != null && previous.getOrientation().equals(Orientation.LEFT) && block.getOrientation().equals(Orientation.LEFT) && equalsWithThreshold(block.getMaxY(),
-                    previous.getMaxY()) || previous != null && previous.getOrientation().equals(Orientation.LEFT) && block.getOrientation()
-                    .equals(Orientation.RIGHT) && equalsWithThreshold(block.getMaxY(), previous.getMaxY())) {
-                previous.add(block);
-                itty.remove();
-                continue;
-            }
-
-            previous = block;
-        }
-
-        return new ClassificationPage(chunkBlockList);
-    }
-
-
-    private boolean equalsWithThreshold(float f1, float f2) {
-
-        return Math.abs(f1 - f2) < THRESHOLD;
-    }
-
-
-    private TextPageBlock buildTextBlock(List<TextPositionSequence> wordBlockList, int indexOnPage) {
-
-        TextPageBlock textBlock = null;
-
-        FloatFrequencyCounter lineHeightFrequencyCounter = new FloatFrequencyCounter();
-        FloatFrequencyCounter fontSizeFrequencyCounter = new FloatFrequencyCounter();
-        FloatFrequencyCounter spaceFrequencyCounter = new FloatFrequencyCounter();
-        StringFrequencyCounter fontFrequencyCounter = new StringFrequencyCounter();
-        StringFrequencyCounter styleFrequencyCounter = new StringFrequencyCounter();
-
-        for (TextPositionSequence wordBlock : wordBlockList) {
-
-            lineHeightFrequencyCounter.add(wordBlock.getTextHeight());
-            fontSizeFrequencyCounter.add(wordBlock.getFontSize());
-            spaceFrequencyCounter.add(wordBlock.getSpaceWidth());
-            fontFrequencyCounter.add(wordBlock.getFont());
-            styleFrequencyCounter.add(wordBlock.getFontStyle());
-
-            if (textBlock == null) {
-                textBlock = new TextPageBlock(wordBlock.getMinXDirAdj(),
-                        wordBlock.getMaxXDirAdj(),
-                        wordBlock.getMinYDirAdj(),
-                        wordBlock.getMaxYDirAdj(),
-                        wordBlockList,
-                        wordBlock.getRotation());
-            } else {
-                TextPageBlock spatialEntity = textBlock.union(wordBlock);
-                textBlock.resize(spatialEntity.getMinX(), spatialEntity.getMinY(), spatialEntity.getWidth(), spatialEntity.getHeight());
-            }
-        }
-
-        if (textBlock != null) {
-            textBlock.setMostPopularWordFont(fontFrequencyCounter.getMostPopular());
-            textBlock.setMostPopularWordStyle(styleFrequencyCounter.getMostPopular());
-            textBlock.setMostPopularWordFontSize(fontSizeFrequencyCounter.getMostPopular());
-            textBlock.setMostPopularWordHeight(lineHeightFrequencyCounter.getMostPopular());
-            textBlock.setMostPopularWordSpaceWidth(spaceFrequencyCounter.getMostPopular());
-            textBlock.setHighestFontSize(fontSizeFrequencyCounter.getHighest());
-        }
-
-        if (textBlock != null && textBlock.getSequences() != null && textBlock.getSequences().stream().map(t -> round(t.getMinYDirAdj(), 3)).collect(toSet()).size() == 1) {
-            textBlock.getSequences().sort(Comparator.comparing(TextPositionSequence::getMinXDirAdj));
-        }
-        return textBlock;
-    }
-
-
-    private boolean isSplitByRuling(float minX,
-                                    float minY,
-                                    float maxX,
-                                    float maxY,
-                                    TextPositionSequence word,
-                                    List<Ruling> horizontalRulingLines,
-                                    List<Ruling> verticalRulingLines) {
-
-        return isSplitByRuling(maxX,
-                minY,
-                word.getMinXDirAdj(),
-                word.getMinYDirAdj(),
-                verticalRulingLines,
-                word.getDir().getDegrees(),
-                word.getPageWidth(),
-                word.getPageHeight()) //
-                || isSplitByRuling(minX,
-                minY,
-                word.getMinXDirAdj(),
-                word.getMaxYDirAdj(),
-                horizontalRulingLines,
-                word.getDir().getDegrees(),
-                word.getPageWidth(),
-                word.getPageHeight()) //
-                || isSplitByRuling(maxX,
-                minY,
-                word.getMinXDirAdj(),
-                word.getMinYDirAdj(),
-                horizontalRulingLines,
-                word.getDir().getDegrees(),
-                word.getPageWidth(),
-                word.getPageHeight()) //
-                || isSplitByRuling(minX,
-                minY,
-                word.getMinXDirAdj(),
-                word.getMaxYDirAdj(),
-                verticalRulingLines,
-                word.getDir().getDegrees(),
-                word.getPageWidth(),
-                word.getPageHeight());
-    }
-
-
-    private boolean isSplitByRuling(float previousX2, float previousY1, float currentX1, float currentY1, List<Ruling> rulingLines, float dir, float pageWidth, float pageHeight) {
-
-        for (Ruling ruling : rulingLines) {
-            var line = RulingTextDirAdjustUtil.convertToDirAdj(ruling, dir, pageWidth, pageHeight);
-            if (line.intersectsLine(previousX2, previousY1, currentX1, currentY1)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-
-    private double round(float value, int decimalPoints) {
-
-        var d = Math.pow(10, decimalPoints);
-        return Math.round(value * d) / d;
-    }
-
-}

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

@@ -1,164 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.service;
-
-import java.util.List;
-
-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.Rectangle;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.AbstractPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.ClassificationPage;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.FloatFrequencyCounter;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.table.Cell;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.table.TablePageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.text.TextPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.classification.utils.PositionUtils;
-
-@Service
-public class BodyTextFrameService {
-
-    private static final float APPROXIMATE_HEADER_LINE_COUNT = 2.9f;
-
-
-    /**
-     * Adjusts and sets the body text frame to a page.
-     * Note: This needs to use Pdf Coordinate System where {0,0} rotated with the page rotation.
-     * 0 -> LowerLeft
-     * 90 -> UpperLeft
-     * 180 -> UpperRight
-     * 270 -> LowerRight
-     * The aspect ratio of the page is also regarded.
-     *
-     * @param page                   The page
-     * @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) {
-
-        Rectangle textFrame = page.isLandscape() ? landscapeBodyTextFrame : bodyTextFrame;
-
-        if (page.getPageWidth() > page.getPageHeight() && page.getRotation() == 270) {
-            textFrame = new Rectangle(new Point(textFrame.getTopLeft().getY(), page.getPageHeight() - textFrame.getTopLeft().getX() - textFrame.getWidth()),
-                    textFrame.getHeight(),
-                    textFrame.getWidth(),
-                    0);
-        } else if (page.getPageWidth() > page.getPageHeight() && page.getRotation() != 0) {
-            textFrame = new Rectangle(new Point(textFrame.getTopLeft().getY(), textFrame.getTopLeft().getX()), textFrame.getHeight(), textFrame.getWidth(), page.getPageNumber());
-        } else if (page.getRotation() == 180) {
-            textFrame = new Rectangle(new Point(textFrame.getTopLeft().getX(), page.getPageHeight() - textFrame.getTopLeft().getY() - textFrame.getHeight()),
-                    textFrame.getWidth(),
-                    textFrame.getHeight(),
-                    0);
-        }
-        page.setBodyTextFrame(textFrame);
-    }
-
-
-    /**
-     * Calculates the frame that contains the main text, text outside the frame will be e.g. headers or footers.
-     * Note: This needs to use Pdf Coordinate System where {0,0} rotated with the page rotation.
-     * 0 -> LowerLeft
-     * 90 -> UpperLeft
-     * 180 -> UpperRight
-     * 270 -> LowerRight
-     * The aspect ratio of the page is also regarded.
-     *
-     * @param pages                   List of all pages
-     * @param documentFontSizeCounter Statistics of the document
-     * @param landscape               Calculate for landscape or portrait
-     * @return Rectangle of the text frame
-     */
-    public Rectangle calculateBodyTextFrame(List<ClassificationPage> pages, FloatFrequencyCounter documentFontSizeCounter, boolean landscape) {
-
-        BodyTextFrameExpansionsRectangle expansionsRectangle = new BodyTextFrameExpansionsRectangle();
-
-        for (ClassificationPage page : pages) {
-
-            if (page.getTextBlocks().isEmpty() || landscape != page.isLandscape()) {
-                continue;
-            }
-
-            for (AbstractPageBlock container : page.getTextBlocks()) {
-
-                if (container instanceof TextPageBlock) {
-                    TextPageBlock textBlock = (TextPageBlock) container;
-                    if (textBlock.getMostPopularWordFont() == null || textBlock.getMostPopularWordStyle() == null) {
-                        continue;
-                    }
-
-                    float approxLineCount = PositionUtils.getApproxLineCount(textBlock);
-                    if (approxLineCount < APPROXIMATE_HEADER_LINE_COUNT) {
-                        continue;
-                    }
-
-                    if (documentFontSizeCounter.getMostPopular() != null && textBlock.getMostPopularWordFontSize() >= documentFontSizeCounter.getMostPopular()) {
-
-                        expandRectangle(textBlock, page, expansionsRectangle);
-                    }
-                }
-
-                if (container instanceof TablePageBlock) {
-                    TablePageBlock table = (TablePageBlock) container;
-                    for (List<Cell> row : table.getRows()) {
-                        for (Cell cell : row) {
-
-                            if (cell == null || cell.getTextBlocks() == null) {
-                                continue;
-                            }
-                            for (TextPageBlock textBlock : cell.getTextBlocks()) {
-                                expandRectangle(textBlock, page, expansionsRectangle);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return new Rectangle(new Point(expansionsRectangle.minX, expansionsRectangle.minY),
-                expansionsRectangle.maxX - expansionsRectangle.minX,
-                expansionsRectangle.maxY - expansionsRectangle.minY,
-                0);
-    }
-
-
-    private void expandRectangle(TextPageBlock textBlock, ClassificationPage page, BodyTextFrameExpansionsRectangle expansionsRectangle) {
-
-        if (page.getPageWidth() > page.getPageHeight() && page.getRotation() != 0) {
-            if (textBlock.getPdfMinY() < expansionsRectangle.minX) {
-                expansionsRectangle.minX = textBlock.getPdfMinY();
-            }
-            if (textBlock.getPdfMaxY() > expansionsRectangle.maxX) {
-                expansionsRectangle.maxX = textBlock.getPdfMaxY();
-            }
-            if (textBlock.getPdfMinX() < expansionsRectangle.minY) {
-                expansionsRectangle.minY = textBlock.getPdfMinX();
-            }
-            if (textBlock.getPdfMaxX() > expansionsRectangle.maxY) {
-                expansionsRectangle.maxY = textBlock.getPdfMaxX();
-            }
-        } else {
-            if (textBlock.getPdfMinX() < expansionsRectangle.minX) {
-                expansionsRectangle.minX = textBlock.getPdfMinX();
-            }
-            if (textBlock.getPdfMaxX() > expansionsRectangle.maxX) {
-                expansionsRectangle.maxX = textBlock.getPdfMaxX();
-            }
-            if (textBlock.getPdfMinY() < expansionsRectangle.minY) {
-                expansionsRectangle.minY = textBlock.getPdfMinY();
-            }
-            if (textBlock.getPdfMaxY() > expansionsRectangle.maxY) {
-                expansionsRectangle.maxY = textBlock.getPdfMaxY();
-            }
-        }
-    }
-
-
-    private class BodyTextFrameExpansionsRectangle {
-
-        float minX = 10000;
-        float maxX = -100;
-        float minY = 10000;
-        float maxY = -100;
-
-    }
-
-}

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

@@ -1,115 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.service;
-
-import java.util.List;
-import java.util.regex.Pattern;
-
-import org.springframework.stereotype.Service;
-
-import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Rectangle;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.AbstractPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.ClassificationDocument;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.ClassificationPage;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.PageBlockType;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.text.TextPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.classification.utils.PositionUtils;
-
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-@Service
-@RequiredArgsConstructor
-public class ClassificationService {
-
-    private final BodyTextFrameService bodyTextFrameService;
-
-
-    public void classifyDocument(ClassificationDocument document) {
-
-        Rectangle bodyTextFrame = bodyTextFrameService.calculateBodyTextFrame(document.getPages(), document.getFontSizeCounter(), false);
-        Rectangle landscapeBodyTextFrame = bodyTextFrameService.calculateBodyTextFrame(document.getPages(), document.getFontSizeCounter(), true);
-        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);
-        }
-    }
-
-
-    public void classifyPage(ClassificationPage page, ClassificationDocument document, List<Float> headlineFontSizes) {
-
-        for (AbstractPageBlock textBlock : page.getTextBlocks()) {
-            if (textBlock instanceof TextPageBlock) {
-                classifyBlock((TextPageBlock) textBlock, page, document, headlineFontSizes);
-            }
-        }
-    }
-
-
-    public void classifyBlock(TextPageBlock textBlock, ClassificationPage page, ClassificationDocument document, List<Float> headlineFontSizes) {
-
-        var bodyTextFrame = page.getBodyTextFrame();
-
-        if (document.getFontSizeCounter().getMostPopular() == null) {
-            textBlock.setClassification(PageBlockType.OTHER);
-            return;
-        }
-        if (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())) {
-            textBlock.setClassification(PageBlockType.FOOTER);
-        } else if (page.getPageNumber() == 1 && (PositionUtils.getHeightDifferenceBetweenChunkWordAndDocumentWord(textBlock,
-                document.getTextHeightCounter().getMostPopular()) > 2.5 && textBlock.getHighestFontSize() > document.getFontSizeCounter().getMostPopular() || page.getTextBlocks()
-                .size() == 1)) {
-            if (!Pattern.matches("[0-9]+", textBlock.toString())) {
-                textBlock.setClassification(PageBlockType.TITLE);
-            }
-        } else if (textBlock.getMostPopularWordFontSize() > document.getFontSizeCounter()
-                .getMostPopular() && PositionUtils.getApproxLineCount(textBlock) < 4.9 && (textBlock.getMostPopularWordStyle().equals("bold") || !document.getFontStyleCounter()
-                .getCountPerValue()
-                .containsKey("bold") && textBlock.getMostPopularWordFontSize() > document.getFontSizeCounter().getMostPopular() + 1) && textBlock.getSequences()
-                .get(0)
-                .getTextPositions()
-                .get(0)
-                .getFontSizeInPt() >= textBlock.getMostPopularWordFontSize()) {
-
-            for (int i = 1; i <= headlineFontSizes.size(); i++) {
-                if (textBlock.getMostPopularWordFontSize() == headlineFontSizes.get(i - 1)) {
-                    textBlock.setClassification(PageBlockType.getHeadlineType(i));
-                    document.setHeadlines(true);
-                }
-            }
-        } else if (!textBlock.getText().startsWith("Figure ") && PositionUtils.isWithinBodyTextFrame(bodyTextFrame, textBlock) && textBlock.getMostPopularWordStyle()
-                .equals("bold") && !document.getFontStyleCounter().getMostPopular().equals("bold") && PositionUtils.getApproxLineCount(textBlock) < 2.9 && textBlock.getSequences()
-                .get(0)
-                .getTextPositions()
-                .get(0)
-                .getFontSizeInPt() >= textBlock.getMostPopularWordFontSize()) {
-            textBlock.setClassification(PageBlockType.getHeadlineType(headlineFontSizes.size() + 1));
-            document.setHeadlines(true);
-        } else if (PositionUtils.isWithinBodyTextFrame(bodyTextFrame, textBlock) && textBlock.getMostPopularWordFontSize() == document.getFontSizeCounter()
-                .getMostPopular() && textBlock.getMostPopularWordStyle().equals("bold") && !document.getFontStyleCounter().getMostPopular().equals("bold")) {
-            textBlock.setClassification(PageBlockType.PARAGRAPH_BOLD);
-        } else if (PositionUtils.isWithinBodyTextFrame(bodyTextFrame, textBlock) && textBlock.getMostPopularWordFont()
-                .equals(document.getFontCounter().getMostPopular()) && textBlock.getMostPopularWordStyle()
-                .equals(document.getFontStyleCounter().getMostPopular()) && textBlock.getMostPopularWordFontSize() == document.getFontSizeCounter().getMostPopular()) {
-            textBlock.setClassification(PageBlockType.PARAGRAPH);
-        } else if (PositionUtils.isWithinBodyTextFrame(bodyTextFrame, textBlock) && textBlock.getMostPopularWordFontSize() == document.getFontSizeCounter()
-                .getMostPopular() && textBlock.getMostPopularWordStyle().equals("italic") && !document.getFontStyleCounter()
-                .getMostPopular()
-                .equals("italic") && PositionUtils.getApproxLineCount(textBlock) < 2.9) {
-            textBlock.setClassification(PageBlockType.PARAGRAPH_ITALIC);
-        } else if (PositionUtils.isWithinBodyTextFrame(bodyTextFrame, textBlock)) {
-            textBlock.setClassification(PageBlockType.PARAGRAPH_UNKNOWN);
-        } else {
-            textBlock.setClassification(PageBlockType.OTHER);
-        }
-    }
-
-}

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

@@ -1,136 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.service;
-
-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.processor.adapter.ImageServiceResponseAdapter;
-import com.knecon.fforesight.service.layoutparser.processor.adapter.model.table.TableCells;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.AbstractPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.ClassificationDocument;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.ClassificationPage;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.image.ClassifiedImage;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.table.CleanRulings;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.text.TextPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.text.TextPositionSequence;
-import com.knecon.fforesight.service.layoutparser.processor.classification.parsing.PDFLinesTextStripper;
-
-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 BlockificationService blockificationService;
-    private final ImageServiceResponseAdapter imageServiceResponseAdapter;
-
-
-    public ClassificationDocument parseDocument(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(pdfImages, originDocument, pdfTableCells, document, classificationPages, pageNumber);
-        }
-
-        document.setPages(classificationPages);
-
-        return document;
-    }
-
-
-    @SneakyThrows
-    private void parsePage(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 = blockificationService.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);
-        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/classification/service/RulingCleaningService.java

@@ -1,231 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.service;
-
-import java.awt.geom.Line2D;
-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 org.springframework.stereotype.Service;
-
-import com.knecon.fforesight.service.layoutparser.processor.adapter.model.table.TableCells;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.table.CleanRulings;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.table.Ruling;
-import com.knecon.fforesight.service.layoutparser.processor.classification.utils.DoubleComparisons;
-
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-@Service
-@RequiredArgsConstructor
-public class RulingCleaningService {
-
-    public CleanRulings getCleanRulings(List<TableCells> tableCells, List<Ruling> rulings, float minCharWidth, float maxCharHeight) {
-
-        if (!rulings.isEmpty()) {
-            snapPoints(rulings, minCharWidth, maxCharHeight);
-        }
-
-        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) {
-            if (hr.horizontal()) {
-                hrs.add(hr);
-            }
-        }
-        if (hrs.isEmpty()) {
-            hrs.addAll(extractHorizontalRulings(tableCells));
-        }
-        List<Ruling> horizontalRulingLines = collapseOrientedRulings(hrs);
-
-        return CleanRulings.builder().vertical(verticalRulingLines).horizontal(horizontalRulingLines).build();
-    }
-
-
-    public void snapPoints(List<? extends Line2D.Float> rulings, float xThreshold, float yThreshold) {
-
-        // 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]);
-        }
-    }
-
-
-    private Collection<? extends Ruling> extractVerticalRulings(List<TableCells> cvParsedTableCells) {
-
-        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());
-                vrs.add(leftLine);
-                vrs.add(rightLine);
-            }
-        }
-        return vrs;
-    }
-
-
-    private Collection<? extends Ruling> extractHorizontalRulings(List<TableCells> cvParsedTableCells) {
-
-        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());
-                hrs.add(topLine);
-                hrs.add(baseLine);
-            }
-        }
-
-        return hrs;
-    }
-
-
-    private Ruling createRuling(float tableCellX0, float tableCellX1, float tableCellY0, float tableCellY1) {
-
-        float x0 = tableCellX0;
-        float x1 = tableCellX1;
-        float y0 = tableCellY0;
-        float y1 = tableCellY1;
-
-        if (x1 < x0) {
-            x0 = tableCellX1;
-            x1 = tableCellX0;
-        }
-
-        if (y1 < y0) {
-            y0 = tableCellY1;
-            y1 = tableCellY0;
-        }
-
-        return new Ruling(new Point2D.Float(x0, y0), new Point2D.Float(x1, y1));
-    }
-
-
-    private List<Ruling> collapseOrientedRulings(List<Ruling> lines) {
-
-        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/classification/service/TableExtractionService.java

@@ -1,336 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.service;
-
-import java.awt.geom.Point2D;
-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 org.springframework.stereotype.Service;
-
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.AbstractPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.ClassificationPage;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.table.Cell;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.table.CleanRulings;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.table.Rectangle;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.table.Ruling;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.table.TablePageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.classification.model.text.TextPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.classification.utils.DoubleComparisons;
-
-@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;
-    };
-
-
-    /**
-     * Finds tables on a page and moves textblocks into cells of the found tables.
-     * Note: This algorithm uses Pdf Coordinate System where {0,0} rotated with the page rotation.
-     * 0 -> LowerLeft
-     * 90 -> UpperLeft
-     * 180 -> UpperRight
-     * 270 -> LowerRight
-     * <p>
-     * DirAdj (Text direction adjusted) values can not be used here.
-     *
-     * @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) {
-
-        List<Cell> cells = findCells(cleanRulings.getHorizontal(), cleanRulings.getVertical());
-
-        List<TextPageBlock> toBeRemoved = new ArrayList<>();
-
-        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())) {
-                    cell.addTextBlock(textBlock);
-                    toBeRemoved.add(textBlock);
-                    break;
-                }
-            }
-        }
-
-        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<TablePageBlock> tables = new ArrayList<>();
-        for (Rectangle area : spreadsheetAreas) {
-
-            List<Cell> overlappingCells = new ArrayList<>();
-            for (Cell c : cells) {
-                if (c.hasMinimumSize() && c.intersects(area)) {
-                    overlappingCells.add(c);
-                }
-            }
-            tables.add(new TablePageBlock(overlappingCells, area, page.getRotation()));
-        }
-
-        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);
-                }
-            }
-            if (position != -1) {
-                page.getTextBlocks().add(position, table);
-            }
-        }
-
-        page.getTextBlocks().removeAll(toBeRemoved);
-    }
-
-
-    public List<Cell> findCells(List<Ruling> horizontalRulingLines, List<Ruling> verticalRulingLines) {
-
-        List<Cell> cellsFound = new ArrayList<>();
-        Map<Point2D, Ruling[]> intersectionPoints = Ruling.findIntersections(horizontalRulingLines, verticalRulingLines);
-        List<Point2D> intersectionPointsList = new ArrayList<>(intersectionPoints.keySet());
-        intersectionPointsList.sort(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 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;
-    }
-
-
-    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;
-
-        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(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;
-    }
-
-
-    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/classification/utils/FileUtils.java

@@ -1,56 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.utils;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-
-import lombok.experimental.UtilityClass;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
-@UtilityClass
-public class FileUtils {
-
-    public File createTempFile(String filenamePrefix, String filenameSuffix) throws IOException {
-
-        File tempFile = Files.createTempFile(filenamePrefix, filenameSuffix).toFile();
-        setRWPermissionsOnlyForOwner(tempFile);
-
-        return tempFile;
-    }
-
-
-    /**
-     * Deletes a file; logs a message with the reason if the deletion fails.
-     * This method is null-safe.
-     *
-     * @param file The file to delete.  Can be null.
-     */
-    public void deleteFile(File file) {
-
-        if (file != null) {
-            try {
-                Files.deleteIfExists(file.toPath());
-            } catch (IOException ex) {
-                log.warn("Could not delete file!", ex);
-            }
-        }
-    }
-
-
-    // We don't need to check the results of the permission setters below,
-    // since we're manipulating a file we created ourselves.
-    @SuppressWarnings({"ResultOfMethodCallIgnored", "squid:S899"})
-    private void setRWPermissionsOnlyForOwner(File tempFile) {
-
-        try {
-            tempFile.setReadable(true, true);
-            tempFile.setWritable(true, true);
-            tempFile.setExecutable(false);
-        } catch (SecurityException ex) {
-            // This should never happen since we're creating a temp file ourselves.
-            log.warn("Caught an exception during temp file creation.  This should not happend.  Check the code.", ex);
-        }
-    }
-
-}

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

@@ -1,31 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.classification.utils;
-
-import lombok.experimental.UtilityClass;
-
-@UtilityClass
-public final class TextNormalizationUtilities {
-
-    /**
-     * Revert hyphenation due to line breaks.
-     *
-     * @param text Text to be processed.
-     * @return Text without line-break hyphenation.
-     */
-    public static String removeHyphenLineBreaks(String text) {
-
-        return text.replaceAll("([^\\s\\d\\-]{2,500})[\\-\\u00AD]\\R", "$1");
-    }
-
-
-    public static String removeLineBreaks(String text) {
-
-        return text.replaceAll("\n", " ");
-    }
-
-
-    public static String removeRepeatingWhitespaces(String text) {
-
-        return text.replaceAll(" {2}", " ");
-    }
-
-}

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

@@ -0,0 +1,98 @@
+package com.knecon.fforesight.service.layoutparser.processor.docstrum;
+
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.springframework.stereotype.Service;
+
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.Character;
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.Line;
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.Zone;
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.service.LineBuilderService;
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.service.NearestNeighbourService;
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.service.ReadingOrderService;
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.service.SpacingService;
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.service.ZoneBuilderService;
+import com.knecon.fforesight.service.layoutparser.processor.model.table.CleanRulings;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.RedTextPosition;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.TextDirection;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.Word;
+import com.knecon.fforesight.service.layoutparser.processor.visualization.LayoutDebugLayer;
+
+import lombok.RequiredArgsConstructor;
+
+@Service
+@RequiredArgsConstructor
+public class DocstrumSegmentationService {
+
+    public static final double SAME_DIRECTION_THRESHOLD = 0.9;
+    private final NearestNeighbourService nearestNeighbourService;
+    private final SpacingService spacingService;
+    private final LineBuilderService lineBuilderService;
+    private final ZoneBuilderService zoneBuilderService;
+    private final ReadingOrderService readingOrderService;
+
+
+    public List<Zone> segmentPage(List<Word> textPositions, boolean xyOrder, CleanRulings usedRulings, LayoutDebugLayer visualizations) {
+
+        EnumMap<TextDirection, Integer> directionCounts = new EnumMap<>(TextDirection.class);
+
+        List<Zone> newZones = computeZones(textPositions, usedRulings, visualizations, TextDirection.ZERO);
+        directionCounts.put(TextDirection.ZERO, newZones.size());
+        List<Zone> zones = new ArrayList<>(newZones);
+
+        newZones = computeZones(textPositions, usedRulings, visualizations, TextDirection.QUARTER_CIRCLE);
+        directionCounts.put(TextDirection.QUARTER_CIRCLE, newZones.size());
+        zones.addAll(newZones);
+
+        newZones = computeZones(textPositions, usedRulings, visualizations, TextDirection.HALF_CIRCLE);
+        directionCounts.put(TextDirection.HALF_CIRCLE, newZones.size());
+        zones.addAll(newZones);
+
+        newZones = computeZones(textPositions, usedRulings, visualizations, TextDirection.THREE_QUARTER_CIRCLE);
+        directionCounts.put(TextDirection.THREE_QUARTER_CIRCLE, newZones.size());
+        zones.addAll(newZones);
+
+        return readingOrderService.resolve(zones, xyOrder, mostSameDirection(directionCounts));
+    }
+
+
+    private boolean mostSameDirection(EnumMap<TextDirection, Integer> directionCounts) {
+
+        int total = directionCounts.values()
+                .stream()
+                .mapToInt(i -> i).sum();
+
+        if ((double) directionCounts.get(TextDirection.ZERO) / total > SAME_DIRECTION_THRESHOLD) {
+            return true;
+        } else if ((double) directionCounts.get(TextDirection.QUARTER_CIRCLE) / total > SAME_DIRECTION_THRESHOLD) {
+            return true;
+        } else if ((double) directionCounts.get(TextDirection.HALF_CIRCLE) / total > SAME_DIRECTION_THRESHOLD) {
+            return true;
+        } else if ((double) directionCounts.get(TextDirection.THREE_QUARTER_CIRCLE) / total > SAME_DIRECTION_THRESHOLD) {
+            return true;
+        }
+        return false;
+    }
+
+
+    private List<Zone> computeZones(List<Word> textPositions, CleanRulings rulings, LayoutDebugLayer visualizations, TextDirection direction) {
+
+        List<Character> characters = textPositions.stream()
+                .filter(t -> t.getDir() == direction)
+                .map(Word::getCharacters)
+                .flatMap(List::stream)
+                .toList();
+
+        nearestNeighbourService.findNearestNeighbors(characters);
+
+        double characterSpacing = spacingService.computeCharacterSpacing(characters);
+        double lineSpacing = Math.min(spacingService.computeLineSpacing(characters), 20);
+
+        List<Line> lines = lineBuilderService.buildLines(characters, characterSpacing, lineSpacing, rulings);
+        return zoneBuilderService.buildZones(lines, characterSpacing, lineSpacing, rulings);
+    }
+
+}

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

@@ -0,0 +1,31 @@
+package com.knecon.fforesight.service.layoutparser.processor.docstrum.model;
+
+public class AngleFilter {
+
+    protected double lowerAngle;
+    protected double upperAngle;
+
+
+    public AngleFilter(double lowerAngle, double upperAngle) {
+
+        this.lowerAngle = lowerAngle < -Math.PI / 2 ? lowerAngle + Math.PI : lowerAngle;
+        this.upperAngle = upperAngle >= Math.PI / 2 ? upperAngle - Math.PI : upperAngle;
+    }
+
+
+    public boolean matches(Neighbor neighbor) {
+
+        return matches(neighbor.getAngle());
+    }
+
+
+    public boolean matches(double angle) {
+
+        if (lowerAngle <= upperAngle) {
+            return lowerAngle <= angle && angle < upperAngle;
+        } else {
+            return lowerAngle <= angle || angle < upperAngle;
+        }
+    }
+
+}

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

@@ -0,0 +1,279 @@
+package com.knecon.fforesight.service.layoutparser.processor.docstrum.model;
+
+import java.awt.geom.Rectangle2D;
+import java.util.Comparator;
+import java.util.List;
+
+import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+@Data
+@SuperBuilder
+@NoArgsConstructor
+public abstract class BoundingBox {
+
+    // Java coordinate system: (0, 0) is always upper left, x is increasing left to right and y is increasing from top to bottom.
+    // should be used when determining reading order or other tasks which require coordinates in a harmonized system.
+    protected Rectangle2D bBox; // I would not trust this coordinate when comparing rulings and text, due to the text positions being slightly off.
+
+    // PDF coordinate system: depends on page rotation, (0, 0) is lower left corner, x is increasing left to right and y from bottom to top.
+    // This rotates completely in 90 degree steps with page rotation.
+    // Needs to be used when writing to a PDF.
+    // Also, these are definitely correct and should be used whenever possible.
+    protected Rectangle2D bBoxPdf;
+
+    protected static final float VERTICAL_COMPARISON_THRESHOLD = 0.4f;
+
+
+    public double getX() {
+
+        return bBox.getX();
+    }
+
+
+    public double getY() {
+
+        return bBox.getY();
+    }
+
+
+    public double getMinX() {
+
+        return bBox.getMinX();
+    }
+
+
+    public double getMinY() {
+
+        return bBox.getMinY();
+    }
+
+
+    public double getPdfMinX() {
+
+        return bBoxPdf.getMinX();
+    }
+
+
+    public double getPdfMaxX() {
+
+        return bBoxPdf.getMaxX();
+    }
+
+
+    public double getPdfMinY() {
+
+        return bBoxPdf.getMinY();
+    }
+
+
+    public double getPdfMaxY() {
+
+        return bBoxPdf.getMaxY();
+    }
+
+
+    public double getWidth() {
+
+        return bBox.getWidth();
+    }
+
+
+    public double getHeight() {
+
+        return bBox.getHeight();
+    }
+
+
+    public double getMaxX() {
+
+        return bBox.getMaxX();
+    }
+
+
+    public double getMaxY() {
+
+        return bBox.getMaxY();
+    }
+
+
+    public double getArea() {
+
+        return (bBox.getHeight() * bBox.getWidth());
+    }
+
+
+    public boolean contains(BoundingBox contained) {
+
+        return contains(contained, 0);
+    }
+
+
+    public boolean contains(BoundingBox contained, double tolerance) {
+
+        return getPdfMinX() <= contained.getPdfMinX() + tolerance
+               && getPdfMinY() <= contained.getPdfMinY() + tolerance
+               && getPdfMaxX() >= contained.getPdfMaxX() - tolerance
+               && getPdfMaxY() >= contained.getPdfMaxY() - tolerance;
+    }
+
+
+    public boolean intersects(BoundingBox other) {
+
+        return this.intersectsX(other) && this.intersectsY(other);
+    }
+
+
+    public boolean intersects(BoundingBox other, float yThreshold, float xThreshold) {
+
+        return this.intersectsX(other, xThreshold) && this.intersectsY(other, yThreshold);
+    }
+
+
+    public boolean intersectsX(BoundingBox other, float threshold) {
+
+        return this.getX() - threshold <= other.getMaxX() && this.getMaxX() + threshold >= other.getX();
+    }
+
+
+    public boolean intersectsPdf(BoundingBox other) {
+
+        return this.intersectsXPdf(other) && this.intersectsYPdf(other);
+    }
+
+
+    public boolean intersectsPdf(BoundingBox other, float yThreshold, float xThreshold) {
+
+        return this.intersectsXPdf(other, xThreshold) && this.intersectsYPdf(other, yThreshold);
+    }
+
+
+    public boolean intersectsYPdf(BoundingBox other) {
+
+        return this.getPdfMinY() <= other.getPdfMaxY() && this.getPdfMaxY() >= other.getPdfMinY();
+    }
+
+
+    public boolean intersectsY(BoundingBox other) {
+
+        return this.getY() <= other.getMaxY() && this.getMaxY() >= other.getY();
+    }
+
+
+    public boolean intersectsY(BoundingBox other, float threshold) {
+
+        return this.getY() - threshold <= other.getMaxY() && this.getMaxY() + threshold >= other.getY();
+    }
+
+
+    public boolean intersectsYPdf(BoundingBox other, float threshold) {
+
+        return this.getPdfMinY() - threshold <= other.getPdfMaxY() && this.getPdfMaxY() + threshold >= other.getPdfMinY();
+    }
+
+
+    public boolean intersectsXPdf(BoundingBox other) {
+
+        return this.getPdfMinX() <= other.getPdfMaxX() && this.getPdfMaxX() >= other.getPdfMinX();
+    }
+
+
+    public boolean intersectsX(BoundingBox other) {
+
+        return this.getX() <= other.getMaxX() && this.getMaxX() >= other.getMinX();
+    }
+
+
+    public boolean intersectsXPdf(BoundingBox other, float threshold) {
+
+        return this.getPdfMinX() - threshold <= other.getPdfMaxX() && this.getMaxX() + threshold >= other.getPdfMinX();
+    }
+
+
+    public void setToBBoxOfComponents(List<? extends BoundingBox> components) {
+
+        this.bBox = components.stream()
+                .map(BoundingBox::getBBox)
+                .collect(RectangleTransformations.collectBBox());
+        this.bBoxPdf = components.stream()
+                .map(BoundingBox::getBBoxPdf)
+                .collect(RectangleTransformations.collectBBox());
+    }
+
+
+    public double verticalOverlap(BoundingBox other) {
+
+        return Math.max(0, Math.min(this.getPdfMaxY(), other.getPdfMaxY()) - Math.max(this.getPdfMinY(), other.getPdfMinY()));
+    }
+
+
+    public static final Comparator<BoundingBox> ILL_DEFINED_ORDER = (o1, o2) -> {
+
+        if (o1.equals(o2)) {
+            return 0;
+        }
+        if (o1.verticalOverlap(o2) > VERTICAL_COMPARISON_THRESHOLD * ((o1.getHeight() + o2.getHeight()) / 2)) {
+            return Double.compare(o1.getPdfMinX(), o2.getPdfMinX());
+        } else {
+            return Double.compare(o1.getPdfMaxY(), o2.getPdfMaxY());
+        }
+    };
+
+
+    public double horizontalDistance(BoundingBox other) {
+
+        double rect1Right = getMaxX();
+        double rect1Left = getMinX();
+        double rect2Right = other.getMaxX();
+        double rect2Left = other.getMinX();
+
+        if (rect1Left > rect2Right || rect2Left > rect1Right) {
+            return Math.max(rect2Left - rect1Right, rect1Left - rect2Right);
+        } else {
+            return 0;
+        }
+    }
+
+
+    public double verticalDistance(BoundingBox other) {
+
+        double rect1Top = getMaxY();
+        double rect1Bottom = getMinY();
+        double rect2Top = other.getMaxY();
+        double rect2Bottom = other.getMinY();
+
+        if (rect1Bottom > rect2Top || rect2Bottom > rect1Top) {
+            return Math.max(rect2Bottom - rect1Top, rect1Bottom - rect2Top);
+        } else {
+            return 0;
+        }
+    }
+
+
+    public boolean rightOf(BoundingBox other) {
+
+        return this.intersectsY(other) && other.getMaxX() <= this.getMinX();
+    }
+
+
+    public boolean leftOf(BoundingBox other) {
+
+        return this.intersectsY(other) && other.getMinX() >= this.getMaxX();
+    }
+
+
+    public boolean isAbove(BoundingBox other) {
+
+        return this.intersectsX(other) && other.getMinY() >= this.getMaxY();
+    }
+
+
+    public boolean isBelow(BoundingBox other) {
+
+        return this.intersectsX(other) && this.getMinY() >= other.getMaxY();
+    }
+
+}