Merge branch 'RED-10126' into 'main'

RM-187: Footers are recognized in the middle of the page

See merge request fforesight/layout-parser!233

.gitlab-ci.yml

@@ -21,5 +21,6 @@ deploy:
       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

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

@@ -42,6 +42,19 @@ tasks.jacocoTestReport {
 }
 
 allprojects {
+
+    tasks.withType<Javadoc> {
+        options {
+            this as StandardJavadocDocletOptions
+            addBooleanOption("Xdoclint:none", true)
+            addStringOption("Xmaxwarns", "1")
+        }
+    }
+
+    pmd {
+        setConsoleOutput(true)
+    }
+
     publishing {
         publications {
             create<MavenPublication>(name) {
@@ -64,6 +77,7 @@ java {
     withJavadocJar()
 }
 
+
 repositories {
     mavenLocal()
     mavenCentral()

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

@@ -7,4 +7,5 @@ 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/src/main/java/com/knecon/fforesight/service/layoutparser/internal/api/data/redaction/DocumentData.java

@@ -2,6 +2,11 @@ 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;
@@ -13,16 +18,26 @@ import lombok.experimental.FieldDefaults;
 @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.")
+@Schema(description = "Object containing the complete document layout parsing information. It is split into 4 categories, structure, text, positions and pages: "
+                      + "The document tree structure of SemanticNodes such as Section, Paragraph, Headline, etc. "
+                      + "The text, which is stored as separate blocks of data. "
+                      + "The text positions, which are also stored as separate blocks. The Blocks are equal to the text blocks in length and order. "
+                      + "The page information.")
 public class DocumentData implements Serializable {
 
     @Schema(description = "Contains information about the document's pages.")
-    DocumentPage[] documentPages;
+    AllDocumentPages documentPages;
     @Schema(description = "Contains information about the document's text.")
-    DocumentTextData[] documentTextData;
+    AllDocumentTextData documentTextData;
     @Schema(description = "Contains information about the document's text positions.")
-    DocumentPositionData[] documentPositions;
+    AllDocumentPositionData documentPositions;
     @Schema(description = "Contains information about the document's semantic structure.")
-    DocumentStructure documentStructure;
+    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

@@ -10,6 +10,7 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 import lombok.experimental.FieldDefaults;
 
+@Deprecated
 @Data
 @Builder
 @NoArgsConstructor

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

@@ -10,6 +10,7 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 import lombok.experimental.FieldDefaults;
 
+@Deprecated
 @Data
 @Builder
 @NoArgsConstructor

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

@@ -16,6 +16,7 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 import lombok.experimental.FieldDefaults;
 
+@Deprecated
 @Data
 @Builder
 @NoArgsConstructor

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

@@ -10,6 +10,7 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 import lombok.experimental.FieldDefaults;
 
+@Deprecated
 @Data
 @Builder
 @NoArgsConstructor

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

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

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

@@ -3,6 +3,7 @@ package com.knecon.fforesight.service.layoutparser.internal.api.data.redaction;
 import java.io.Serializable;
 import java.util.Locale;
 
+@Deprecated
 public enum NodeType implements Serializable {
     DOCUMENT,
     SECTION,

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/SimplifiedText.java

@@ -19,6 +19,16 @@ 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/queue/LayoutParsingQueueNames.java

@@ -2,6 +2,9 @@ package com.knecon.fforesight.service.layoutparser.internal.api.queue;
 
 public class LayoutParsingQueueNames {
 
-    public static final String LAYOUT_PARSING_REQUEST_QUEUE = "layout_parsing_request_queue";
-    public static final String LAYOUT_PARSING_FINISHED_EVENT_QUEUE = "layout_parsing_response_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/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-processor/build.gradle.kts

@@ -12,12 +12,14 @@ dependencies {
     implementation(project(":layoutparser-service-internal-api"))
     implementation(project(":viewer-doc-processor"))
 
-    implementation("com.iqser.red.service:persistence-service-shared-api-v1:2.144.0") {
+    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.21.0")
-    implementation("com.iqser.red.commons:storage-commons:2.45.0")
+    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}")
@@ -25,7 +27,14 @@ dependencies {
     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/src/main/java/com/knecon/fforesight/service/layoutparser/processor/LayoutParsingPipeline.java

@@ -2,13 +2,13 @@ package com.knecon.fforesight.service.layoutparser.processor;
 
 import static java.lang.String.format;
 
-import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
@@ -20,11 +20,11 @@ import org.apache.pdfbox.pdmodel.common.PDRectangle;
 import org.apache.pdfbox.pdmodel.documentinterchange.markedcontent.PDMarkedContent;
 import org.springframework.stereotype.Service;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+import com.knecon.fforesight.service.layoutparser.internal.api.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.markdown.MarkdownMapper;
+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;
@@ -69,6 +69,7 @@ import com.knecon.fforesight.service.layoutparser.processor.services.parsing.PDF
 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;
@@ -137,17 +138,16 @@ public class LayoutParsingPipeline {
         log.info("Building document graph for {}", layoutParsingRequest.identifier());
 
         Document documentGraph = observeBuildDocumentGraph(settings.getLayoutParsingTypeOverride() == null //
-                                                                   ? layoutParsingRequest.layoutParsingType() : settings.getLayoutParsingTypeOverride(),
-                                                           classificationDocument);
+                                                                   ? layoutParsingRequest.layoutParsingType() : settings.getLayoutParsingTypeOverride(), classificationDocument);
 
         log.info("Creating viewer document for {}", layoutParsingRequest.identifier());
 
-        layoutGridService.addLayoutGrid(viewerDocumentFile, documentGraph, viewerDocumentFile, false, layoutParsingRequest.visualLayoutParsingFileId().isPresent());
+        layoutGridService.addLayoutGrid(viewerDocumentFile, documentGraph, viewerDocumentFile, false);
 
         log.info("Storing resulting files for {}", layoutParsingRequest.identifier());
 
         layoutParsingStorageService.storeDocumentData(layoutParsingRequest, DocumentDataMapper.toDocumentData(documentGraph));
-        if(layoutParsingRequest.documentMarkdownFileStorageId().isPresent()) {
+        if (layoutParsingRequest.documentMarkdownFileStorageId().isPresent()) {
             layoutParsingStorageService.storeMarkdownFile(layoutParsingRequest.documentMarkdownFileStorageId().get(), new MarkdownMapper().toMarkdownContent(documentGraph));
         }
         layoutParsingStorageService.storeSimplifiedText(layoutParsingRequest, simplifiedSectionTextService.toSimplifiedText(documentGraph));
@@ -245,7 +245,7 @@ public class LayoutParsingPipeline {
         OutlineObject lastProcessedOutlineObject = null;
 
         // parsing the structure elements could be useful as well
-        if (layoutParsingType != LayoutParsingType.REDACT_MANAGER_OLD && layoutParsingType != LayoutParsingType.DOCUMINE_OLD) {
+        if (layoutParsingType != LayoutParsingType.REDACT_MANAGER_OLD) {
             classificationDocument.setOutlineObjectTree(outlineExtractorService.getOutlineObjectTree(originDocument));
         }
 
@@ -271,11 +271,13 @@ public class LayoutParsingPipeline {
             stripper.setStartPage(pageNumber);
             stripper.setEndPage(pageNumber);
             stripper.setPdpage(pdPage);
-            if (layoutParsingType.equals(LayoutParsingType.DOCUMINE_OLD)) {
-                stripper.setSortByPosition(true);
-            }
             stripper.getText(originDocument);
             List<TextPositionSequence> words = stripper.getTextPositionSequences();
+            if (layoutParsingType.equals(LayoutParsingType.DOCUMINE_OLD)) {
+                var lines = TextPositionOperations.groupByLine(new HashSet<>(words));
+                classificationDocument.getLayoutDebugLayer().addLineVisualizationsFromNestedTextPosition(lines, pageNumber);
+                words = TextPositionOperations.sortLines(lines);
+            }
             classificationDocument.getLayoutDebugLayer().addTextVisualizations(words, pageNumber);
 
             PDRectangle pdr = pdPage.getMediaBox();
@@ -321,18 +323,19 @@ public class LayoutParsingPipeline {
             classificationPage.setPageWidth(cropbox.getWidth());
             classificationPage.setPageHeight(cropbox.getHeight());
 
-            if (layoutParsingType != LayoutParsingType.REDACT_MANAGER_OLD && layoutParsingType != LayoutParsingType.DOCUMINE_OLD) {
-                List<OutlineObject> outlineObjects = classificationDocument.getOutlineObjectTree().getOutlineObjectsPerPage().getOrDefault(pageNumber - 1, new ArrayList<>());
+            if (layoutParsingType != LayoutParsingType.REDACT_MANAGER_OLD) {
+                List<OutlineObject> outlineObjects = classificationDocument.getOutlineObjectTree().getOutlineObjectsPerPage().getOrDefault(pageNumber, new ArrayList<>());
 
                 OutlineObject notFoundOutlineObject = null;
                 if (lastProcessedOutlineObject != null && !lastProcessedOutlineObject.isFound()) {
-                    lastProcessedOutlineObject.setPoint(new Point2D.Float(0, cropbox.getHeight()));
+                    lastProcessedOutlineObject.resetPoint();
                     notFoundOutlineObject = lastProcessedOutlineObject;
                 }
                 if (!outlineObjects.isEmpty()) {
                     classificationPage.setOutlineObjects(outlineObjects);
                     lastProcessedOutlineObject = blockificationPostprocessingService.sanitizeOutlineBlocks(classificationPage, notFoundOutlineObject);
                 }
+                classificationDocument.getLayoutDebugLayer().addOutlineObjects(outlineObjects, pageInformation);
             }
 
             classificationDocument.getLayoutDebugLayer().addMarkedContentVisualizations(stripper.getMarkedContents(), pageNumber);
@@ -376,6 +379,12 @@ public class LayoutParsingPipeline {
             case CLARIFYND -> clarifyndClassificationService.classifyDocument(classificationDocument);
         }
 
+        if (layoutParsingType.equals(LayoutParsingType.DOCUMINE_OLD)) {
+            for (ClassificationPage page : classificationDocument.getPages()) {
+                docuMineBlockificationService.mergeblocks(page, page.getCleanRulings().withoutTextRulings(), 0, 10);
+            }
+        }
+
         List<TextPageBlock> headlines = classificationDocument.getPages()
                 .stream()
                 .flatMap(classificationPage -> classificationPage.getTextBlocks()

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

@@ -11,7 +11,9 @@ 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.springframework.core.task.TaskExecutor;
 import org.springframework.stereotype.Service;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -39,6 +41,8 @@ public class LayoutParsingStorageService {
     private final StorageService storageService;
     private final ObjectMapper objectMapper;
 
+    private final TaskExecutor taskExecutor;
+
 
     @Observed(name = "LayoutParsingStorageService", contextualName = "get-origin-file")
     public File getOriginFile(String storageId) throws IOException {
@@ -100,13 +104,35 @@ public class LayoutParsingStorageService {
     }
 
 
+    @SneakyThrows
     @Observed(name = "LayoutParsingStorageService", contextualName = "store-document-data")
     public void storeDocumentData(LayoutParsingRequest layoutParsingRequest, DocumentData documentData) {
 
-        storageService.storeJSONObject(TenantContext.getTenantId(), layoutParsingRequest.structureFileStorageId(), documentData.getDocumentStructure());
-        storageService.storeJSONObject(TenantContext.getTenantId(), layoutParsingRequest.textBlockFileStorageId(), documentData.getDocumentTextData());
-        storageService.storeJSONObject(TenantContext.getTenantId(), layoutParsingRequest.positionBlockFileStorageId(), documentData.getDocumentPositions());
-        storageService.storeJSONObject(TenantContext.getTenantId(), layoutParsingRequest.pageFileStorageId(), documentData.getDocumentPages());
+        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();
     }
 
 

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

@@ -1,6 +1,7 @@
 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;
 
@@ -26,6 +27,7 @@ import lombok.RequiredArgsConstructor;
 @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;
@@ -35,13 +37,44 @@ public class DocstrumSegmentationService {
 
     public List<Zone> segmentPage(List<TextPositionSequence> textPositions, boolean xyOrder, CleanRulings usedRulings, LayoutDebugLayer visualizations) {
 
-        List<Zone> zones = new ArrayList<>();
-        zones.addAll(computeZones(textPositions, usedRulings, visualizations, TextDirection.ZERO));
-        zones.addAll(computeZones(textPositions, usedRulings, visualizations, TextDirection.QUARTER_CIRCLE));
-        zones.addAll(computeZones(textPositions, usedRulings, visualizations, TextDirection.HALF_CIRCLE));
-        zones.addAll(computeZones(textPositions, usedRulings, visualizations, TextDirection.THREE_QUARTER_CIRCLE));
+        EnumMap<TextDirection, Integer> directionCounts = new EnumMap<>(TextDirection.class);
 
-        return readingOrderService.resolve(zones, xyOrder);
+        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;
     }
 
 

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

@@ -15,10 +15,16 @@ public class AngleFilter {
 
     public boolean matches(Neighbor neighbor) {
 
+        return matches(neighbor.getAngle());
+    }
+
+
+    public boolean matches(double angle) {
+
         if (lowerAngle <= upperAngle) {
-            return lowerAngle <= neighbor.getAngle() && neighbor.getAngle() < upperAngle;
+            return lowerAngle <= angle && angle < upperAngle;
         } else {
-            return lowerAngle <= neighbor.getAngle() || neighbor.getAngle() < upperAngle;
+            return lowerAngle <= angle || angle < upperAngle;
         }
     }
 

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

@@ -7,8 +7,12 @@ 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.
@@ -19,7 +23,7 @@ public abstract class BoundingBox {
     // 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 bBoxInitialUserSpace;
+    protected Rectangle2D bBoxPdf;
 
     protected static final float VERTICAL_COMPARISON_THRESHOLD = 0.4f;
 
@@ -50,25 +54,25 @@ public abstract class BoundingBox {
 
     public double getPdfMinX() {
 
-        return bBoxInitialUserSpace.getMinX();
+        return bBoxPdf.getMinX();
     }
 
 
     public double getPdfMaxX() {
 
-        return bBoxInitialUserSpace.getMaxX();
+        return bBoxPdf.getMaxX();
     }
 
 
     public double getPdfMinY() {
 
-        return bBoxInitialUserSpace.getMinY();
+        return bBoxPdf.getMinY();
     }
 
 
     public double getPdfMaxY() {
 
-        return bBoxInitialUserSpace.getMaxY();
+        return bBoxPdf.getMaxY();
     }
 
 
@@ -129,13 +133,31 @@ public abstract class BoundingBox {
     }
 
 
-    public boolean intersectsY(BoundingBox other) {
+    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 intersectsYJava(BoundingBox other) {
+    public boolean intersectsY(BoundingBox other) {
 
         return this.getY() <= other.getMaxY() && this.getMaxY() >= other.getY();
     }
@@ -143,25 +165,31 @@ public abstract class BoundingBox {
 
     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 intersectsX(BoundingBox other) {
+    public boolean intersectsXPdf(BoundingBox other) {
 
         return this.getPdfMinX() <= other.getPdfMaxX() && this.getPdfMaxX() >= other.getPdfMinX();
     }
 
 
-    public boolean intersectsXJava(BoundingBox other) {
+    public boolean intersectsX(BoundingBox other) {
 
         return this.getX() <= other.getMaxX() && this.getMaxX() >= other.getMinX();
     }
 
 
-    public boolean intersectsX(BoundingBox other, float threshold) {
+    public boolean intersectsXPdf(BoundingBox other, float threshold) {
 
-        return this.getPdfMinX() - threshold <= other.getMaxX() && this.getMaxX() + threshold >= other.getPdfMinX();
+        return this.getPdfMinX() - threshold <= other.getPdfMaxX() && this.getMaxX() + threshold >= other.getPdfMinX();
     }
 
 
@@ -170,8 +198,8 @@ public abstract class BoundingBox {
         this.bBox = components.stream()
                 .map(BoundingBox::getBBox)
                 .collect(RectangleTransformations.collectBBox());
-        this.bBoxInitialUserSpace = components.stream()
-                .map(BoundingBox::getBBoxInitialUserSpace)
+        this.bBoxPdf = components.stream()
+                .map(BoundingBox::getBBoxPdf)
                 .collect(RectangleTransformations.collectBBox());
     }
 
@@ -229,25 +257,25 @@ public abstract class BoundingBox {
 
     public boolean rightOf(BoundingBox other) {
 
-        return this.intersectsYJava(other) && other.getMaxX() <= this.getMinX();
+        return this.intersectsY(other) && other.getMaxX() <= this.getMinX();
     }
 
 
     public boolean leftOf(BoundingBox other) {
 
-        return this.intersectsYJava(other) && other.getMinX() >= this.getMaxX();
+        return this.intersectsY(other) && other.getMinX() >= this.getMaxX();
     }
 
 
     public boolean isAbove(BoundingBox other) {
 
-        return this.intersectsXJava(other) && other.getMinY() >= this.getMaxY();
+        return this.intersectsX(other) && other.getMinY() >= this.getMaxY();
     }
 
 
     public boolean isBelow(BoundingBox other) {
 
-        return this.intersectsXJava(other) && this.getMinY() >= other.getMaxY();
+        return this.intersectsX(other) && this.getMinY() >= other.getMaxY();
     }
 
 }

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

@@ -35,7 +35,7 @@ public class Character {
 
     public double getHeight() {
 
-        return textPosition.getHeightDir();
+        return textPosition.getHeightDirAdj();
     }
 
 
@@ -65,9 +65,9 @@ public class Character {
         double s = Math.sin(-0);
         double c = Math.cos(-0);
         xs[0] = c * x - s * y;
-        xs[1] = c * (x + textPosition.getWidthDirAdj()) - s * (y + textPosition.getHeightDir());
+        xs[1] = c * (x + textPosition.getWidthDirAdj()) - s * (y + textPosition.getHeightDirAdj());
         xs[2] = c * other.x - s * other.y;
-        xs[3] = c * (other.x + other.textPosition.getWidthDirAdj()) - s * (other.y + other.textPosition.getHeightDir());
+        xs[3] = c * (other.x + other.textPosition.getWidthDirAdj()) - s * (other.y + other.textPosition.getHeightDirAdj());
         boolean overlapping = xs[1] >= xs[2] && xs[3] >= xs[0];
         Arrays.sort(xs);
         return Math.abs(xs[2] - xs[1]) * (overlapping ? 1 : -1);

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

@@ -1,18 +1,28 @@
 package com.knecon.fforesight.service.layoutparser.processor.docstrum.model;
 
+import static com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence.BOLD;
+import static com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence.BOLD_ITALIC;
+import static com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence.ITALIC;
+import static com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence.STANDARD;
+
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Comparator;
+import java.util.EnumMap;
 import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import com.knecon.fforesight.service.layoutparser.processor.docstrum.utils.FastAtan2;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.FontStyle;
 
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 
 @Data
-@EqualsAndHashCode(onlyExplicitlyIncluded = true)
-public class Line extends BoundingBox {
+@EqualsAndHashCode(onlyExplicitlyIncluded = true, callSuper = false)
+public class Line extends TextBoundingBox {
 
     private static final double WORD_DISTANCE_MULTIPLIER = 0.18;
 
@@ -28,6 +38,8 @@ public class Line extends BoundingBox {
 
     private final double height;
 
+    private FontStyle fontStyle;
+
     private final List<Character> characters;
     private final List<TextPositionSequence> words = new ArrayList<>();
 
@@ -67,6 +79,29 @@ public class Line extends BoundingBox {
         height = computeHeight();
         computeWords(wordSpacing * WORD_DISTANCE_MULTIPLIER);
         buildBBox();
+        computeFontStyle();
+    }
+
+
+    private void computeFontStyle() {
+
+        EnumMap<FontStyle, AtomicInteger> fontStyleCounter = new EnumMap<>(FontStyle.class);
+        for (FontStyle fontStyle : FontStyle.values()) {
+            fontStyleCounter.put(fontStyle, new AtomicInteger(0));
+        }
+        for (TextPositionSequence word : words) {
+            switch (word.getFontStyle()) {
+                case STANDARD -> fontStyleCounter.get(FontStyle.REGULAR).getAndIncrement();
+                case BOLD -> fontStyleCounter.get(FontStyle.BOLD).getAndIncrement();
+                case ITALIC -> fontStyleCounter.get(FontStyle.ITALIC).getAndIncrement();
+                case BOLD_ITALIC -> fontStyleCounter.get(FontStyle.BOLD_ITALIC).getAndIncrement();
+            }
+        }
+        fontStyle = fontStyleCounter.entrySet()
+                .stream()
+                .max(Comparator.comparing(entry -> entry.getValue().get()))
+                .map(Map.Entry::getKey)
+                .orElse(FontStyle.REGULAR);
     }
 
 
@@ -144,8 +179,8 @@ public class Line extends BoundingBox {
     private void buildBBox() {
 
         this.setToBBoxOfComponents(characters.stream()
-                                       .map(Character::getTextPosition)
-                                       .toList());
+                                           .map(Character::getTextPosition)
+                                           .toList());
     }
 
 

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

@@ -0,0 +1,102 @@
+package com.knecon.fforesight.service.layoutparser.processor.docstrum.model;
+
+import java.awt.geom.Rectangle2D;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import com.knecon.fforesight.service.layoutparser.processor.model.text.TextDirection;
+import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.experimental.SuperBuilder;
+
+@Getter
+@Setter
+@SuperBuilder
+@NoArgsConstructor
+@EqualsAndHashCode(callSuper = false)
+public abstract class TextBoundingBox extends BoundingBox {
+
+    protected Rectangle2D bBoxDirAdj;
+
+    protected TextDirection dir;
+
+
+    @Override
+    public void setToBBoxOfComponents(List<? extends BoundingBox> components) {
+
+        super.setToBBoxOfComponents(components);
+        this.bBoxDirAdj = components.stream()
+                .filter(c -> c instanceof TextBoundingBox)
+                .map(c -> (TextBoundingBox) c)
+                .map(TextBoundingBox::getBBoxDirAdj)
+                .collect(RectangleTransformations.collectBBox());
+
+        Set<TextDirection> textDirections = components.stream()
+                .filter(c -> c instanceof TextBoundingBox)
+                .map(c -> (TextBoundingBox) c)
+                .map(TextBoundingBox::getDir)
+                .collect(Collectors.toSet());
+
+        if (textDirections.isEmpty()) {
+            dir = TextDirection.ZERO;
+        } else if (textDirections.size() > 1) {
+            throw new IllegalArgumentException("More than one text direction found");
+        } else {
+            dir = textDirections.iterator().next();
+        }
+    }
+
+
+    public double getXDirAdj() {
+
+        return this.bBoxDirAdj.getX();
+    }
+
+
+    public double getYDirAdj() {
+
+        return this.bBoxDirAdj.getY();
+    }
+
+
+    public double getWidthDirAdj() {
+
+        return this.bBoxDirAdj.getWidth();
+    }
+
+
+    public double getHeightDirAdj() {
+
+        return this.bBoxDirAdj.getHeight();
+    }
+
+
+    public double getMaxXDirAdj() {
+
+        return this.bBoxDirAdj.getMaxX();
+    }
+
+
+    public double getMaxYDirAdj() {
+
+        return this.bBoxDirAdj.getMaxY();
+    }
+
+
+    public double getCenterYDirAdj() {
+
+        return this.bBoxDirAdj.getCenterY();
+    }
+
+
+    public double getCenterXDirAdj() {
+
+        return this.bBoxDirAdj.getCenterX();
+    }
+
+}

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

@@ -6,9 +6,11 @@ import java.util.List;
 import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
 
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 
 @Data
-public class Zone extends BoundingBox {
+@EqualsAndHashCode(callSuper = false)
+public class Zone extends TextBoundingBox {
 
     private List<Line> lines;
 

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

@@ -1,15 +1,17 @@
 package com.knecon.fforesight.service.layoutparser.processor.docstrum.service;
 
+import java.awt.geom.Rectangle2D;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 import org.springframework.stereotype.Service;
 
-import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.BoundingBox;
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.TextBoundingBox;
 import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.Zone;
 import com.knecon.fforesight.service.layoutparser.processor.docstrum.utils.DoubleUtils;
 
@@ -19,21 +21,30 @@ public class ReadingOrderService {
     private static final double THRESHOLD = 5;
     public static final double MULTI_COLUMN_DETECTION_THRESHOLD = 1.5;
 
+    private static final Comparator<TextBoundingBox> COMPARATOR = //
+            Comparator.comparing(TextBoundingBox::getY, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD))
+                    .thenComparing(TextBoundingBox::getX, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD));
 
-    public List<Zone> resolve(List<Zone> zones, boolean xyReadingOrder) {
+    private static final Comparator<TextBoundingBox> COMPARATOR_DIR_ADJ = //
+            Comparator.comparing(TextBoundingBox::getYDirAdj, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD))
+                    .thenComparing(TextBoundingBox::getXDirAdj, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD));
+
+
+    public List<Zone> resolve(List<Zone> zones, boolean xyReadingOrder, boolean useDirAdjCoords) {
 
         if (zones.isEmpty() || zones.size() == 1) {
             return zones;
         }
 
         if (xyReadingOrder) {
-            return resolveSingleColumnReadingOrder(zones);
+            return resolveSingleColumnReadingOrder(zones, useDirAdjCoords);
         }
 
         Map<Long, Integer> histogram = new HashMap<>();
         for (Zone zone : zones) {
-            long minY = Math.round(zone.getBBox().getMinY());
-            long maxY = Math.round(zone.getBBox().getMaxY());
+            Rectangle2D bbox = useDirAdjCoords ? zone.getBBoxDirAdj() : zone.getBBox();
+            long minY = Math.round(bbox.getMinY());
+            long maxY = Math.round(bbox.getMaxY());
             for (long i = minY; i <= maxY; i++) {
                 histogram.put(i, histogram.getOrDefault(i, 0) + 1);
             }
@@ -43,24 +54,32 @@ public class ReadingOrderService {
                     .stream()
                     .mapToInt(Integer::intValue).average()
                     .orElse(1) < MULTI_COLUMN_DETECTION_THRESHOLD) {
-            return resolveSingleColumnReadingOrder(zones);
+            return resolveSingleColumnReadingOrder(zones, useDirAdjCoords);
         } else {
 
-            return resolveMultiColumnReadingOder(zones);
+            return resolveMultiColumnReadingOder(zones, useDirAdjCoords);
         }
 
     }
 
 
-    private static List<Zone> resolveSingleColumnReadingOrder(List<Zone> zones) {
+    private static List<Zone> resolveSingleColumnReadingOrder(List<Zone> zones, boolean useDirAdjCoords) {
 
-        zones.sort(Comparator.comparing(BoundingBox::getY, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD))
-                           .thenComparing(BoundingBox::getX, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD)));
+        if (useDirAdjCoords) {
+            return zones.stream()
+                    .collect(Collectors.groupingBy(TextBoundingBox::getDir)).values()
+                    .stream()
+                    .flatMap(words -> words.stream()
+                            .sorted(COMPARATOR_DIR_ADJ))
+                    .toList();
+        }
+
+        zones.sort(COMPARATOR);
         return zones;
     }
 
 
-    private List<Zone> resolveMultiColumnReadingOder(List<Zone> zones) {
+    private List<Zone> resolveMultiColumnReadingOder(List<Zone> zones, boolean useDirAdjCoords) {
 
         // Simple reading order resolver for multi column page layout as described here : https://pub.towardsai.net/advanced-rag-02-unveiling-pdf-parsing-b84ae866344e
         // TODO implement a more fancy reading order resolver see https://github.com/BobLd/DocumentLayoutAnalysis/blob/master/README.md#reading-order
@@ -69,11 +88,12 @@ public class ReadingOrderService {
         double maxX = Double.NEGATIVE_INFINITY;
 
         for (Zone zone : zones) {
-            if (zone.getX() < minX) {
-                minX = zone.getX();
+            Rectangle2D bbox = useDirAdjCoords ? zone.getBBoxDirAdj() : zone.getBBox();
+            if (bbox.getX() < minX) {
+                minX = zone.getXDirAdj();
             }
-            if (zone.getX() + zone.getWidth() > maxX) {
-                maxX = zone.getX() + zone.getWidth();
+            if (bbox.getMaxX() > maxX) {
+                maxX = zone.getMaxXDirAdj();
             }
         }
 
@@ -82,24 +102,27 @@ public class ReadingOrderService {
         List<Zone> leftOf = new ArrayList<>();
         List<Zone> rightOf = new ArrayList<>();
         List<Zone> middle = new ArrayList<>();
+
         for (Zone zone : zones) {
-            if (zone.getX() < midLineXCoordinate && zone.getX() + zone.getWidth() < midLineXCoordinate) {
+            Rectangle2D bbox = useDirAdjCoords ? zone.getBBoxDirAdj() : zone.getBBox();
+            if (bbox.getX() < midLineXCoordinate && bbox.getX() + bbox.getWidth() < midLineXCoordinate) {
                 leftOf.add(zone);
-            } else if (zone.getX() > midLineXCoordinate && zone.getX() + zone.getWidth() > midLineXCoordinate) {
+            } else if (bbox.getX() > midLineXCoordinate && bbox.getX() + bbox.getWidth() > midLineXCoordinate) {
                 rightOf.add(zone);
             } else {
                 middle.add(zone);
             }
         }
 
-        leftOf.sort(Comparator.comparing(BoundingBox::getY, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD))
-                            .thenComparing(BoundingBox::getX, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD)));
-
-        rightOf.sort(Comparator.comparing(BoundingBox::getY, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD))
-                             .thenComparing(BoundingBox::getX, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD)));
-
-        middle.sort(Comparator.comparing(BoundingBox::getY, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD))
-                            .thenComparing(BoundingBox::getX, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD)));
+        if (useDirAdjCoords) {
+            leftOf.sort(COMPARATOR_DIR_ADJ);
+            rightOf.sort(COMPARATOR_DIR_ADJ);
+            middle.sort(COMPARATOR_DIR_ADJ);
+        } else {
+            leftOf.sort(COMPARATOR);
+            rightOf.sort(COMPARATOR);
+            middle.sort(COMPARATOR);
+        }
 /*
         List<Zone> leftNotIntersecting = new ArrayList<>();
         for (Zone leftZone : leftOf) {
@@ -151,8 +174,9 @@ public class ReadingOrderService {
 
         while (itty.hasNext()) {
             Zone current = itty.next();
+            Rectangle2D bbox = useDirAdjCoords ? current.getBBoxDirAdj() : current.getBBox();
             for (int i = 0; i < sortedZones.size(); i++) {
-                if (current.getY() < sortedZones.get(i).getY()) {
+                if (bbox.getY() < sortedZones.get(i).getY()) {
                     sortedZones.add(i, current);
                     itty.remove();
                     break;

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

@@ -1,5 +1,7 @@
 package com.knecon.fforesight.service.layoutparser.processor.docstrum.service;
 
+import static com.knecon.fforesight.service.layoutparser.processor.model.SectionIdentifier.numericalIdentifierPattern;
+
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashSet;
@@ -21,7 +23,7 @@ public class ZoneBuilderService {
     private static final double MIN_HORIZONTAL_DISTANCE_MULTIPLIER = -0.5;
     private static final double MAX_VERTICAL_DISTANCE_MULTIPLIER = 1.2;
 
-    private static final double MIN_HORIZONTAL_MERGE_DISTANCE_MULTIPLIER = -3.0;
+    private static final double MIN_HORIZONTAL_MERGE_DISTANCE_MULTIPLIER = -7;
 
     private static final double MAX_VERTICAL_MERGE_DISTANCE_MULTIPLIER = 0.5;
 
@@ -38,7 +40,7 @@ public class ZoneBuilderService {
 
         double minHorizontalDistance = characterSpacing * MIN_HORIZONTAL_DISTANCE_MULTIPLIER;
         double maxVerticalDistance = lineSpacing * MAX_VERTICAL_DISTANCE_MULTIPLIER;
-        double minHorizontalMergeDistance = characterSpacing * MIN_HORIZONTAL_MERGE_DISTANCE_MULTIPLIER;
+        double minHorizontalMergeDistance = lineSpacing * MIN_HORIZONTAL_MERGE_DISTANCE_MULTIPLIER;
         double maxVerticalMergeDistance = lineSpacing * MAX_VERTICAL_MERGE_DISTANCE_MULTIPLIER;
 
         UnionFind<Line> unionFind = new UnionFind<>(new HashSet<>(lines));
@@ -54,11 +56,26 @@ public class ZoneBuilderService {
                     return;
                 }
 
-                double scale = Math.min(outerLine.getHeight(), innerLine.getHeight()) / meanHeight;
-                scale = Math.max(MIN_LINE_SIZE_SCALE, Math.min(scale, MAX_LINE_SIZE_SCALE));
+//                if (!innerLine.getFontStyle().equals(outerLine.getFontStyle()) //
+//                    && !outerLine.intersectsY(innerLine, -2f)) {
+//                    return;
+//                }
 
-                double horizontalDistance = outerLine.horizontalDistance(innerLine) / scale;
-                double verticalDistance = outerLine.verticalDistance(innerLine) / scale;
+                double horizontalScale = Math.min(outerLine.getHeightDirAdj(), innerLine.getHeightDirAdj()) / meanHeight;
+                horizontalScale = Math.max(MIN_LINE_SIZE_SCALE, Math.min(horizontalScale, MAX_LINE_SIZE_SCALE));
+                double verticalScale = horizontalScale;
+
+//                if (innerLine.toString().endsWith(":")
+//                    || outerLine.toString().endsWith(":")
+//                    || numericalIdentifierPattern.matcher(innerLine.toString()).matches()
+//                    || numericalIdentifierPattern.matcher(outerLine.toString()).matches()) {
+//
+//                    horizontalScale *= 5;
+//                    verticalScale /= 10;
+//                }
+
+                double horizontalDistance = outerLine.horizontalDistance(innerLine) / horizontalScale;
+                double verticalDistance = outerLine.verticalDistance(innerLine) / verticalScale;
 
                 if ((!(minHorizontalDistance <= horizontalDistance) || !(verticalDistance <= maxVerticalDistance)) //
                     && (!(minHorizontalMergeDistance <= horizontalDistance) || !(verticalDistance <= maxVerticalMergeDistance))) {
@@ -87,7 +104,7 @@ public class ZoneBuilderService {
         double weights = 0.0;
         for (Line line : lines) {
             double weight = line.getLength();
-            meanHeight += line.getHeight() * weight;
+            meanHeight += line.getHeightDirAdj() * weight;
             weights += weight;
         }
         meanHeight /= weights;

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

@@ -7,9 +7,12 @@ public class DoubleUtils {
         if (Double.isNaN(d1) || Double.isNaN(d2)) {
             return Double.compare(d1, d2);
         }
-        long i1 = Math.round(d1 / (precision == 0 ? 1 : precision));
-        long i2 = Math.round(d2 / (precision == 0 ? 1 : precision));
-        return Long.compare(i1, i2);
+
+        if (Math.abs(d1 - d2) < precision) {
+            return 0;
+        }
+
+        return Double.compare(d1, d2);
     }
 
 }

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

@@ -4,7 +4,7 @@ import java.util.HashSet;
 import java.util.Set;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.LayoutEngine;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.LayoutEngineProto.LayoutEngine;
 import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.BoundingBox;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
 

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

@@ -18,6 +18,7 @@ import lombok.RequiredArgsConstructor;
 
 @Data
 @RequiredArgsConstructor
+
 public class ClassificationPage {
 
     @NonNull
@@ -25,7 +26,7 @@ public class ClassificationPage {
 
     private List<OutlineObject> outlineObjects = new ArrayList<>();
 
-    private List<AbstractPageBlock> headlines  = new ArrayList<>();
+    private List<AbstractPageBlock> headlines = new ArrayList<>();
 
     private List<ClassifiedImage> images = new ArrayList<>();
 
@@ -44,7 +45,7 @@ public class ClassificationPage {
     private float pageWidth;
     private float pageHeight;
 
-    CleanRulings cleanRulings;
+    private CleanRulings cleanRulings;
 
     private Map<String, List<Rectangle2D>> markedContentBboxPerType = new HashMap<>();
 

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

@@ -1,6 +1,5 @@
 package com.knecon.fforesight.service.layoutparser.processor.model;
 
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -12,10 +11,14 @@ import lombok.Getter;
 @Getter
 public class FloatFrequencyCounter {
 
-    Map<Float, Integer> countPerValue = new HashMap<>();
+    Map<Double, Integer> countPerValue = new HashMap<>();
+    boolean changed;
+    Double mostPopularCache;
 
 
-    public void add(float value) {
+    public void add(double value) {
+
+        changed = true;
 
         if (!countPerValue.containsKey(value)) {
             countPerValue.put(value, 1);
@@ -25,9 +28,11 @@ public class FloatFrequencyCounter {
     }
 
 
-    public void addAll(Map<Float, Integer> otherCounter) {
+    public void addAll(Map<Double, Integer> otherCounter) {
 
-        for (Map.Entry<Float, Integer> entry : otherCounter.entrySet()) {
+        changed = true;
+
+        for (Map.Entry<Double, Integer> entry : otherCounter.entrySet()) {
             if (countPerValue.containsKey(entry.getKey())) {
                 countPerValue.put(entry.getKey(), countPerValue.get(entry.getKey()) + entry.getValue());
             } else {
@@ -37,36 +42,36 @@ public class FloatFrequencyCounter {
     }
 
 
-    public Float getMostPopular() {
+    public Double getMostPopular() {
 
-        Map.Entry<Float, Integer> mostPopular = null;
-        for (Map.Entry<Float, Integer> entry : countPerValue.entrySet()) {
-            if (mostPopular == null || entry.getValue() >= mostPopular.getValue()) {
-                mostPopular = entry;
+        if (changed) {
+            Map.Entry<Double, Integer> mostPopular = null;
+            for (Map.Entry<Double, Integer> entry : countPerValue.entrySet()) {
+                if (mostPopular == null || entry.getValue() >= mostPopular.getValue()) {
+                    mostPopular = entry;
+                }
             }
+            mostPopularCache = mostPopular != null ? mostPopular.getKey() : null;
+            changed = false;
         }
-        return mostPopular != null ? mostPopular.getKey() : null;
+
+        return mostPopularCache;
     }
 
 
-    public List<Float> getHighterThanMostPopular() {
+    public List<Double> getValuesInReverseOrder() {
 
-        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());
+        return countPerValue.keySet()
+                .stream()
+                .sorted(Collections.reverseOrder())
+                .collect(Collectors.toList());
     }
 
 
-    public Float getHighest() {
+    public Double getHighest() {
 
-        Float highest = null;
-        for (Float value : countPerValue.keySet()) {
+        Double highest = null;
+        for (Double value : countPerValue.keySet()) {
             if (highest == null || value > highest) {
                 highest = value;
             }

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

@@ -3,6 +3,7 @@ package com.knecon.fforesight.service.layoutparser.processor.model;
 import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Locale;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -15,11 +16,13 @@ import lombok.experimental.FieldDefaults;
 @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
 public class SectionIdentifier {
 
-    static Pattern numericalIdentifierPattern = Pattern.compile("^[\\s]?(\\d+)[\\s.,;]?(\\d+)?[\\s.,;]?(\\d+)?[\\s.,;]?(\\d+)?");
+    public static Pattern numericalIdentifierPattern = Pattern.compile("^[\\s]?(\\d+)[\\s.,;]?(\\d+)?[\\s.,;]?(\\d+)?[\\s.,;]?(\\d+)?");
+    public static Pattern alphanumericIdentifierPattern = Pattern.compile("^[\\s]?[A-Za-z][\\s.,;]?(\\d+)[\\s.,;]?(\\d+)?[\\s.,;]?(\\d+)?[\\s.,;]?(\\d+)?[\\s.,;]?");
 
     public enum Format {
         EMPTY,
         NUMERICAL,
+        ALPHANUMERIC,
         DOCUMENT
     }
 
@@ -41,6 +44,10 @@ public class SectionIdentifier {
         if (numericalIdentifierMatcher.find()) {
             return buildNumericalSectionIdentifier(headline, numericalIdentifierMatcher);
         }
+        Matcher alphanumericIdentifierMatcher = alphanumericIdentifierPattern.matcher(headline);
+        if (alphanumericIdentifierMatcher.find()) {
+            return buildAlphanumericSectionIdentifier(headline, alphanumericIdentifierMatcher);
+        }
         // more formats here
         return SectionIdentifier.empty();
     }
@@ -75,7 +82,36 @@ public class SectionIdentifier {
             }
             identifiers.add(Integer.parseInt(numericalIdentifier.trim()));
         }
-        return new SectionIdentifier(Format.NUMERICAL, identifierString, identifiers.stream().toList(), false);
+        return new SectionIdentifier(Format.NUMERICAL,
+                                     identifierString,
+                                     identifiers.stream()
+                                             .toList(),
+                                     false);
+    }
+
+
+    private static SectionIdentifier buildAlphanumericSectionIdentifier(String headline, Matcher alphanumericIdentifierMatcher) {
+
+        String identifierString = headline.substring(alphanumericIdentifierMatcher.start(), alphanumericIdentifierMatcher.end());
+
+        String alphanumericIdentifier = alphanumericIdentifierMatcher.group(0).substring(0, 1).toUpperCase(Locale.ENGLISH);
+        int mappedCharacterValue = alphanumericIdentifier.charAt(0) - 'A' + 1;
+        List<Integer> identifiers = new LinkedList<>();
+        identifiers.add(mappedCharacterValue);
+
+        for (int i = 1; i <= 3; i++) {
+            String numericalIdentifier = alphanumericIdentifierMatcher.group(i);
+            if (numericalIdentifier == null || numericalIdentifier.equals("0") || numericalIdentifier.isEmpty() || numericalIdentifier.isBlank()) {
+                break;
+            }
+            identifiers.add(Integer.parseInt(numericalIdentifier.trim()));
+        }
+
+        return new SectionIdentifier(Format.ALPHANUMERIC,
+                                     identifierString,
+                                     identifiers.stream()
+                                             .toList(),
+                                     false);
     }
 
 
@@ -123,4 +159,22 @@ public class SectionIdentifier {
         return identifierString;
     }
 
+
+    public boolean isEmpty() {
+
+        return this.format.equals(Format.EMPTY);
+    }
+
+
+    public int level() {
+
+        return identifiers.size();
+    }
+
+
+    protected List<Integer> getIdentifiers() {
+
+        return identifiers;
+    }
+
 }

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

@@ -84,7 +84,7 @@ public abstract class AbstractNodeVisitor implements NodeVisitor {
     }
 
 
-    private void visitChildren(SemanticNode semanticNode) {
+    protected void visitChildren(SemanticNode semanticNode) {
 
         semanticNode.streamChildren()
                 .forEach(node -> node.accept(this));

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

@@ -8,7 +8,7 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.stream.Stream;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeTypeProto.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Document;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.GenericSemanticNode;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.SemanticNode;

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

@@ -6,7 +6,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.LayoutEngine;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.LayoutEngineProto.LayoutEngine;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.DocumentTree;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.entity.TextEntity;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;

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

@@ -9,7 +9,7 @@ import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeTypeProto.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.DocumentTree;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;

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

@@ -25,11 +25,4 @@ public class DuplicatedParagraph extends Paragraph {
 
     }
 
-
-    @Override
-    public String toString() {
-
-        return super.toString();
-    }
-
 }

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

@@ -1,6 +1,6 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeTypeProto.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;
 

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

@@ -1,6 +1,6 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeTypeProto.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;
 

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

@@ -1,6 +1,6 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeTypeProto.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;
 

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

@@ -6,7 +6,7 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeTypeProto.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;
 

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

@@ -1,12 +1,15 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes;
 
+import java.util.Comparator;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;
+import java.util.stream.Stream;
 
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.entity.TextEntity;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.AtomicTextBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlockCollector;
 
@@ -29,9 +32,8 @@ public class Page {
     Integer height;
     Integer width;
     Integer rotation;
-
     @EqualsAndHashCode.Exclude
-    List<SemanticNode> mainBody;
+    List<AtomicTextBlock> textBlocksOnPage;
     @EqualsAndHashCode.Exclude
     Header header;
     @EqualsAndHashCode.Exclude
@@ -53,20 +55,44 @@ public class Page {
                 .width((int) classificationPage.getPageWidth())
                 .number(classificationPage.getPageNumber())
                 .rotation(classificationPage.getRotation())
-                .mainBody(new LinkedList<>())
+                .textBlocksOnPage(new LinkedList<>())
                 .build();
     }
 
 
+    /**
+     * Constructs and returns a {@link TextBlock} representing the concatenated text of all leaf semantic nodes in the main body.
+     *
+     * @return The main body text block.
+     */
     public TextBlock getMainBodyTextBlock() {
 
-        return mainBody.stream()
-                .filter(SemanticNode::isLeaf)
-                .map(SemanticNode::getLeafTextBlock)
+        return textBlocksOnPage.stream()
+                .filter(atb -> !atb.isEmpty())
                 .collect(new TextBlockCollector());
     }
 
 
+    public List<SemanticNode> getMainBody() {
+
+        return textBlocksOnPage.stream()
+                .map(AtomicTextBlock::getParent)
+                .map(this::getHighestParentOnPage)
+                .distinct()
+                .toList();
+    }
+
+
+    private SemanticNode getHighestParentOnPage(SemanticNode node) {
+
+        SemanticNode currentNode = node;
+        while (currentNode.hasParent() && currentNode.getParent().onlyOnPage(this)) {
+            currentNode = currentNode.getParent();
+        }
+        return currentNode;
+    }
+
+
     @Override
     public String toString() {
 

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

@@ -1,6 +1,6 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeTypeProto.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;
 

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

@@ -1,6 +1,7 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeTypeProto.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.NodeVisitor;
 
 import lombok.AccessLevel;

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

@@ -12,8 +12,8 @@ import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.LayoutEngine;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.LayoutEngineProto.LayoutEngine;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeTypeProto.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.DocumentTree;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.TextRange;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.entity.EntityType;
@@ -74,7 +74,8 @@ public interface SemanticNode {
 
         return getTextBlock().getPages()
                 .stream()
-                .min(Comparator.comparingInt(Page::getNumber)).orElseThrow(() -> new IllegalStateException("SemanticNode has no Page!"));
+                .min(Comparator.comparingInt(Page::getNumber))
+                .orElseThrow(() -> new IllegalStateException("SemanticNode has no Page!"));
     }
 
 
@@ -504,4 +505,17 @@ public interface SemanticNode {
 
     void accept(NodeVisitor visitor);
 
+
+    /**
+     * Checks wether this SemanticNode appears on a single page only, and if that page is the provided one.
+     *
+     * @param page the page to check
+     * @return true, when SemanticNode is on a single page only and the page is the provided page. Otherwise, false.
+     */
+    default boolean onlyOnPage(Page page) {
+
+        Set<Page> pages = getPages();
+        return pages.size() == 1 && pages.contains(page);
+    }
+
 }

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

@@ -1,6 +1,6 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeTypeProto.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.NodeVisitor;
 
 import lombok.AccessLevel;

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

@@ -12,8 +12,8 @@ import java.util.Set;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.LayoutEngine;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.LayoutEngineProto.LayoutEngine;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeTypeProto.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.DocumentTree;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.entity.TextEntity;

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

@@ -4,7 +4,7 @@ import java.awt.geom.Rectangle2D;
 import java.util.HashMap;
 import java.util.Map;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeTypeProto.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlockCollector;

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

@@ -1,5 +1,6 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock;
 
+import static com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentTextDataProto.DocumentTextData;
 import static java.lang.String.format;
 
 import java.awt.geom.Rectangle2D;
@@ -13,8 +14,8 @@ import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentPositionData;
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentTextData;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentPositionDataProto.DocumentPositionData;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.DocumentPositionDataProto.DocumentPositionData.Position;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.TextRange;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Page;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.SemanticNode;
@@ -145,10 +146,7 @@ public class AtomicTextBlock implements TextBlock {
     }
 
 
-    public static AtomicTextBlock fromAtomicTextBlockData(DocumentTextData documentTextData,
-                                                          DocumentPositionData documentPositionData,
-                                                          SemanticNode parent,
-                                                          Page page) {
+    public static AtomicTextBlock fromAtomicTextBlockData(DocumentTextData documentTextData, DocumentPositionData documentPositionData, SemanticNode parent, Page page) {
 
         return AtomicTextBlock.builder()
                 .id(documentTextData.getId())
@@ -156,9 +154,9 @@ public class AtomicTextBlock implements TextBlock {
                 .page(page)
                 .textRange(new TextRange(documentTextData.getStart(), documentTextData.getEnd()))
                 .searchText(documentTextData.getSearchText())
-                .lineBreaks(Arrays.stream(documentTextData.getLineBreaks()).boxed().toList())
-                .stringIdxToPositionIdx(Arrays.stream(documentPositionData.getStringIdxToPositionIdx()).boxed().toList())
-                .positions(toRectangle2DList(documentPositionData.getPositions()))
+                .lineBreaks(documentTextData.getLineBreaksList())
+                .stringIdxToPositionIdx(documentPositionData.getStringIdxToPositionIdxList())
+                .positions(toRectangle2DList(documentPositionData.getPositionsList()))
                 .parent(parent)
                 .build();
     }
@@ -166,7 +164,17 @@ public class AtomicTextBlock implements TextBlock {
 
     private static List<Rectangle2D> toRectangle2DList(float[][] positions) {
 
-        return Arrays.stream(positions).map(floatArr -> (Rectangle2D) new Rectangle2D.Float(floatArr[0], floatArr[1], floatArr[2], floatArr[3])).toList();
+        return Arrays.stream(positions)
+                .map(floatArr -> (Rectangle2D) new Rectangle2D.Float(floatArr[0], floatArr[1], floatArr[2], floatArr[3]))
+                .toList();
+    }
+
+
+    private static List<Rectangle2D> toRectangle2DList(List<Position> positions) {
+
+        return positions.stream()
+                .map(pos -> (Rectangle2D) new Rectangle2D.Float(pos.getValue(0), pos.getValue(1), pos.getValue(2), pos.getValue(3)))
+                .toList();
     }
 
 
@@ -176,6 +184,9 @@ public class AtomicTextBlock implements TextBlock {
             throw new IndexOutOfBoundsException(format("line %d out of range for AtomicTextBlock with %d lines", lineNumber, numberOfLines()));
         }
         if (lineNumber == 0) {
+            if (lineBreaks.isEmpty()) {
+                return searchText;
+            }
             return subSequence(textRange.start(), lineBreaks.get(0) + textRange.start());
         } else if (lineNumber == numberOfLines() - 1) {
             return subSequence(lineBreaks.get(lineBreaks.size() - 1) + textRange.start(), textRange.end());
@@ -195,9 +206,9 @@ public class AtomicTextBlock implements TextBlock {
     public int getNextLinebreak(int fromIndex) {
 
         return lineBreaks.stream()//
-                .filter(linebreak -> linebreak > fromIndex - textRange.start()) //
-                .findFirst() //
-                .orElse(searchText.length()) + textRange.start();
+                       .filter(linebreak -> linebreak > fromIndex - textRange.start()) //
+                       .findFirst() //
+                       .orElse(searchText.length()) + textRange.start();
     }
 
 
@@ -205,9 +216,9 @@ public class AtomicTextBlock implements TextBlock {
     public int getPreviousLinebreak(int fromIndex) {
 
         return lineBreaks.stream()//
-                .filter(linebreak -> linebreak <= fromIndex - textRange.start())//
-                .reduce((a, b) -> b)//
-                .orElse(0) + textRange.start();
+                       .filter(linebreak -> linebreak <= fromIndex - textRange.start())//
+                       .reduce((a, b) -> b)//
+                       .orElse(0) + textRange.start();
     }
 
 
@@ -255,7 +266,10 @@ public class AtomicTextBlock implements TextBlock {
 
     protected List<Integer> getAllLineBreaksInBoundary(TextRange textRange) {
 
-        return getLineBreaks().stream().map(linebreak -> linebreak + this.textRange.start()).filter(textRange::contains).toList();
+        return getLineBreaks().stream()
+                .map(linebreak -> linebreak + this.textRange.start())
+                .filter(textRange::contains)
+                .toList();
     }
 
 

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

@@ -10,8 +10,8 @@ import lombok.NonNull;
 import lombok.RequiredArgsConstructor;
 
 @Data
-@RequiredArgsConstructor
 @AllArgsConstructor
+@RequiredArgsConstructor
 public class ClassifiedImage {
 
     @NonNull
@@ -20,11 +20,18 @@ public class ClassifiedImage {
     private ImageType imageType;
     private boolean sourceByAi;
     private boolean isAppendedToSection;
-    @NonNull
     private boolean hasTransparency;
-    @NonNull
     private int page;
-    @NonNull
     private String representation;
 
+
+    public ClassifiedImage(@NonNull Rectangle2D position, @NonNull ImageType imageType, boolean hasTransparency, int page, String representation) {
+
+        this.position = position;
+        this.imageType = imageType;
+        this.hasTransparency = hasTransparency;
+        this.page = page;
+        this.representation = representation;
+    }
+
 }

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

@@ -1,5 +1,6 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.outline;
 
+import java.awt.geom.AffineTransform;
 import java.awt.geom.Point2D;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -26,6 +27,9 @@ import org.apache.pdfbox.pdmodel.interactive.documentnavigation.outline.PDDocume
 import org.apache.pdfbox.pdmodel.interactive.documentnavigation.outline.PDOutlineItem;
 import org.springframework.stereotype.Service;
 
+import com.knecon.fforesight.service.layoutparser.processor.utils.CoordinateTransforms;
+import com.knecon.fforesight.service.layoutparser.processor.utils.PageInformation;
+
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 
@@ -89,12 +93,13 @@ public class OutlineExtractorService {
             if (page == null) {
                 return Optional.empty();
             }
-        }catch (IOException e){
+        } catch (IOException e) {
             log.info(String.format("Error occurred during position resolution for outline item with title %s: " + e, title));
             return Optional.empty();
         }
 
-        int pageNumber = document.getPages().indexOf(page);
+        int pageNumber = document.getPages().indexOf(page) + 1;
+        AffineTransform userSpaceToPageCoords = CoordinateTransforms.calculateInitialUserSpaceCoordsToPageCoords(PageInformation.fromPDPage(pageNumber, page));
 
         Optional<Point2D> outlinePosition = Optional.empty();
 
@@ -123,8 +128,15 @@ public class OutlineExtractorService {
             log.info(String.format("Error occurred during position resolution for outline item on page %s with title %s: " + e, pageNumber, title));
         }
 
-        return Optional.of(new OutlineObjectTreeNode(new OutlineObject(title, pageNumber, outlinePosition.orElse(new Point2D.Float(0, 0)), depth)));
+        return Optional.of(new OutlineObjectTreeNode(new OutlineObject(title,
+                                                                       pageNumber,
+                                                                       transformPointToPageCoords(outlinePosition, userSpaceToPageCoords), depth)));
+    }
 
+
+    private static Point2D transformPointToPageCoords(Optional<Point2D> outlinePosition, AffineTransform userSpaceToPageCoords) {
+
+        return outlinePosition.map(point -> userSpaceToPageCoords.transform(point, null)).orElse(null);
     }
 
 

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

@@ -1,27 +1,34 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.outline;
 
 import java.awt.geom.Point2D;
+import java.util.Optional;
 
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.RequiredArgsConstructor;
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.BoundingBox;
+
+import lombok.Getter;
+import lombok.Setter;
 
-@Data
-@RequiredArgsConstructor
-@AllArgsConstructor
 public class OutlineObject {
 
+    @Getter
     private final String title;
+    @Getter
     private final int pageNumber;
-    private Point2D point;
+    @Getter
     private final int treeDepth;
 
+    private Point2D point; // java coordinates, (0, 0) is always top left
+
+    @Getter
+    @Setter
     private boolean found;
 
 
     public OutlineObject(String title, int pageNumber, Point2D point2D, int depth) {
 
-        this(title, pageNumber, depth);
+        this.title = title;
+        this.pageNumber = pageNumber;
+        this.treeDepth = depth;
         this.point = point2D;
     }
 
@@ -32,4 +39,39 @@ public class OutlineObject {
         return "OutlineObject{" + "title='" + title + '\'' + '}';
     }
 
+
+    public Optional<Point2D> getPoint() {
+
+        return Optional.ofNullable(point);
+    }
+
+
+    public boolean isAbove(BoundingBox boundingBox) {
+
+        if (point == null) {
+            return true;
+        }
+        return point.getY() <= boundingBox.getMaxY();
+    }
+
+
+    public double distance(BoundingBox boundingBox) {
+
+        if (point == null) {
+            return 0;
+        }
+        if (boundingBox.getBBox().contains(point)) {
+            return 0;
+        }
+        double deltaX = Math.min(Math.abs(boundingBox.getMinX() - point.getX()), Math.abs(boundingBox.getMaxX() - point.getX()));
+        double deltaY = Math.min(Math.abs(boundingBox.getMinY() - point.getY()), Math.abs(boundingBox.getMaxY() - point.getY()));
+        return Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+    }
+
+
+    public void resetPoint() {
+
+        this.point = null;
+    }
+
 }

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

@@ -39,4 +39,28 @@ public class OutlineObjectTree {
         }
     }
 
+    @Override
+    public String toString() {
+
+        StringBuilder sb = new StringBuilder();
+        sb.append("OutlineObjectTree(\n");
+        for (OutlineObjectTreeNode node : rootNodes) {
+            buildString(node, sb, 1);
+        }
+        sb.append(")");
+        return sb.toString();
+    }
+
+    private void buildString(OutlineObjectTreeNode node, StringBuilder sb, int depth) {
+
+        for (int i = 0; i < depth; i++) {
+            sb.append("  ");
+        }
+        sb.append(node.getOutlineObject().getTitle()).append("\n");
+
+        for (OutlineObjectTreeNode child : node.getChildren()) {
+            buildString(child, sb, depth + 1);
+        }
+    }
+
 }

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

@@ -1,6 +1,7 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.outline;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
@@ -167,7 +168,7 @@ public class TOCEnrichmentService {
             }
         }
 
-        if (!startBlocks.isEmpty()) {
+        if (!startBlocks.isEmpty() || !startImages.isEmpty()) {
             TableOfContentItem unassigned = new TableOfContentItem(null);
             unassigned.setSectionBlocks(startBlocks);
             unassigned.setImages(startImages);
@@ -185,12 +186,8 @@ public class TOCEnrichmentService {
             List<Cell> previousTableNonHeaderRow = getRowWithNonHeaderCells(previousTable);
             List<Cell> tableNonHeaderRow = getRowWithNonHeaderCells(currentTable);
             // Allow merging of tables if header row is separated from first logical non-header row
-            if (previousTableNonHeaderRow.isEmpty()
-                && previousTable.getRowCount() == 1
-                && previousTable.getRows()
-                           .get(0).size() == tableNonHeaderRow.size()) {
-                previousTableNonHeaderRow = previousTable.getRows()
-                        .get(0)
+            if (previousTableNonHeaderRow.isEmpty() && previousTable.getRowCount() == 1 && previousTable.getRows().get(0).size() == tableNonHeaderRow.size()) {
+                previousTableNonHeaderRow = previousTable.getRows().get(0)
                         .stream()
                         .map(cell -> {
                             Cell fakeCell = Cell.copy(cell);
@@ -201,8 +198,7 @@ public class TOCEnrichmentService {
             }
             if (previousTableNonHeaderRow.size() == tableNonHeaderRow.size()) {
                 for (int i = currentTable.getRowCount() - 1; i >= 0; i--) { // Non header rows are most likely at bottom of table
-                    List<Cell> row = currentTable.getRows()
-                            .get(i);
+                    List<Cell> row = currentTable.getRows().get(i);
                     if (row.size() == tableNonHeaderRow.size() && row.stream()
                             .allMatch(cell -> cell.getHeaderCells().isEmpty())) {
                         for (int j = 0; j < row.size(); j++) {
@@ -225,18 +221,15 @@ public class TOCEnrichmentService {
 
         return table.getRows()
                 .stream()
-                .flatMap(row -> row.stream()
-                        .filter(cell -> !cell.getHeaderCells().isEmpty()))
-                .findAny().isEmpty();
-
+                .flatMap(Collection::stream)
+                .allMatch(cell -> cell.getHeaderCells().isEmpty());
     }
 
 
     private List<Cell> getRowWithNonHeaderCells(TablePageBlock table) {
 
         for (int i = table.getRowCount() - 1; i >= 0; i--) { // Non header rows are most likely at bottom of table
-            List<Cell> row = table.getRows()
-                    .get(i);
+            List<Cell> row = table.getRows().get(i);
             if (row.size() == 1) {
                 continue;
             }

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

@@ -5,7 +5,7 @@ import java.util.List;
 import java.util.stream.Collectors;
 
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.AbstractSemanticNode;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.GenericSemanticNode;
 import com.knecon.fforesight.service.layoutparser.processor.model.image.ClassifiedImage;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
 
@@ -24,7 +24,7 @@ public class TableOfContentItem {
     private List<AbstractPageBlock> sectionBlocks = new ArrayList<>();
     private List<ClassifiedImage> images = new ArrayList<>();
 
-    private AbstractSemanticNode section;
+    private GenericSemanticNode section;
 
 
     public TableOfContentItem(TextPageBlock headline) {
@@ -45,8 +45,7 @@ public class TableOfContentItem {
         if (parent != null) {
             int index = parent.getChildren().indexOf(this);
             if (index > 0) {
-                return parent.getChildren()
-                        .get(index - 1);
+                return parent.getChildren().get(index - 1);
             }
         }
         return null;
@@ -58,8 +57,7 @@ public class TableOfContentItem {
         if (parent != null) {
             int index = parent.getChildren().indexOf(this);
             if (index >= 0 && index < parent.getChildren().size() - 1) {
-                return parent.getChildren()
-                        .get(index + 1);
+                return parent.getChildren().get(index + 1);
             }
         }
         return null;
@@ -93,17 +91,19 @@ public class TableOfContentItem {
         return false;
     }
 
+
     public List<AbstractPageBlock> getNonEmptySectionBlocks() {
 
-        return sectionBlocks.stream().filter(pageBlock -> !pageBlock.isEmpty()).collect(Collectors.toList());
+        return sectionBlocks.stream()
+                .filter(pageBlock -> !pageBlock.isEmpty())
+                .collect(Collectors.toList());
     }
 
+
     @Override
     public String toString() {
 
         return "OutlineObjectTreeNode{" + "textPageBlock=" + headline + '}';
     }
 
-
-
 }

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

@@ -35,14 +35,14 @@ public class Cell extends BoundingBox {
 
     public Cell(Point2D topLeft, Point2D bottomRight) {
 
-        this.bBoxInitialUserSpace = new Rectangle2D.Double(topLeft.getX(), topLeft.getY(), (bottomRight.getX() - topLeft.getX()), (bottomRight.getY() - topLeft.getY()));
-        this.bBox = bBoxInitialUserSpace;
+        this.bBoxPdf = new Rectangle2D.Double(topLeft.getX(), topLeft.getY(), (bottomRight.getX() - topLeft.getX()), (bottomRight.getY() - topLeft.getY()));
+        this.bBox = bBoxPdf;
     }
 
 
     public Cell(Rectangle2D bBoxInitialUserSpace, AffineTransform initialUserSpaceToJava) {
 
-        this.bBoxInitialUserSpace = bBoxInitialUserSpace;
+        this.bBoxPdf = bBoxInitialUserSpace;
         this.bBox = initialUserSpaceToJava.createTransformedShape(bBoxInitialUserSpace).getBounds2D();
     }
 
@@ -50,7 +50,7 @@ public class Cell extends BoundingBox {
     public static Cell copy(Cell cell) {
 
         Cell copy = new Cell();
-        copy.bBoxInitialUserSpace = cell.bBoxInitialUserSpace;
+        copy.bBoxPdf = cell.bBoxPdf;
         copy.bBox = cell.bBox;
         return copy;
     }
@@ -87,7 +87,7 @@ public class Cell extends BoundingBox {
 
         }
 
-        return TextNormalizationUtilities.removeHyphenLineBreaks(sb.toString()).replaceAll("\n", " ").replaceAll(" {2}", " ");
+        return TextNormalizationUtilities.cleanString(sb.toString());
     }
 
 

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

@@ -70,7 +70,7 @@ public class CleanRulings {
 
     public boolean lineBetween(BoundingBox a, BoundingBox b) {
 
-        return lineBetween(a.getBBoxInitialUserSpace(), b.getBBoxInitialUserSpace());
+        return lineBetween(a.getBBoxPdf(), b.getBBoxPdf());
     }
 
 

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

@@ -263,8 +263,8 @@ public class TablePageBlock extends AbstractPageBlock {
 
                         cells.stream()
                                 .map(originalCell -> new CellWithIntersection(originalCell,
-                                                                              RectangleTransformations.calculateIntersectedArea(cellFromGridStructure.getBBoxInitialUserSpace(),
-                                                                                                                                originalCell.getBBoxInitialUserSpace())))
+                                                                              RectangleTransformations.calculateIntersectedArea(cellFromGridStructure.getBBoxPdf(),
+                                                                                                                                originalCell.getBBoxPdf())))
                                 .filter(cellWithIntersection -> cellWithIntersection.intersectedArea > 0)
                                 .filter(cellWithIntersection -> cellWithIntersection.originalCell.getArea() > cellWithIntersection.intersectedArea * CELL_AREA_CONTAINED_THRESHOLD)
                                 .max(Comparator.comparing(CellWithIntersection::intersectedArea))

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

@@ -0,0 +1,9 @@
+package com.knecon.fforesight.service.layoutparser.processor.model.text;
+
+
+public enum FontStyle {
+    REGULAR,
+    BOLD,
+    ITALIC,
+    BOLD_ITALIC;
+}

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

@@ -5,64 +5,50 @@ import java.awt.geom.Rectangle2D;
 
 import org.apache.pdfbox.text.TextPosition;
 
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.BoundingBox;
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.TextBoundingBox;
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.utils.FastAtan2;
 
+import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
-import lombok.Builder;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import lombok.SneakyThrows;
+import lombok.experimental.FieldDefaults;
+import lombok.experimental.SuperBuilder;
 
 @Data
-@Builder
+@SuperBuilder
 @NoArgsConstructor
 @AllArgsConstructor
-public class RedTextPosition extends BoundingBox {
+@EqualsAndHashCode(callSuper = true)
+@FieldDefaults(level = AccessLevel.PRIVATE)
+public class RedTextPosition extends TextBoundingBox {
 
     public final static int HEIGHT_PADDING = 2;
 
-    private Rectangle2D.Float bBoxDirAdj; // adjusted to text rotation
+    String unicode;
 
-    @JsonIgnore
-    private int rotation;
+    // estimated using the TextMatrix in radians
+    float exactDir;
 
-    @JsonIgnore
-    private float pageHeight;
+    float widthOfSpace;
 
-    @JsonIgnore
-    private float pageWidth;
+    float fontSizeInPt;
 
-    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;
+    String fontName;
 
 
     @SneakyThrows
     public static RedTextPosition fromTextPosition(TextPosition textPosition) {
 
         var pos = new RedTextPosition();
-        pos.setRotation(textPosition.getRotation());
-        pos.setPageHeight(textPosition.getPageHeight());
-        pos.setPageWidth(textPosition.getPageWidth());
         pos.setUnicode(textPosition.getUnicode());
-        pos.setDir(textPosition.getDir());
         pos.setWidthOfSpace(textPosition.getWidthOfSpace());
         pos.setFontSizeInPt(textPosition.getFontSizeInPt());
         pos.setFontName(textPosition.getFont().getName());
+        pos.setExactDir((float) FastAtan2.fastAtan2(textPosition.getTextMatrix().getShearY(), textPosition.getTextMatrix().getScaleX()));
+        pos.setDir(TextDirection.fromDegrees(textPosition.getDir()));
 
         //TODO: There is a mismatch in the java coords of the text and the rulings,
         // I guess if we start with the initial user space positions and transform them the same way we do the rulings it would work.
@@ -73,18 +59,18 @@ public class RedTextPosition extends BoundingBox {
                                                                  textPosition.getYDirAdj() - textHeight,
                                                                  textPosition.getWidthDirAdj(),
                                                                  textHeight + HEIGHT_PADDING);
+
         pos.setBBoxDirAdj(dirAdjPosition);
 
         AffineTransform affineTransform = getRotationMatrix(TextDirection.fromDegrees(textPosition.getDir()), textPosition.getPageWidth(), textPosition.getPageHeight());
         Rectangle2D bBoxInitialUserSpace = affineTransform.createTransformedShape(dirAdjPosition).getBounds2D();
 
-        pos.setBBoxInitialUserSpace(bBoxInitialUserSpace); // These are definitely correct
+        pos.setBBoxPdf(bBoxInitialUserSpace); // These are definitely correct
 
         return pos;
     }
 
 
-
     private static AffineTransform getRotationMatrix(TextDirection textDirection, float pageWidth, float pageHeight) {
 
         AffineTransform transform = new AffineTransform();
@@ -103,32 +89,4 @@ public class RedTextPosition extends BoundingBox {
         return transform;
     }
 
-
-    @JsonIgnore
-    public float getXDirAdj() {
-
-        return this.bBoxDirAdj.x;
-    }
-
-
-    @JsonIgnore
-    public float getYDirAdj() {
-
-        return this.bBoxDirAdj.y;
-    }
-
-
-    @JsonIgnore
-    public float getWidthDirAdj() {
-
-        return this.bBoxDirAdj.width;
-    }
-
-
-    @JsonIgnore
-    public float getHeightDir() {
-
-        return this.bBoxDirAdj.height;
-    }
-
 }

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

@@ -2,6 +2,7 @@ package com.knecon.fforesight.service.layoutparser.processor.model.text;
 
 import java.util.ArrayList;
 import java.util.List;
+
 import com.knecon.fforesight.service.layoutparser.processor.utils.TextNormalizationUtilities;
 
 import lombok.Getter;
@@ -38,11 +39,7 @@ public class SearchableText {
             sb.append(word);
             sb.append(' ');
         }
-        String text = sb.toString();
-        text = TextNormalizationUtilities.removeHyphenLineBreaks(text);
-        text = TextNormalizationUtilities.removeLineBreaks(text);
-        text = TextNormalizationUtilities.removeRepeatingWhitespaces(text);
-        return text;
+        return TextNormalizationUtilities.cleanString(sb.toString());
     }
 
 }

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

@@ -44,4 +44,15 @@ public enum TextDirection {
 
         throw new IllegalArgumentException(String.format("A value of %f is not supported by TextDirection", degrees));
     }
+
+
+    public int getRotation() {
+
+        return switch (this) {
+            case ZERO -> 0;
+            case QUARTER_CIRCLE -> 1;
+            case HALF_CIRCLE -> 2;
+            case THREE_QUARTER_CIRCLE -> 3;
+        };
+    }
 }

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

@@ -2,12 +2,14 @@ package com.knecon.fforesight.service.layoutparser.processor.model.text;
 
 import java.awt.geom.Rectangle2D;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.FloatFrequencyCounter;
 import com.knecon.fforesight.service.layoutparser.processor.model.PageBlockType;
+import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
 import com.knecon.fforesight.service.layoutparser.processor.utils.TextNormalizationUtilities;
 
 import lombok.AllArgsConstructor;
@@ -26,59 +28,64 @@ public class TextPageBlock extends AbstractPageBlock {
     @Builder.Default
     private List<TextPositionSequence> sequences = new ArrayList<>();
 
+    private Rectangle2D bBoxDirAdj;
+
     private String mostPopularWordFont;
 
     private String mostPopularWordStyle;
 
-    private float mostPopularWordFontSize;
+    private double mostPopularWordFontSize;
 
-    private float mostPopularWordHeight;
+    private double mostPopularWordHeight;
 
-    private float mostPopularWordSpaceWidth;
+    private double mostPopularWordSpaceWidth;
 
-    private float highestFontSize;
+    private boolean underlined;
+
+    private double highestFontSize;
 
     private PageBlockType classification;
 
     private boolean toDuplicate;
 
+    private String text;
+    private boolean changed;
+
 
     public TextPageBlock(List<TextPositionSequence> sequences) {
 
-        this.sequences = sequences;
-        calculateFrequencyCounters();
+        this.sequences = new ArrayList<>(sequences);
+        if (!sequences.isEmpty()) {
+            calculateFrequencyCounters();
+        }
         calculateBBox();
     }
 
 
-    @JsonIgnore
+    public List<TextPositionSequence> getSequences() {
+
+        return Collections.unmodifiableList(sequences);
+    }
+
+
     public TextDirection getDir() {
 
         return sequences.get(0).getDir();
     }
 
 
-    @JsonIgnore
-    public float getPageHeight() {
-
-        return sequences.get(0).getPageHeight();
-    }
-
-
-    @JsonIgnore
-    public float getPageWidth() {
-
-        return sequences.get(0).getPageWidth();
-    }
-
-
     private void calculateBBox() {
 
         if (sequences == null) {
             this.bBox = new Rectangle2D.Double();
-            this.bBoxInitialUserSpace = new Rectangle2D.Double();
+            this.bBoxPdf = new Rectangle2D.Double();
+            this.bBoxDirAdj = new Rectangle2D.Double();
             return;
         }
+        this.bBoxDirAdj = sequences.stream()
+                .map(TextPositionSequence::getBBoxDirAdj)
+                .collect(RectangleTransformations.collectBBox());
+
         setToBBoxOfComponents(sequences);
     }
 
@@ -135,13 +142,16 @@ public class TextPageBlock extends AbstractPageBlock {
         setMostPopularWordHeight(lineHeightFrequencyCounter.getMostPopular());
         setMostPopularWordSpaceWidth(spaceFrequencyCounter.getMostPopular());
         setHighestFontSize(fontSizeFrequencyCounter.getHighest());
+
+        setUnderlined(sequences.stream()
+                              .allMatch(TextPositionSequence::isUnderline));
     }
 
 
     public TextPageBlock union(TextPositionSequence r) {
 
         TextPageBlock union = this.copy();
-        union.getSequences().add(r);
+        union.add(r);
         calculateFrequencyCounters();
         calculateBBox();
         return union;
@@ -151,24 +161,35 @@ public class TextPageBlock extends AbstractPageBlock {
     public TextPageBlock union(TextPageBlock r) {
 
         TextPageBlock union = this.copy();
-        union.getSequences().addAll(r.getSequences());
+        union.addAll(r.getSequences());
         calculateFrequencyCounters();
         calculateBBox();
         return union;
     }
 
 
-    public void add(TextPageBlock r) {
+    public void add(TextPageBlock textPageBlock) {
 
-        sequences.addAll(r.getSequences());
+        changed = true;
+        sequences.addAll(textPageBlock.getSequences());
         calculateFrequencyCounters();
         calculateBBox();
     }
 
 
-    public void add(TextPositionSequence r) {
+    public void add(TextPositionSequence textPositionSequence) {
 
-        sequences.add(r);
+        changed = true;
+        sequences.add(textPositionSequence);
+        calculateFrequencyCounters();
+        calculateBBox();
+    }
+
+
+    public void addAll(List<TextPositionSequence> textPositionSequences) {
+
+        changed = true;
+        sequences.addAll(textPositionSequences);
         calculateFrequencyCounters();
         calculateBBox();
     }
@@ -183,19 +204,7 @@ public class TextPageBlock extends AbstractPageBlock {
     @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();
-
+        return getText();
     }
 
 
@@ -203,22 +212,28 @@ public class TextPageBlock extends AbstractPageBlock {
     @JsonIgnore
     public String getText() {
 
-        StringBuilder sb = new StringBuilder();
+        if (text == null || changed) {
 
-        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(' ');
+            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;
             }
-            sb.append(word.toString());
-            previous = word;
+
+            text = TextNormalizationUtilities.removeHyphenLinebreaks(sb.toString());
+            changed = false;
         }
 
-        return TextNormalizationUtilities.removeHyphenLineBreaks(sb.toString());
+        return text;
     }
 
 

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

@@ -1,20 +1,20 @@
 package com.knecon.fforesight.service.layoutparser.processor.model.text;
 
-import java.awt.geom.Rectangle2D;
+import static com.knecon.fforesight.service.layoutparser.processor.model.text.RedTextPosition.HEIGHT_PADDING;
+
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
+import java.util.Objects;
 import java.util.stream.Collectors;
 
 import org.apache.pdfbox.text.TextPosition;
 
-import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.BoundingBox;
-import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.TextBoundingBox;
 
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
-import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
@@ -23,27 +23,25 @@ import lombok.extern.slf4j.Slf4j;
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
-@EqualsAndHashCode(onlyExplicitlyIncluded = true, callSuper = false)
-public class TextPositionSequence extends BoundingBox implements CharSequence {
+@SuppressWarnings("pmd")
+public class TextPositionSequence extends TextBoundingBox implements CharSequence {
 
-    public static final int HEIGHT_PADDING = 2;
+    public static final String STANDARD = "standard";
+    public static final String BOLD_ITALIC = "bold, italic";
+    public static final String BOLD = "bold";
+    public static final String ITALIC = "italic";
 
-    @EqualsAndHashCode.Include
     private int page;
 
-    @EqualsAndHashCode.Include
+    @Builder.Default
     private List<RedTextPosition> textPositions = new ArrayList<>();
 
-    private Rectangle2D bBoxDirAdj;
-    @EqualsAndHashCode.Include
-    private TextDirection dir;
-    private int rotation;
-    private float pageHeight;
-    private float pageWidth;
     private boolean isParagraphStart;
     private boolean strikethrough;
     private boolean underline;
 
+    private Integer hashcodeCache;
+
 
     public TextPositionSequence(List<TextPosition> textPositions, int pageNumber, boolean isParagraphStart) {
 
@@ -51,21 +49,15 @@ public class TextPositionSequence extends BoundingBox implements CharSequence {
                 .map(RedTextPosition::fromTextPosition)
                 .collect(Collectors.toList());
         this.page = pageNumber;
-        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.isParagraphStart = isParagraphStart;
-        calculateBBox();
+        calculateBBoxAndHashcode();
     }
 
 
-    private void calculateBBox() {
+    private void calculateBBoxAndHashcode() {
 
-        this.bBoxDirAdj = textPositions.stream()
-                .map(RedTextPosition::getBBoxDirAdj)
-                .collect(RectangleTransformations.collectBBox());
         setToBBoxOfComponents(getTextPositions());
+        hashcodeCache = null;
     }
 
 
@@ -73,11 +65,7 @@ public class TextPositionSequence extends BoundingBox implements CharSequence {
 
         this.textPositions = textPositions;
         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();
-        calculateBBox();
+        calculateBBoxAndHashcode();
     }
 
 
@@ -112,9 +100,6 @@ public class TextPositionSequence extends BoundingBox implements CharSequence {
         textPositionSequence.textPositions = textPositions.subList(start, end);
         textPositionSequence.page = page;
         textPositionSequence.dir = dir;
-        textPositionSequence.rotation = rotation;
-        textPositionSequence.pageHeight = pageHeight;
-        textPositionSequence.pageWidth = pageWidth;
         textPositionSequence.setToBBoxOfComponents(getTextPositions());
         return textPositionSequence;
     }
@@ -141,90 +126,26 @@ public class TextPositionSequence extends BoundingBox implements CharSequence {
 
         this.textPositions.add(textPosition);
         this.page = textPositionSequence.getPage();
-        this.dir = textPositionSequence.getDir();
-        this.rotation = textPositionSequence.getRotation();
-        this.pageHeight = textPositionSequence.getPageHeight();
-        this.pageWidth = textPositionSequence.getPageWidth();
-        calculateBBox();
+        calculateBBoxAndHashcode();
     }
 
 
     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();
-        calculateBBox();
+        calculateBBoxAndHashcode();
     }
 
 
-    /**
-     * 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
-     */
-
-    public float getMinXDirAdj() {
-
-        return textPositions.get(0).getXDirAdj();
+    public double getTextHeightNoPadding() {
 
+        return textPositions.get(0).getHeightDirAdj();
     }
 
 
-    /**
-     * 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
-     */
+    public double getTextHeight() {
 
-    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.
-     */
-
-    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.
-     */
-
-    public float getMaxYDirAdj() {
-
-        return textPositions.get(0).getYDirAdj();
-
-    }
-
-
-    public float getTextHeightNoPadding() {
-
-        return textPositions.get(0).getHeightDir();
-    }
-
-
-    public float getTextHeight() {
-
-        return textPositions.get(0).getHeightDir() + HEIGHT_PADDING;
+        return textPositions.get(0).getHeightDirAdj() + HEIGHT_PADDING;
     }
 
 
@@ -240,18 +161,18 @@ public class TextPositionSequence extends BoundingBox implements CharSequence {
     public String getFontStyle() {
 
         if (textPositions.get(0).getFontName() == null) {
-            return "standard";
+            return STANDARD;
         }
         String lowercaseFontName = textPositions.get(0).getFontName().toLowerCase(Locale.ROOT);
 
-        if (lowercaseFontName.contains("bold") && lowercaseFontName.contains("italic")) {
-            return "bold, italic";
-        } else if (lowercaseFontName.contains("bold")) {
-            return "bold";
-        } else if (lowercaseFontName.contains("italic")) {
-            return "italic";
+        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";
+            return STANDARD;
         }
     }
 
@@ -267,5 +188,55 @@ public class TextPositionSequence extends BoundingBox implements CharSequence {
         return textPositions.get(0).getWidthOfSpace();
     }
 
+
+    public boolean equals(final Object o) {
+        // auto-generated with lombok
+        if (o == this) {
+            return true;
+        }
+        if (!(o instanceof TextPositionSequence other)) {
+            return false;
+        }
+        if (!other.canEqual((Object) this)) {
+            return false;
+        }
+        if (!super.equals(o)) {
+            return false;
+        }
+        if (this.getPage() != other.getPage()) {
+            return false;
+        }
+        final Object this$textPositions = this.getTextPositions();
+        final Object other$textPositions = other.getTextPositions();
+        if (!Objects.equals(this$textPositions, other$textPositions)) {
+            return false;
+        }
+        return Objects.equals(this.getHashcodeCache(), other.getHashcodeCache());
+    }
+
+
+    protected boolean canEqual(final Object other) {return other instanceof TextPositionSequence;}
+
+
+    public int hashCode() {
+
+        if (hashcodeCache == null) {
+            hashcodeCache = hashcodeCalculation();
+        }
+
+        return hashcodeCache;
+    }
+
+
+    private int hashcodeCalculation() {
+
+        final int PRIME = 59;
+        int result = super.hashCode();
+        result = result * PRIME + this.getPage();
+        final Object $textPositions = this.getTextPositions();
+        result = result * PRIME + ($textPositions == null ? 43 : $textPositions.hashCode());
+        return result;
+    }
+
 }
 

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

@@ -56,7 +56,7 @@ public class ImageServiceResponseAdapter {
         classificationPage.getImages().forEach(image -> {
             if (image.getImageType().equals(ImageType.OTHER)) {
                 for (AbstractPageBlock textblock : classificationPage.getTextBlocks()) {
-                    if (image.getPosition().contains(textblock.getBBoxInitialUserSpace())) {
+                    if (image.getPosition().contains(textblock.getBBoxPdf())) {
                         image.setImageType(ImageType.OCR);
                         return;
                     }

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

@@ -14,6 +14,7 @@ import lombok.NoArgsConstructor;
 @AllArgsConstructor
 public class Classification {
 
+    @Builder.Default
     private Map<String, Float> probabilities = new HashMap<>();
     private String label;
 

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

@@ -22,8 +22,10 @@ public class ImageServiceResponse {
 
     @JsonProperty(value = "imageMetadata")
     @JsonAlias("data")
+    @Builder.Default
     private List<ImageMetadata> data = new ArrayList<>();
 
+    @Builder.Default
     private List<ImageMetadata> dataCV = new ArrayList<>();
 
 

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

@@ -15,6 +15,7 @@ import lombok.NoArgsConstructor;
 public class TableData {
 
     private PageInfo pageInfo;
+    @Builder.Default
     private List<TableCells> tableCells = new ArrayList<>();
 
 }

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

@@ -19,7 +19,7 @@ public class TableServiceResponse {
     private String operation;
     private String targetFileExtension;
     private String responseFileExtension;
-
+    @Builder.Default
     private List<TableData> data = new ArrayList<>();
 
 }

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

@@ -6,7 +6,6 @@ import java.util.List;
 
 import com.knecon.fforesight.service.layoutparser.processor.model.GapInformation;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
-import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
 
 import lombok.AllArgsConstructor;
 import lombok.experimental.UtilityClass;
@@ -38,7 +37,7 @@ public class GapDetectionService {
         for (TextPositionSequence currentTextPosition : sortedTextPositionSequences.subList(1, sortedTextPositionSequences.size())) {
 
             double yDifference = Math.abs(currentTextPosition.getMaxYDirAdj() - previousTextPosition.getMaxYDirAdj());
-            double xGap = Math.abs(previousTextPosition.getMaxXDirAdj() - currentTextPosition.getMinXDirAdj());
+            double xGap = Math.abs(previousTextPosition.getMaxXDirAdj() - currentTextPosition.getXDirAdj());
             Rectangle2D previousTextPositionBBox = toRectangle2D(previousTextPosition);
             Rectangle2D currentTextPositionBBox = toRectangle2D(currentTextPosition);
 

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

@@ -71,7 +71,7 @@ public class LineDetectionService {
 
     private static boolean isXGap(TextPositionSequence currentTextPosition, TextPositionSequence previousTextPosition, double avgTextPositionHeight) {
 
-        return Math.abs(previousTextPosition.getMaxXDirAdj() - currentTextPosition.getMinXDirAdj()) > (avgTextPositionHeight * X_GAP_FACTOR);
+        return Math.abs(previousTextPosition.getMaxXDirAdj() - currentTextPosition.getXDirAdj()) > (avgTextPositionHeight * X_GAP_FACTOR);
     }
 
 
@@ -83,7 +83,7 @@ public class LineDetectionService {
 
     private static boolean isNewLine(TextPositionSequence currentTextPosition, TextPositionSequence previousTextPosition, double avgTextPositionHeight) {
 
-        return Math.abs(previousTextPosition.getMinYDirAdj() - currentTextPosition.getMinYDirAdj()) > avgTextPositionHeight;
+        return Math.abs(previousTextPosition.getYDirAdj() - currentTextPosition.getYDirAdj()) > avgTextPositionHeight;
     }
 
 

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

@@ -34,7 +34,22 @@ public class SimplifiedSectionTextService {
         List<SimplifiedSectionText> simplifiedText = Stream.of(simplifiedMainSectionsList, simplifiedHeadersList, simplifiedFootersList)
                 .flatMap(List::stream)
                 .collect(Collectors.toList());
-        return SimplifiedText.builder().numberOfPages(document.getNumberOfPages()).sectionTexts(simplifiedText).build();
+        return SimplifiedText.builder()
+                .numberOfPages(document.getNumberOfPages())
+                .sectionTexts(simplifiedText)
+                .mainSectionNumbers(document.getAllSections()
+                                            .stream()
+                                            .map(this::getSectionNumber)
+                                            .toList())
+                .headerSectionNumbers(document.getHeaders()
+                                              .stream()
+                                              .map(this::getSectionNumber)
+                                              .toList())
+                .footerSectionNumbers(document.getFooters()
+                                              .stream()
+                                              .map(this::getSectionNumber)
+                                              .toList())
+                .build();
     }
 
 
@@ -49,4 +64,13 @@ public class SimplifiedSectionTextService {
                 .build();
     }
 
+
+    private String getSectionNumber(SemanticNode semanticNode) {
+
+        return semanticNode.getTreeId()
+                .stream()
+                .map(String::valueOf)
+                .collect(Collectors.joining("."));
+    }
+
 }

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

@@ -78,7 +78,7 @@ public class TableExtractionService {
 
             List<Cell> containedCells = new ArrayList<>();
             for (Cell c : cells) {
-                if (c.hasMinimumSize() && area.contains(c.getBBoxInitialUserSpace())) {
+                if (c.hasMinimumSize() && area.contains(c.getBBoxPdf())) {
                     containedCells.add(c);
                 }
             }

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

@@ -31,13 +31,13 @@ public class TextRulingsClassifier {
 
     private static void handleVerticalText(CleanRulings cleanRulings, TextPositionSequence word) {
 
-        float lowerY = (float) (word.getBBoxInitialUserSpace().getMinY() + TEXT_BBOX_THRESHOLD_FACTOR * word.getWidth());
-        float upperY = (float) (word.getBBoxInitialUserSpace().getMaxY() - TEXT_BBOX_THRESHOLD_FACTOR * word.getWidth());
+        float lowerY = (float) (word.getBBoxPdf().getMinY() + TEXT_BBOX_THRESHOLD_FACTOR * word.getWidth());
+        float upperY = (float) (word.getBBoxPdf().getMaxY() - TEXT_BBOX_THRESHOLD_FACTOR * word.getWidth());
 
-        float strikethroughCenterX = (float) word.getBBoxInitialUserSpace().getCenterX();
+        float strikethroughCenterX = (float) word.getBBoxPdf().getCenterX();
         float strikethroughBoxHeight = (float) ((word.getBBoxDirAdj().getHeight() * STRIKETHROUGH_ZONE) / 2);
 
-        float underlineCenterX = (float) (word.getDir().equals(TextDirection.QUARTER_CIRCLE) ? word.getBBoxInitialUserSpace().getMaxX() : word.getBBoxInitialUserSpace().getMinX());
+        float underlineCenterX = (float) (word.getDir().equals(TextDirection.QUARTER_CIRCLE) ? word.getBBoxPdf().getMaxX() : word.getBBoxPdf().getMinX());
         float underlineBoxHeight = (float) ((word.getBBoxDirAdj().getHeight() * UNDERLINE_ZONE) / 2);
 
         float leftX = Math.min(underlineCenterX - underlineBoxHeight, strikethroughCenterX - strikethroughBoxHeight);
@@ -65,13 +65,13 @@ public class TextRulingsClassifier {
 
     private static void handleHorizontalText(CleanRulings cleanRulings, TextPositionSequence word) {
 
-        float leftX = (float) (word.getBBoxInitialUserSpace().getMinX() + TEXT_BBOX_THRESHOLD_FACTOR * word.getWidth());
-        float rightX = (float) (word.getBBoxInitialUserSpace().getMaxX() - TEXT_BBOX_THRESHOLD_FACTOR * word.getWidth());
+        float leftX = (float) (word.getBBoxPdf().getMinX() + TEXT_BBOX_THRESHOLD_FACTOR * word.getWidth());
+        float rightX = (float) (word.getBBoxPdf().getMaxX() - TEXT_BBOX_THRESHOLD_FACTOR * word.getWidth());
 
-        float strikethroughCenterY = (float) word.getBBoxInitialUserSpace().getCenterY();
+        float strikethroughCenterY = (float) word.getBBoxPdf().getCenterY();
         float strikethroughBoxHeight = (float) ((word.getBBoxDirAdj().getHeight() * STRIKETHROUGH_ZONE) / 2);
 
-        float underlineCenterY = (float) (word.getDir().equals(TextDirection.ZERO) ? word.getBBoxInitialUserSpace().getMinY() : word.getBBoxInitialUserSpace().getMaxY());
+        float underlineCenterY = (float) (word.getDir().equals(TextDirection.ZERO) ? word.getBBoxPdf().getMinY() : word.getBBoxPdf().getMaxY());
         float underlineBoxHeight = (float) ((word.getBBoxDirAdj().getHeight() * UNDERLINE_ZONE) / 2);
 
         float lowerY = Math.min(underlineCenterY - underlineBoxHeight, strikethroughCenterY - strikethroughBoxHeight);

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

@@ -2,40 +2,29 @@ package com.knecon.fforesight.service.layoutparser.processor.services.blockifica
 
 import static com.knecon.fforesight.service.layoutparser.processor.services.blockification.DocstrumBlockificationService.buildTextBlock;
 
-import java.awt.geom.Rectangle2D;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Locale;
-import java.util.function.Function;
 
 import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.text.similarity.LevenshteinDistance;
 import org.springframework.stereotype.Service;
 
-import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.LayoutEngine;
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.LayoutEngineProto.LayoutEngine;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
 import com.knecon.fforesight.service.layoutparser.processor.model.PageBlockType;
 import com.knecon.fforesight.service.layoutparser.processor.model.SectionIdentifier;
 import com.knecon.fforesight.service.layoutparser.processor.model.outline.OutlineObject;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
-import com.knecon.fforesight.service.layoutparser.processor.services.factory.SearchTextWithTextPositionFactory;
-import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
 
 import lombok.Data;
 
 @Service
 public class BlockificationPostprocessingService {
 
-    private static final float BLOCK_TO_OUTLINE_DISTANCE_THRESHOLD = 5.0f;
-
-    private static final Function<TextPageBlock, Rectangle2D> blockToBoundingBox = (abstractPageBlock) -> abstractPageBlock.getSequences()
-            .stream()
-            .map(textPositionSequence -> textPositionSequence.getTextPositions()
-                    .stream()
-                    .map(tp -> SearchTextWithTextPositionFactory.mapRedTextPositionToInitialUserSpace(tp, textPositionSequence))
-                    .collect(RectangleTransformations.collectBBox()))
-            .collect(RectangleTransformations.collectBBox());
+    private static final float STRING_SIMILARITY_THRESHOLD = 0.1f;
 
 
     public OutlineObject sanitizeOutlineBlocks(ClassificationPage classificationPage, OutlineObject notFoundOutlineObject) {
@@ -46,20 +35,18 @@ public class BlockificationPostprocessingService {
             return null;
         }
 
-        float pageHeight = classificationPage.getPageHeight();
-
         ListIterator<OutlineObject> outlineObjectListIterator = outlineObjects.listIterator();
 
         if (notFoundOutlineObject != null) {
             OutlineProcessionContext notFoundOutlineObjectProcessionContext = new OutlineProcessionContext(notFoundOutlineObject);
-            processTextBlocks(getTextPageBlocks(classificationPage), pageHeight, notFoundOutlineObjectProcessionContext);
+            processTextBlocks(getTextPageBlocks(classificationPage), notFoundOutlineObjectProcessionContext);
 
             OutlineObject firstOutlineObject = null;
             OutlineProcessionContext firstOutlineObjectProcessionContext = null;
             if (outlineObjectListIterator.hasNext()) {
                 firstOutlineObject = outlineObjectListIterator.next();
                 firstOutlineObjectProcessionContext = new OutlineProcessionContext(firstOutlineObject);
-                processTextBlocks(getTextPageBlocks(classificationPage), pageHeight, firstOutlineObjectProcessionContext);
+                processTextBlocks(getTextPageBlocks(classificationPage), firstOutlineObjectProcessionContext);
             }
 
             if (!contextsOverlap(notFoundOutlineObjectProcessionContext, firstOutlineObjectProcessionContext)) {
@@ -68,7 +55,7 @@ public class BlockificationPostprocessingService {
             if (firstOutlineObject != null) {
                 // re-create the context for the updated blocks
                 firstOutlineObjectProcessionContext = new OutlineProcessionContext(firstOutlineObject);
-                processTextBlocks(getTextPageBlocks(classificationPage), pageHeight, firstOutlineObjectProcessionContext);
+                processTextBlocks(getTextPageBlocks(classificationPage), firstOutlineObjectProcessionContext);
                 firstOutlineObject.setFound(selectMatch(classificationPage, firstOutlineObjectProcessionContext));
             }
 
@@ -76,7 +63,7 @@ public class BlockificationPostprocessingService {
 
         outlineObjectListIterator.forEachRemaining(outlineObject -> {
             OutlineProcessionContext outlineObjectProcessionContext = new OutlineProcessionContext(outlineObject);
-            processTextBlocks(getTextPageBlocks(classificationPage), pageHeight, outlineObjectProcessionContext);
+            processTextBlocks(getTextPageBlocks(classificationPage), outlineObjectProcessionContext);
             outlineObject.setFound(selectMatch(classificationPage, outlineObjectProcessionContext));
         });
 
@@ -116,8 +103,7 @@ public class BlockificationPostprocessingService {
 
         double maxYFirst = blocksOfFirstOutline.stream()
                 .mapToDouble(TextPageBlock::getPdfMaxY)
-                .max()
-                .orElse(Double.NEGATIVE_INFINITY);
+                .max().orElse(Double.NEGATIVE_INFINITY);
 
         return blocksOfNotFoundOutline.stream()
                 .mapToDouble(TextPageBlock::getPdfMaxY)
@@ -139,13 +125,13 @@ public class BlockificationPostprocessingService {
     }
 
 
-    private void processTextBlocks(List<TextPageBlock> textBlocks, float pageHeight, OutlineProcessionContext context) {
+    private void processTextBlocks(List<TextPageBlock> textBlocks, OutlineProcessionContext context) {
 
         OutlineObject outlineObject = context.getOutlineObject();
         ListIterator<TextPageBlock> iterator = textBlocks.listIterator();
         while (iterator.hasNext()) {
             TextPageBlock pageBlock = iterator.next();
-            if (pageHeight - outlineObject.getPoint().getY() - BLOCK_TO_OUTLINE_DISTANCE_THRESHOLD <= pageBlock.getMaxY()) {
+            if (outlineObject.isAbove(pageBlock)) {
                 break;
             }
         }
@@ -190,8 +176,7 @@ public class BlockificationPostprocessingService {
             for (List<TextPageBlock> combination : combinations) {
                 double averageDistance = combination.stream()
                         .map(block -> calculateDistance(outlineObject, block))
-                        .mapToDouble(Double::doubleValue).average()
-                        .orElse(Double.MAX_VALUE);
+                        .mapToDouble(Double::doubleValue).average().orElse(Double.MAX_VALUE);
                 if (distanceToBestMergeCandidates > averageDistance) {
                     distanceToBestMergeCandidates = averageDistance;
                     bestMergeCandidateCombination = combination;
@@ -273,7 +258,7 @@ public class BlockificationPostprocessingService {
         List<TextPositionSequence> postSequence = new ArrayList<>();
         StringBuilder currentSequence = new StringBuilder();
 
-        if (target.isBlank()){
+        if (target.isBlank()) {
             return new WordSequenceResult();
         }
 
@@ -336,7 +321,7 @@ public class BlockificationPostprocessingService {
         TextPositionSequence in = null;
         TextPositionSequence out;
 
-        String currentSequence = sequence.toString();
+        String currentSequence = sequence.toString().toLowerCase(Locale.ROOT);
         int index = currentSequence.indexOf(toRemove);
         int endIndex = index + toRemove.length();
 
@@ -372,7 +357,7 @@ public class BlockificationPostprocessingService {
                 if (firstBlock != null && !firstBlock.getSequences().isEmpty()) {
 
                     if (textPageBlock.getDir() == firstBlock.getDir()) {
-                        firstBlock.getSequences().addAll(textPageBlock.getSequences());
+                        firstBlock.addAll(textPageBlock.getSequences());
                         mergedBlocks.add(textPageBlock);
                     }
                 }
@@ -420,9 +405,7 @@ public class BlockificationPostprocessingService {
 
     private double calculateDistance(OutlineObject outlineObject, TextPageBlock pageBlock) {
 
-        double deltaX = outlineObject.getPoint().getX() - pageBlock.getMinX();
-        double deltaY = pageBlock.getPageHeight() - outlineObject.getPoint().getY() - pageBlock.getMinY();
-        return Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+        return outlineObject.distance(pageBlock);
     }
 
 
@@ -439,6 +422,13 @@ public class BlockificationPostprocessingService {
         String blockText = sanitizeString(pageBlock.getText());
         String outlineTitle = sanitizeString(outlineObject.getTitle());
 
+        int threshold = (int) (Math.min(blockText.length(), outlineTitle.length()) * STRING_SIMILARITY_THRESHOLD) + 1;
+        int distance = new LevenshteinDistance(threshold).apply(blockText, outlineTitle);
+        if (distance >= 0 && distance < threshold) {
+            context.directMatch = pageBlock;
+            return true;
+        }
+
         boolean blockTextContainsOutlineTitle = blockText.contains(outlineTitle);
         boolean outlineTitleContainsBlockText = outlineTitle.contains(blockText);
 

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

@@ -1,7 +1,6 @@
 package com.knecon.fforesight.service.layoutparser.processor.services.blockification;
 
 import java.util.ArrayList;
-import java.util.Comparator;
 import java.util.List;
 import java.util.ListIterator;
 
@@ -10,7 +9,6 @@ import org.springframework.stereotype.Service;
 import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingType;
 import com.knecon.fforesight.service.layoutparser.processor.docstrum.DocstrumSegmentationService;
 import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.Zone;
-import com.knecon.fforesight.service.layoutparser.processor.docstrum.utils.DoubleUtils;
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
 import com.knecon.fforesight.service.layoutparser.processor.model.table.CleanRulings;
@@ -40,7 +38,7 @@ public class DocstrumBlockificationService {
 
         CleanRulings usedRulings = rulings.withoutTextRulings();
 
-        var zones = docstrumSegmentationService.segmentPage(textPositions, xyOrder, usedRulings, visualizations);
+        List<Zone> zones = docstrumSegmentationService.segmentPage(textPositions, xyOrder, usedRulings, visualizations);
 
         if (!textPositions.isEmpty()) {
             visualizations.addZoneVisualizations(zones, textPositions.get(0).getPage());
@@ -48,11 +46,7 @@ public class DocstrumBlockificationService {
             visualizations.addCharactersWithNeighbours(zones, textPositions.get(0).getPage());
         }
 
-        var pageBlocks = toAbstractPageBlocks(zones, xyOrder, usedRulings);
-
-        if (xyOrder) {
-            sortPageBlocksXThenY(pageBlocks);
-        }
+        var pageBlocks = toAbstractPageBlocks(zones);
 
         var classificationPage = new ClassificationPage(pageBlocks);
         classificationPage.setCleanRulings(rulings);
@@ -73,21 +67,7 @@ public class DocstrumBlockificationService {
     }
 
 
-    private static void sortPageBlocksXThenY(List<AbstractPageBlock> pageBlocks) {
-
-        pageBlocks.sort(Comparator.comparing(AbstractPageBlock::getMinY, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD))
-                                .thenComparing(AbstractPageBlock::getMinX, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD)));
-        pageBlocks.sort(new Comparator<AbstractPageBlock>() {
-            @Override
-            public int compare(AbstractPageBlock o1, AbstractPageBlock o2) {
-
-                return Math.abs(o1.getMinY() - o2.getMinY()) < 5 && o1.getMinX() < o2.getMinX() == true ? -1 : 0;
-            }
-        });
-    }
-
-
-    private List<AbstractPageBlock> toAbstractPageBlocks(List<Zone> zones, boolean xyOrder, CleanRulings usedRulings) {
+    private List<AbstractPageBlock> toAbstractPageBlocks(List<Zone> zones) {
 
         List<AbstractPageBlock> abstractPageBlocks = new ArrayList<>();
         zones.forEach(zone -> {
@@ -202,7 +182,7 @@ public class DocstrumBlockificationService {
 
     private TextPageBlock combineBlocksAndResetIterator(TextPageBlock previous, TextPageBlock current, ListIterator<AbstractPageBlock> itty, boolean toDuplicate) {
 
-        previous.getSequences().addAll(current.getSequences());
+        previous.addAll(current.getSequences());
         previous = buildTextBlock(previous.getSequences(), 0);
         previous.setToDuplicate(toDuplicate);
         if (current.getClassification() != null && previous.getClassification() == null) {
@@ -296,10 +276,14 @@ public class DocstrumBlockificationService {
                     continue;
                 }
 
+//                if (!current.getMostPopularWordStyle().equals(inner.getMostPopularWordStyle())) {
+//                    continue;
+//                }
+
                 if (current.getDir() == inner.getDir() && current.intersects(inner, yThreshold, xThreshold)) {
 
                     boolean toDuplicate = current.isToDuplicate() || inner.isToDuplicate();
-                    current.getSequences().addAll(inner.getSequences());
+                    current.addAll(inner.getSequences());
                     current = buildTextBlock(current.getSequences(), 0);
 
                     current.setToDuplicate(toDuplicate);

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

@@ -1,25 +1,24 @@
 package com.knecon.fforesight.service.layoutparser.processor.services.blockification;
 
-import static java.util.stream.Collectors.toSet;
-
 import java.util.ArrayList;
-import java.util.Comparator;
 import java.util.List;
+import java.util.ListIterator;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 import org.springframework.stereotype.Service;
 
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.LayoutEngine;
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
-import com.knecon.fforesight.service.layoutparser.processor.model.FloatFrequencyCounter;
 import com.knecon.fforesight.service.layoutparser.processor.model.Orientation;
 import com.knecon.fforesight.service.layoutparser.processor.model.table.CleanRulings;
-import com.knecon.fforesight.service.layoutparser.processor.model.text.StringFrequencyCounter;
+import com.knecon.fforesight.service.layoutparser.processor.model.table.TablePageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
 
+@SuppressWarnings("all")
 @Service
 public class DocuMineBlockificationService {
 
@@ -44,31 +43,32 @@ public class DocuMineBlockificationService {
 
         CleanRulings usedRulings = cleanRulings.withoutTextRulings();
 
-        float minX = 1000;
-        float maxX = 0;
-        float minY = 1000;
-        float maxY = 0;
+        double minX = 1000;
+        double maxX = 0;
+        double minY = 1000;
+        double maxY = 0;
         TextPositionSequence prev = null;
 
         boolean wasSplitted = false;
-        Float splitX1 = null;
+        Double splitX1 = null;
         for (TextPositionSequence word : textPositions) {
 
-            boolean lineSeparation = prev != null && word.getMinYDirAdj() - maxY > Math.min(word.getHeight(), prev.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 negativeXGap = prev != null && word.getMinXDirAdj() - minX < -5;
-            boolean newLineAfterSplit = prev != null && word.getMinYDirAdj() != prev.getMinYDirAdj() && wasSplitted && splitX1 != word.getMinXDirAdj();
+            boolean lineSeparation = prev != null && word.getYDirAdj() - prev.getMaxYDirAdj() > Math.min(word.getHeight(), prev.getHeight()) * 1.1;
+            boolean startFromTop = prev != null && word.getYDirAdj() < prev.getYDirAdj() - prev.getTextHeight();
+            boolean splitByX = prev != null && maxX + 50 < word.getXDirAdj() && prev.getYDirAdj() == word.getYDirAdj();
+            boolean negativeXGap = prev != null && word.getXDirAdj() - minX < -5;
+            boolean newLineAfterSplit = prev != null && word.getYDirAdj() != prev.getYDirAdj() && wasSplitted && splitX1 != word.getXDirAdj();
             boolean isSplitByRuling = prev != null && usedRulings.lineBetween(prev, word);
             boolean splitByDir = prev != null && !prev.getDir().equals(word.getDir());
-            boolean splitByOtherFontAndOtherY = prev != null && Math.abs(prev.getMaxYDirAdj() - word.getMaxYDirAdj()) > word.getTextHeight() * 0.2 && (word.getFontStyle()
-                                                                                                                                                               .contains("bold")
-                                                                                                                                                       && !prev.getFontStyle()
-                    .contains("bold") || prev.getFontStyle().contains("bold") && !word.getFontStyle().contains("bold"));
+            boolean splitByOtherFontAndOtherY = prev != null && Math.abs(prev.getMaxYDirAdj() - word.getMaxYDirAdj()) > word.getTextHeight() * 0.2 //
+                                                && (word.getFontStyle().contains("bold") && !prev.getFontStyle().contains("bold")
+                                                    || prev.getFontStyle().contains("bold") && !word.getFontStyle().contains("bold")
+                                                    || Math.abs(prev.getFontSize() - word.getFontSize()) >= 1
+                                                    || Math.abs(word.getTextHeight() - prev.getTextHeight()) > 0.8);
 
             Matcher matcher = pattern.matcher(chunkWords.stream()
                                                       .collect(Collectors.joining(" ")).toString());
-            boolean startsOnSameX = Math.abs(minX - word.getMinXDirAdj()) < 5 && matcher.matches();
+            boolean startsOnSameX = Math.abs(minX - word.getXDirAdj()) < 5 && matcher.matches();
 
             if (prev != null && (lineSeparation || startFromTop || splitByDir || isSplitByRuling || splitByOtherFontAndOtherY || negativeXGap || startsOnSameX)) {
 
@@ -84,7 +84,7 @@ public class DocuMineBlockificationService {
                 if (splitByX && !isSplitByRuling) {
                     wasSplitted = true;
                     cb1.setOrientation(Orientation.LEFT);
-                    splitX1 = word.getMinXDirAdj();
+                    splitX1 = word.getXDirAdj();
                 } else if (newLineAfterSplit && !isSplitByRuling) {
                     wasSplitted = false;
                     cb1.setOrientation(Orientation.RIGHT);
@@ -107,14 +107,14 @@ public class DocuMineBlockificationService {
             chunkWords.add(word);
 
             prev = word;
-            if (word.getMinXDirAdj() < minX) {
-                minX = word.getMinXDirAdj();
+            if (word.getXDirAdj() < minX) {
+                minX = word.getXDirAdj();
             }
             if (word.getMaxXDirAdj() > maxX) {
                 maxX = word.getMaxXDirAdj();
             }
-            if (word.getMinYDirAdj() < minY) {
-                minY = word.getMinYDirAdj();
+            if (word.getYDirAdj() < minY) {
+                minY = word.getYDirAdj();
             }
             if (word.getMaxYDirAdj() > maxY) {
                 maxY = word.getMaxYDirAdj();
@@ -127,6 +127,76 @@ public class DocuMineBlockificationService {
     }
 
 
+    public void mergeblocks(ClassificationPage page, CleanRulings usedRulings, float xThreshold, float yThreshold) {
+
+        var blocks = page.getTextBlocks();
+        ListIterator<AbstractPageBlock> itty = blocks.listIterator();
+        while (itty.hasNext()) {
+            AbstractPageBlock block = itty.next();
+            if (block == null) {
+                continue;
+            }
+            if (block instanceof TablePageBlock) {
+                continue;
+            }
+
+            TextPageBlock current = (TextPageBlock) block;
+
+            for (int i = 0; i < blocks.size(); i++) {
+
+                AbstractPageBlock abstractPageBlock = blocks.get(i);
+                if (abstractPageBlock == null) {
+                    continue;
+                }
+                if (abstractPageBlock == current) {
+                    continue;
+                }
+                if (abstractPageBlock instanceof TablePageBlock) {
+                    continue;
+                }
+
+                if (isHeadlineFromOutline(current) || isHeadlineFromOutline(abstractPageBlock)) {
+                    continue;
+                }
+
+                TextPageBlock inner = (TextPageBlock) abstractPageBlock;
+
+                if (usedRulings.lineBetween(current, blocks.get(i))) {
+                    continue;
+                }
+
+                if (current.getDir() == inner.getDir() && current.intersects(inner, yThreshold, xThreshold) && (current.getClassification() == null || current.getClassification()
+                        .equals(inner.getClassification()))) {
+
+                    boolean toDuplicate = current.isToDuplicate() || inner.isToDuplicate();
+                    current.addAll(inner.getSequences());
+                    current = buildTextBlock(current.getSequences(), 0);
+                    current.setClassification(inner.getClassification());
+                    current.setToDuplicate(toDuplicate);
+                    blocks.set(i, null);
+                    itty.set(current);
+                }
+            }
+        }
+        var blocksIterator = blocks.iterator();
+        while (blocksIterator.hasNext()) {
+            if (blocksIterator.next() == null) {
+                blocksIterator.remove();
+            }
+        }
+    }
+
+
+    private boolean isHeadlineFromOutline(AbstractPageBlock abstractPageBlock) {
+
+        return abstractPageBlock.getEngines().contains(LayoutEngine.OUTLINE) && abstractPageBlock.getClassification() != null && abstractPageBlock.getClassification().isHeadline();
+    }
+
+
+    public static TextPageBlock buildTextBlock(List<TextPositionSequence> wordBlockList, int indexOnPage) {
+
+        return new TextPageBlock(wordBlockList);
+    }
 
 }
 

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

@@ -38,18 +38,18 @@ public class RedactManagerBlockificationService {
         List<TextPositionSequence> chunkWords = new ArrayList<>();
         List<AbstractPageBlock> chunkBlockList = new ArrayList<>();
 
-        float minX = 1000, maxX = 0, minY = 1000, maxY = 0;
+        double minX = 1000, maxX = 0, minY = 1000, maxY = 0;
         TextPositionSequence prev = null;
 
         boolean wasSplitted = false;
-        Float splitX1 = null;
+        Double 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 lineSeparation = word.getYDirAdj() - maxY > word.getHeight() * 1.25;
+            boolean startFromTop = prev != null && word.getYDirAdj() < prev.getYDirAdj() - prev.getTextHeight();
+            boolean splitByX = prev != null && maxX + 50 < word.getXDirAdj() && prev.getYDirAdj() == word.getYDirAdj();
+            boolean xIsBeforeFirstX = prev != null && word.getXDirAdj() < minX;
+            boolean newLineAfterSplit = prev != null && word.getYDirAdj() != prev.getYDirAdj() && wasSplitted && splitX1 != word.getXDirAdj();
             boolean isSplitByRuling = prev != null && usedRulings.lineBetween(prev, word);
             boolean splitByDir = prev != null && !prev.getDir().equals(word.getDir());
 
@@ -69,7 +69,7 @@ public class RedactManagerBlockificationService {
                 if (splitByX && !isSplitByRuling) {
                     wasSplitted = true;
                     cb1.setOrientation(Orientation.LEFT);
-                    splitX1 = word.getMinXDirAdj();
+                    splitX1 = word.getXDirAdj();
                 } else if (newLineAfterSplit && !isSplitByRuling) {
                     wasSplitted = false;
                     cb1.setOrientation(Orientation.RIGHT);
@@ -92,14 +92,14 @@ public class RedactManagerBlockificationService {
             chunkWords.add(word);
 
             prev = word;
-            if (word.getMinXDirAdj() < minX) {
-                minX = word.getMinXDirAdj();
+            if (word.getXDirAdj() < minX) {
+                minX = word.getXDirAdj();
             }
             if (word.getMaxXDirAdj() > maxX) {
                 maxX = word.getMaxXDirAdj();
             }
-            if (word.getMinYDirAdj() < minY) {
-                minY = word.getMinYDirAdj();
+            if (word.getYDirAdj() < minY) {
+                minY = word.getYDirAdj();
             }
             if (word.getMaxYDirAdj() > maxY) {
                 maxY = word.getMaxYDirAdj();
@@ -161,7 +161,6 @@ public class RedactManagerBlockificationService {
         }
         if (!textPositions.isEmpty()) {
             visualizations.addTextBlockVisualizations(chunkBlockList.stream()
-                                                              .map(tb -> (TextPageBlock) tb)
                                                               .toList(), textPositions.get(0).getPage());
         }
 

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

@@ -23,7 +23,7 @@ public class ClarifyndClassificationService {
 
     public void classifyDocument(ClassificationDocument document) {
 
-        List<Float> headlineFontSizes = document.getFontSizeCounter().getHighterThanMostPopular();
+        List<Double> headlineFontSizes = document.getFontSizeCounter().getValuesInReverseOrder();
 
         log.debug("Document FontSize counters are: {}", document.getFontSizeCounter().getCountPerValue());
 
@@ -35,7 +35,10 @@ public class ClarifyndClassificationService {
     }
 
 
-    private void classifyPage(HeadlineClassificationService headlineClassificationService, ClassificationPage page, ClassificationDocument document, List<Float> headlineFontSizes) {
+    private void classifyPage(HeadlineClassificationService headlineClassificationService,
+                              ClassificationPage page,
+                              ClassificationDocument document,
+                              List<Double> headlineFontSizes) {
 
         for (AbstractPageBlock textBlock : page.getTextBlocks()) {
             if (textBlock instanceof TextPageBlock) {
@@ -45,7 +48,11 @@ public class ClarifyndClassificationService {
     }
 
 
-    private void classifyBlock(HeadlineClassificationService headlineClassificationService, TextPageBlock textBlock, ClassificationPage page, ClassificationDocument document, List<Float> headlineFontSizes) {
+    private void classifyBlock(HeadlineClassificationService headlineClassificationService,
+                               TextPageBlock textBlock,
+                               ClassificationPage page,
+                               ClassificationDocument document,
+                               List<Double> headlineFontSizes) {
 
         var bodyTextFrame = page.getBodyTextFrame();
 
@@ -57,59 +64,58 @@ public class ClarifyndClassificationService {
             textBlock.setClassification(PageBlockType.PARAGRAPH);
             return;
         }
-        if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.HEADER) || PositionUtils.isOverBodyTextFrame(bodyTextFrame,
-                textBlock,
-                page.getRotation()) && (document.getFontSizeCounter().getMostPopular() == null || textBlock.getHighestFontSize() <= document.getFontSizeCounter()
+        if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.HEADER)
+            || PositionUtils.isOverBodyTextFrame(bodyTextFrame, textBlock, page.getRotation()) && (document.getFontSizeCounter().getMostPopular() == null
+                                                                                                   || textBlock.getHighestFontSize() <= document.getFontSizeCounter()
                 .getMostPopular())) {
             textBlock.setClassification(PageBlockType.PARAGRAPH);
 
-        } else if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.FOOTER) || PositionUtils.isUnderBodyTextFrame(bodyTextFrame,
-                textBlock,
-                page.getRotation()) && (document.getFontSizeCounter().getMostPopular() == null || textBlock.getHighestFontSize() <= document.getFontSizeCounter()
+        } else if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.FOOTER)
+                   || PositionUtils.isUnderBodyTextFrame(bodyTextFrame, textBlock, page.getRotation()) && (document.getFontSizeCounter().getMostPopular() == null
+                                                                                                           || textBlock.getHighestFontSize() <= document.getFontSizeCounter()
                 .getMostPopular())) {
             textBlock.setClassification(PageBlockType.PARAGRAPH);
-        } else if (page.getPageNumber() == 1 && (PositionUtils.getHeightDifferenceBetweenChunkWordAndDocumentWord(textBlock,
-                document.getTextHeightCounter().getMostPopular()) > 2.5 && textBlock.getHighestFontSize() > document.getFontSizeCounter().getMostPopular() || page.getTextBlocks()
-                .size() == 1)) {
+        } 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()) {
+        } 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)) {
-                    PageBlockType headlineType = PageBlockType.getHeadlineType(i);
-                    headlineClassificationService.classifyHeadline(textBlock, headlineType);
-                    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()) {
-            PageBlockType headlineType = PageBlockType.getHeadlineType(headlineFontSizes.size() + 1);
+            PageBlockType headlineType = HeadlineClassificationService.headlineClassByFontSize(textBlock, headlineFontSizes);
             headlineClassificationService.classifyHeadline(textBlock, headlineType);
             document.setHeadlines(true);
-        } else if (PositionUtils.isWithinBodyTextFrame(bodyTextFrame, textBlock) && textBlock.getMostPopularWordFontSize() == document.getFontSizeCounter()
-                .getMostPopular() && textBlock.getMostPopularWordStyle().equals("bold") && !document.getFontStyleCounter().getMostPopular().equals("bold")) {
+        } 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()) {
+
+            PageBlockType headlineType = HeadlineClassificationService.headlineClassByFontSize(textBlock, headlineFontSizes);
+            headlineClassificationService.classifyHeadline(textBlock, headlineType);
+            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()) {
+        } 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) {
+        } 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);

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

@@ -1,5 +1,6 @@
 package com.knecon.fforesight.service.layoutparser.processor.services.classification;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 import java.util.regex.Matcher;
@@ -24,20 +25,29 @@ import lombok.extern.slf4j.Slf4j;
 @RequiredArgsConstructor
 public class DocuMineClassificationService {
 
-    private static final Pattern HEADLINE_WITH_IDENTIFER_PATTERN = Pattern.compile("^([1-9]\\d?\\.){1,3}\\d{1,2}\\.?\\s[0-9A-Za-z \\[\\]]{2,50}", Pattern.CASE_INSENSITIVE);
-    private static final Pattern AT_LEAST_3_PATTERN = Pattern.compile("\\p{L}{3,}", Pattern.CASE_INSENSITIVE);
-    private static final Pattern HEADLINE_PATTTERN_WITH_SLASHES = Pattern.compile("^(\\d{1,1}\\.){1,3}\\d{1,2}\\.?\\s[a-z]{1,2}\\/[a-z]{1,2}.*");
+    private static final Pattern HEADLINE_WITH_2_IDENTIFER_PATTERN = Pattern.compile("^([1-9]\\d?\\.){1,3}\\d{1,2}\\.?\\s[a-z][0-9a-z \\[\\]]{2,50}", Pattern.CASE_INSENSITIVE);
+    private static final Pattern HEADLINE_WITH_SINGLE_IDENTIFER_PATTERN = Pattern.compile("^([0-9]\\.)\\s[a-z][0-9a-z \\[\\]]{2,50}", Pattern.CASE_INSENSITIVE);
+    private static final Pattern AT_LEAST_3_CHARS_PATTERN = Pattern.compile("\\p{L}{3,}", Pattern.CASE_INSENSITIVE);
+    private static final Pattern HEADLINE_PATTERN_WITH_SLASHES = Pattern.compile("^(\\d{1,1}\\.){1,3}\\d{1,2}\\.?\\s[a-z]{1,2}\\/[a-z]{1,2}.*");
+    private static final Pattern AMOUNT_PATTERN = Pattern.compile("^\\s*\\d+(?:\\.\\d+)?\\s*(?:ml|l|g|kg|mg|cm|mm|km|m|lb|oz|ppm|%|f)\\b", Pattern.CASE_INSENSITIVE);
+    private static final Pattern TABLE_OR_FIGURE_PATTER = Pattern.compile(
+            "^\\s*(?:table|continued\\s+table|appendix|figure)\\s+(?:[xvi]+|[a-z0-9]{1,3}(?:\\.[0-9]{1,3})*(?:-[0-9]{1,3})?)\\b",
+            Pattern.CASE_INSENSITIVE);
+
+    public static final int SEPARATION_THRESHOLD = 10; // if the min distance between a textblock and all its surrounding blocks, the regexes can be more lenient.
+    public static final int SURROUNDING_BLOCKS_RADIUS = 3; // number of surrounding blocks before and after the current textblock to be tested
 
 
     public void classifyDocument(ClassificationDocument document) {
 
-        List<Float> headlineFontSizes = document.getFontSizeCounter().getHighterThanMostPopular();
+        List<Double> headlineFontSizes = document.getFontSizeCounter().getValuesInReverseOrder();
 
         log.debug("Document FontSize counters are: {}", document.getFontSizeCounter().getCountPerValue());
 
         HeadlineClassificationService headlineClassificationService = new HeadlineClassificationService();
 
         for (ClassificationPage page : document.getPages()) {
+            document.getLayoutDebugLayer().addTextBlockVisualizations(page.getTextBlocks(), page.getPageNumber());
             classifyPage(headlineClassificationService, page, document, headlineFontSizes);
         }
     }
@@ -46,35 +56,64 @@ public class DocuMineClassificationService {
     private void classifyPage(HeadlineClassificationService headlineClassificationService,
                               ClassificationPage page,
                               ClassificationDocument document,
-                              List<Float> headlineFontSizes) {
+                              List<Double> headlineFontSizes) {
 
-        for (AbstractPageBlock textBlock : page.getTextBlocks()) {
+        List<AbstractPageBlock> textBlocks = page.getTextBlocks();
+        for (int i = 0; i < textBlocks.size(); i++) {
+            AbstractPageBlock textBlock = textBlocks.get(i);
             if (textBlock instanceof TextPageBlock) {
-                classifyBlock(headlineClassificationService, (TextPageBlock) textBlock, page, document, headlineFontSizes);
+                List<AbstractPageBlock> surroundingBlocks = getSurroundingBlocks(i, textBlocks);
+                classifyBlock(headlineClassificationService, (TextPageBlock) textBlock, surroundingBlocks, page, document, headlineFontSizes);
             }
         }
     }
 
 
+    private List<AbstractPageBlock> getSurroundingBlocks(int originalIndex, List<AbstractPageBlock> textBlocks) {
+
+        int start = Math.max(originalIndex - SURROUNDING_BLOCKS_RADIUS, 0);
+        int end = Math.min(originalIndex + SURROUNDING_BLOCKS_RADIUS, textBlocks.size());
+        List<AbstractPageBlock> surroundingBlocks = new ArrayList<>(2 * SURROUNDING_BLOCKS_RADIUS);
+        for (int i = start; i < end; i++) {
+            if (i == originalIndex) {
+                continue;
+            }
+            surroundingBlocks.add(textBlocks.get(i));
+        }
+        return surroundingBlocks;
+    }
+
+
     private void classifyBlock(HeadlineClassificationService headlineClassificationService,
                                TextPageBlock textBlock,
+                               List<AbstractPageBlock> surroundingBlocks,
                                ClassificationPage page,
                                ClassificationDocument document,
-                               List<Float> headlineFontSizes) {
+                               List<Double> headlineFontSizes) {
 
         log.debug("headlineFontSizes: {}", headlineFontSizes);
         var bodyTextFrame = page.getBodyTextFrame();
 
-        Matcher headlineWithIdentifierMatcher = HEADLINE_WITH_IDENTIFER_PATTERN.matcher(textBlock.toString());
-        Matcher atLeast3Matcher = AT_LEAST_3_PATTERN.matcher(textBlock.toString());
-        Matcher headlineWithSlashesMatcher = HEADLINE_PATTTERN_WITH_SLASHES.matcher(textBlock.toString());
+        Matcher headlineWith2IdentifierMatcher = HEADLINE_WITH_2_IDENTIFER_PATTERN.matcher(textBlock.toString());
+        Matcher atLeast3Matcher = AT_LEAST_3_CHARS_PATTERN.matcher(textBlock.toString());
+        Matcher headlineWithSlashesMatcher = HEADLINE_PATTERN_WITH_SLASHES.matcher(textBlock.toString());
+        Matcher amountMatcher = AMOUNT_PATTERN.matcher(textBlock.toString());
+        Matcher tableOrFigureMatcher = TABLE_OR_FIGURE_PATTER.matcher(textBlock.toString());
+        Matcher headlineWithSingleIdentifierMatcher = HEADLINE_WITH_SINGLE_IDENTIFER_PATTERN.matcher(textBlock.toString());
+        boolean isAtLeast3Characters = atLeast3Matcher.reset().find();
+        boolean isTocItem = textBlock.getText().contains("..............");
+        boolean headlineWithSlashesMatches = headlineWithSlashesMatcher.reset().matches();
+        boolean isAmount = amountMatcher.reset().find();
+        int charCount = countChars(textBlock);
+
+        boolean enoughChars = charCount > textBlock.getText().length() * 0.5;
 
         if (textBlock.getClassification() != null && textBlock.getClassification().isHeadline()) {
             headlineClassificationService.setLastHeadlineFromOutline(textBlock);
             return;
         }
         if (document.getFontSizeCounter().getMostPopular() == null) {
-            textBlock.setClassification(PageBlockType.OTHER);
+            textBlock.setClassification(PageBlockType.PARAGRAPH);
             return;
         }
         if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.HEADER) //
@@ -103,50 +142,132 @@ public class DocuMineClassificationService {
                    && (textBlock.getMostPopularWordHeight() > document.getTextHeightCounter().getMostPopular()
                        || textBlock.getMostPopularWordFontSize() > document.getFontSizeCounter().getMostPopular())
                    && PositionUtils.getApproxLineCount(textBlock) < 5.9
-
-                   && (textBlock.getMostPopularWordStyle().contains("bold")
-                       && Character.isDigit(textBlock.toString().charAt(0))
-                       && atLeast3Matcher.reset().find()
+                   && ((textBlock.getMostPopularWordStyle().contains("bold") || textBlock.isUnderlined())//
+                       && Character.isDigit(textBlock.toString().charAt(0)) //
+                       && isAtLeast3Characters //
                        && !textBlock.toString().contains(":") //
-                       || textBlock.toString().equals(textBlock.toString().toUpperCase(Locale.ROOT)) && atLeast3Matcher.reset().find() && !textBlock.toString().contains(":") //
                        || textBlock.toString().startsWith("APPENDIX") //
                        || textBlock.toString().startsWith("FIGURE") //
                        || textBlock.toString().startsWith("Continued TABLE") //
                        || textBlock.toString().startsWith("TABLE"))
                    && !textBlock.toString().endsWith(":")
-                   && atLeast3Matcher.reset().find()) {
-            PageBlockType headlineType = PageBlockType.getHeadlineType(1);
-            headlineClassificationService.classifyHeadline(textBlock, headlineType);
-            document.setHeadlines(true);
+                   && isAtLeast3Characters
+                   && !isTocItem
+                   && !isAmount
+                   && enoughChars) {
 
-        } else if (headlineWithIdentifierMatcher.reset().find()
+            setAsHeadline(headlineClassificationService, textBlock, document, headlineFontSizes);
+        } else if (isAllCaps(textBlock)
+                   && textBlock.getText().length() > 5
+                   && isAtLeast3Characters
+                   && !isAmount
+                   && enoughChars
+                   && !textBlock.toString().contains(":")
+                   && !textBlock.toString().startsWith("(")
+                   && PositionUtils.getApproxLineCount(textBlock) < 2.9) {
+
+            setAsHeadline(headlineClassificationService, textBlock, document, headlineFontSizes);
+        } else if (headlineWith2IdentifierMatcher.reset().find()
                    && PositionUtils.getApproxLineCount(textBlock) < 2.9
-                   && atLeast3Matcher.reset().find()
-                   && !headlineWithSlashesMatcher.reset().matches()) {
-            PageBlockType headlineType = PageBlockType.getHeadlineType(2);
-            headlineClassificationService.classifyHeadline(textBlock, headlineType);
-            document.setHeadlines(true);
+                   && isAtLeast3Characters
+                   && !headlineWithSlashesMatches
+                   && !isAmount
+                   && !isTocItem) {
+
+            setAsHeadline(headlineClassificationService, textBlock, document, headlineFontSizes);
+        } else if (!isTocItem
+                   && hasSeparation(textBlock, surroundingBlocks)
+                   && greaterOrEqualThanFontPageAverage(textBlock, page)
+                   && PositionUtils.getApproxLineCount(textBlock) < 2.9
+                   && (tableOrFigureMatcher.reset().find() || headlineWithSingleIdentifierMatcher.reset().find())
+                   && !isAmount
+                   && !headlineWithSlashesMatches) {
+
+            setAsHeadline(headlineClassificationService, textBlock, document, headlineFontSizes);
         } 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);
+            textBlock.setClassification(PageBlockType.PARAGRAPH);
         }
     }
 
-}
+
+    private int countChars(TextPageBlock textBlock) {
+
+        int count = 0;
+
+        for (int i = 0; i < textBlock.getText().length(); i++) {
+            if (Character.isAlphabetic(textBlock.getText().charAt(i))) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+
+    private static boolean greaterOrEqualThanFontPageAverage(TextPageBlock textBlock, ClassificationPage page) {
+
+        return textBlock.getMostPopularWordHeight() >= page.getTextHeightCounter().getMostPopular() //
+               || textBlock.getMostPopularWordFontSize() >= page.getFontSizeCounter().getMostPopular();
+    }
+
+
+    private static boolean isAllCaps(TextPageBlock textBlock) {
+
+        return textBlock.toString().equals(textBlock.toString().toUpperCase(Locale.ROOT));
+    }
+
+
+    private boolean hasSeparation(TextPageBlock textBlock, List<AbstractPageBlock> surroundingBlocks) {
+
+        return surroundingBlocks.stream()
+                .allMatch(surroundingBlock -> calculateSeparation(textBlock, surroundingBlock) > Math.pow(SEPARATION_THRESHOLD, 2));
+    }
+
+
+    private double calculateMinSeparation(TextPageBlock textBlock, List<AbstractPageBlock> surroundingBlocks) {
+
+        return surroundingBlocks.stream()
+                .mapToDouble(surroundingBlock -> calculateSeparation(textBlock, surroundingBlock))
+                .min()
+                .orElse(Double.MAX_VALUE);
+    }
+
+
+    private static double calculateSeparation(TextPageBlock textBlock, AbstractPageBlock surroundingBlock) {
+
+        return Math.pow(surroundingBlock.horizontalDistance(textBlock), 2) + Math.pow(surroundingBlock.verticalDistance(textBlock), 2);
+    }
+
+
+    private static void setAsHeadline(HeadlineClassificationService headlineClassificationService,
+                                      TextPageBlock textBlock,
+                                      ClassificationDocument document,
+                                      List<Double> headlineFontSizes) {
+
+        PageBlockType headlineType = HeadlineClassificationService.headlineClassByFontSize(textBlock, headlineFontSizes);
+        headlineClassificationService.classifyHeadline(textBlock, headlineType);
+        document.setHeadlines(true);
+    }
+
+}
+
+
+

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

@@ -2,7 +2,10 @@ package com.knecon.fforesight.service.layoutparser.processor.services.classifica
 
 import static com.knecon.fforesight.service.layoutparser.processor.model.PageBlockType.getHeadlineNumber;
 
+import java.util.List;
+
 import com.knecon.fforesight.service.layoutparser.processor.model.PageBlockType;
+import com.knecon.fforesight.service.layoutparser.processor.model.SectionIdentifier;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
 
 import lombok.Getter;
@@ -16,6 +19,7 @@ public class HeadlineClassificationService {
     PageBlockType originalClassifiedBlockType;
     TextPageBlock lastHeadlineFromOutline;
 
+
     public void setLastHeadlineFromOutline(TextPageBlock lastHeadlineFromOutline) {
 
         this.lastHeadlineFromOutline = lastHeadlineFromOutline;
@@ -25,28 +29,57 @@ public class HeadlineClassificationService {
 
     public void classifyHeadline(TextPageBlock textBlock, PageBlockType initialHeadlineType) {
 
-        TextPageBlock lastHeadline = getLastHeadline();
-        TextPageBlock lastHeadlineFromOutline = getLastHeadlineFromOutline();
-        PageBlockType originalClassifiedBlockType = getOriginalClassifiedBlockType();
         PageBlockType finalHeadlineType = initialHeadlineType;
 
         if (lastHeadline != null) {
 
-            if (lastHeadline.equals(lastHeadlineFromOutline)) {
-
-                finalHeadlineType = PageBlockType.getHeadlineType(getHeadlineNumber(lastHeadline.getClassification()) + 1);
-
-            } else if (originalClassifiedBlockType != null && lastHeadline.getClassification() != originalClassifiedBlockType) {
-
-                PageBlockType lastHeadlineType = lastHeadline.getClassification();
-                int difference = getHeadlineNumber(originalClassifiedBlockType) - getHeadlineNumber(lastHeadlineType);
-                finalHeadlineType = PageBlockType.getHeadlineType(getHeadlineNumber(initialHeadlineType) - difference);
-            }
+            finalHeadlineType = decideOnClassification(textBlock, initialHeadlineType);
         }
 
-        setOriginalClassifiedBlockType(initialHeadlineType);
+        lastHeadline = textBlock;
+        originalClassifiedBlockType = initialHeadlineType;
         textBlock.setClassification(finalHeadlineType);
-        setLastHeadline(textBlock);
+    }
+
+
+    private PageBlockType decideOnClassification(TextPageBlock textBlock, PageBlockType initialHeadlineType) {
+
+        SectionIdentifier identifier = SectionIdentifier.fromSearchText(textBlock.getText());
+        TextPageBlock lastHeadlineFromOutline = getLastHeadlineFromOutline();
+        PageBlockType originalClassifiedBlockType = getOriginalClassifiedBlockType();
+
+        if (!identifier.isEmpty()) {
+            return PageBlockType.getHeadlineType(identifier.level());
+        }
+
+        if (lastHeadline.equals(lastHeadlineFromOutline) && lastHeadline.getMostPopularWordFontSize() >= textBlock.getMostPopularWordFontSize()) {
+
+            return PageBlockType.getHeadlineType(getHeadlineNumber(lastHeadline.getClassification()) + 1);
+
+        } else if (originalClassifiedBlockType != null && lastHeadline.getClassification() != originalClassifiedBlockType) {
+
+            return adjustInitialLevelToLastHeadlineLevel(initialHeadlineType);
+        }
+        return initialHeadlineType;
+    }
+
+
+    private PageBlockType adjustInitialLevelToLastHeadlineLevel(PageBlockType initialHeadlineType) {
+
+        int difference = getHeadlineNumber(originalClassifiedBlockType) - getHeadlineNumber(lastHeadline.getClassification());
+        return PageBlockType.getHeadlineType(Math.max(1, getHeadlineNumber(initialHeadlineType) - difference));
+    }
+
+
+    public static PageBlockType headlineClassByFontSize(TextPageBlock textBlock, List<Double> fontSizeGroups) {
+
+        PageBlockType headlineType = PageBlockType.H1;
+        for (int i = 1; i <= fontSizeGroups.size(); i++) {
+            if (textBlock.getMostPopularWordFontSize() == fontSizeGroups.get(i - 1)) {
+                headlineType = PageBlockType.getHeadlineType(i);
+            }
+        }
+        return headlineType;
     }
 
 }

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

@@ -22,10 +22,9 @@ import lombok.extern.slf4j.Slf4j;
 @RequiredArgsConstructor
 public class RedactManagerClassificationService {
 
-
     public void classifyDocument(ClassificationDocument document) {
 
-        List<Float> headlineFontSizes = document.getFontSizeCounter().getHighterThanMostPopular();
+        List<Double> headlineFontSizes = document.getFontSizeCounter().getValuesInReverseOrder();
 
         log.debug("Document FontSize counters are: {}", document.getFontSizeCounter().getCountPerValue());
 
@@ -37,7 +36,10 @@ public class RedactManagerClassificationService {
     }
 
 
-    private void classifyPage(HeadlineClassificationService headlineClassificationService, ClassificationPage page, ClassificationDocument document, List<Float> headlineFontSizes) {
+    private void classifyPage(HeadlineClassificationService headlineClassificationService,
+                              ClassificationPage page,
+                              ClassificationDocument document,
+                              List<Double> headlineFontSizes) {
 
         for (AbstractPageBlock textBlock : page.getTextBlocks()) {
             if (textBlock instanceof TextPageBlock) {
@@ -47,7 +49,11 @@ public class RedactManagerClassificationService {
     }
 
 
-    private void classifyBlock(HeadlineClassificationService headlineClassificationService, TextPageBlock textBlock, ClassificationPage page, ClassificationDocument document, List<Float> headlineFontSizes) {
+    private void classifyBlock(HeadlineClassificationService headlineClassificationService,
+                               TextPageBlock textBlock,
+                               ClassificationPage page,
+                               ClassificationDocument document,
+                               List<Double> headlineFontSizes) {
 
         var bodyTextFrame = page.getBodyTextFrame();
 
@@ -56,7 +62,7 @@ public class RedactManagerClassificationService {
             return;
         }
         if (document.getFontSizeCounter().getMostPopular() == null) {
-            textBlock.setClassification(PageBlockType.OTHER);
+            textBlock.setClassification(PageBlockType.PARAGRAPH);
             return;
         }
 
@@ -71,15 +77,18 @@ public class RedactManagerClassificationService {
             || PositionUtils.isOverBodyTextFrame(bodyTextFrame, textBlock, page.getRotation()) && (document.getFontSizeCounter().getMostPopular() == null
                                                                                                    || textBlock.getHighestFontSize() <= document.getFontSizeCounter()
                 .getMostPopular())) {
+
             textBlock.setClassification(PageBlockType.HEADER);
 
         } else if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.FOOTER)
                    || PositionUtils.isUnderBodyTextFrame(bodyTextFrame, textBlock, page.getRotation()) && (document.getFontSizeCounter().getMostPopular() == null
                                                                                                            || textBlock.getHighestFontSize() <= document.getFontSizeCounter()
                 .getMostPopular())) {
+
             textBlock.setClassification(PageBlockType.FOOTER);
         } else if (page.getPageNumber() == 1 && (PositionUtils.getHeightDifferenceBetweenChunkWordAndDocumentWord(textBlock, document.getTextHeightCounter().getMostPopular()) > 2.5
                                                  && textBlock.getHighestFontSize() > document.getFontSizeCounter().getMostPopular() || page.getTextBlocks().size() == 1)) {
+
             if (!Pattern.matches("[0-9]+", textBlock.toString())) {
                 textBlock.setClassification(PageBlockType.TITLE);
             }
@@ -88,48 +97,45 @@ public class RedactManagerClassificationService {
                    && (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()) {
+                   && 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)) {
-                    PageBlockType headlineType = PageBlockType.getHeadlineType(i);
-                    headlineClassificationService.classifyHeadline(textBlock, headlineType);
-                    document.setHeadlines(true);
-                }
-            }
+            PageBlockType headlineType = HeadlineClassificationService.headlineClassByFontSize(textBlock, headlineFontSizes);
+            headlineClassificationService.classifyHeadline(textBlock, headlineType);
+            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()) {
-            PageBlockType headlineType = PageBlockType.getHeadlineType(headlineFontSizes.size() + 1);
+                   && textBlock.getSequences().get(0).getTextPositions().get(0).getFontSizeInPt() >= textBlock.getMostPopularWordFontSize()) {
+
+            PageBlockType headlineType = HeadlineClassificationService.headlineClassByFontSize(textBlock, headlineFontSizes);
             headlineClassificationService.classifyHeadline(textBlock, headlineType);
             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);
+            textBlock.setClassification(PageBlockType.PARAGRAPH);
         }
     }
 

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

@@ -6,6 +6,7 @@ import static java.util.stream.Collectors.toList;
 
 import java.awt.geom.Rectangle2D;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
@@ -15,6 +16,7 @@ import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
 import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingType;
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationDocument;
@@ -32,7 +34,9 @@ import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.He
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Image;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Page;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Paragraph;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.SemanticNode;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.AtomicTextBlock;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.image.ClassifiedImage;
 import com.knecon.fforesight.service.layoutparser.processor.model.outline.TableOfContentItem;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
@@ -61,22 +65,38 @@ public class DocumentGraphFactory {
 
         document.getPages()
                 .forEach(context::buildAndAddPageWithCounter);
-        addSections(layoutParsingType, document, context, documentGraph);
+        addSectionsForToC(layoutParsingType, document, context, documentGraph);
         addHeaderAndFooterToEachPage(document, context);
 
         documentGraph.setNumberOfPages(context.pages.size());
         documentGraph.setPages(context.pages.keySet());
         documentGraph.setDocumentTree(context.documentTree);
         documentGraph.setTextBlock(documentGraph.getTextBlock());
+        addTextBlocksToPages(documentGraph);
+
         return documentGraph;
     }
 
 
-    private void addSections(LayoutParsingType layoutParsingType, ClassificationDocument classificationDocument, Context context, Document document) {
+    private void addTextBlocksToPages(Document documentGraph) {
+
+        documentGraph.streamAllSubNodes()
+                .filter(SemanticNode::isLeaf)
+                .filter(node -> !node.getType().equals(NodeType.HEADER))
+                .filter(node -> !node.getType().equals(NodeType.FOOTER))
+                .filter(node -> !node.getType().equals(NodeType.IMAGE))
+                .map(SemanticNode::getTextBlock)
+                .map(TextBlock::getAtomicTextBlocks)
+                .flatMap(Collection::stream)
+                .forEach(atb -> atb.getPage().getTextBlocksOnPage().add(atb));
+    }
+
+
+    private void addSectionsForToC(LayoutParsingType layoutParsingType, ClassificationDocument classificationDocument, Context context, Document document) {
 
         for (TableOfContentItem tocItem : classificationDocument.getTableOfContents()) {
-            var parent = tocItem.getParent() == null ? null : tocItem.getParent().getSection();
-            Optional<AbstractSemanticNode> section = SectionNodeFactory.addSection(layoutParsingType,
+            GenericSemanticNode parent = tocItem.getParent() == null ? null : tocItem.getParent().getSection();
+            Optional<GenericSemanticNode> section = SectionNodeFactory.addSection(layoutParsingType,
                                                                                    parent,
                                                                                    tocItem.getChildren().isEmpty(),
                                                                                    tocItem.getNonEmptySectionBlocks(),
@@ -105,19 +125,17 @@ public class DocumentGraphFactory {
             node = Paragraph.builder().documentTree(context.getDocumentTree()).build();
         }
 
-        page.getMainBody().add(node);
-
         List<TextPageBlock> textBlocks = new ArrayList<>();
         textBlocks.add(originalTextBlock);
         textBlocks.addAll(textBlocksToMerge);
 
-        AtomicTextBlock textBlock = context.textBlockFactory.buildAtomicTextBlock(TextPositionOperations.mergeAndSortTextPositionSequenceByYThenX(textBlocks), node, context, page);
+        AtomicTextBlock textBlock = context.textBlockFactory.buildAtomicTextBlock(TextPositionOperations.mergeAndSort(textBlocks), node, context, page);
 
         if (node instanceof DuplicatedParagraph duplicatedParagraph) {
             AtomicTextBlock unsortedTextBlock = context.textBlockFactory.buildAtomicTextBlock(textBlocks.stream()
-                                                                                                      .flatMap(tb -> tb.getSequences()
-                                                                                                              .stream())
-                                                                                                      .collect(Collectors.toList()), node, context, page);
+                                                                                                       .flatMap(tb -> tb.getSequences()
+                                                                                                               .stream())
+                                                                                                       .collect(Collectors.toList()), node, context, page);
             duplicatedParagraph.setUnsortedLeafTextBlock(unsortedTextBlock);
         }
 
@@ -141,7 +159,7 @@ public class DocumentGraphFactory {
 
         Rectangle2D position = image.getPosition();
         Page page = context.getPage(image.getPage());
-        Image imageNode = Image.builder()
+        return Image.builder()
                 .id(IdBuilder.buildId(Set.of(page), List.of(position)))
                 .imageType(image.getImageType())
                 .position(position)
@@ -150,8 +168,6 @@ public class DocumentGraphFactory {
                 .representationHash(image.getRepresentation())
                 .documentTree(context.getDocumentTree())
                 .build();
-        page.getMainBody().add(imageNode);
-        return imageNode;
     }
 
 
@@ -191,7 +207,7 @@ public class DocumentGraphFactory {
 
         Page page = context.getPage(textBlocks.get(0).getPage());
         Footer footer = Footer.builder().documentTree(context.getDocumentTree()).build();
-        AtomicTextBlock textBlock = context.textBlockFactory.buildAtomicTextBlock(TextPositionOperations.mergeTextPositionSequence(textBlocks), footer, context, page);
+        AtomicTextBlock textBlock = context.textBlockFactory.buildAtomicTextBlock(TextPositionOperations.merge(textBlocks), footer, context, page);
         List<Integer> tocId = context.getDocumentTree().createNewMainEntryAndReturnId(footer);
         footer.setTreeId(tocId);
         footer.setLeafTextBlock(textBlock);
@@ -203,7 +219,7 @@ public class DocumentGraphFactory {
 
         Page page = context.getPage(textBlocks.get(0).getPage());
         Header header = Header.builder().documentTree(context.getDocumentTree()).build();
-        AtomicTextBlock textBlock = context.textBlockFactory.buildAtomicTextBlock(TextPositionOperations.mergeTextPositionSequence(textBlocks), header, 0, page);
+        AtomicTextBlock textBlock = context.textBlockFactory.buildAtomicTextBlock(TextPositionOperations.merge(textBlocks), header, 0, page);
         List<Integer> tocId = context.getDocumentTree().createNewMainEntryAndReturnId(header);
         header.setTreeId(tocId);
         header.setLeafTextBlock(textBlock);
@@ -244,7 +260,6 @@ public class DocumentGraphFactory {
         DocumentTree documentTree;
         Map<Page, Integer> pages;
         List<AbstractSemanticNode> sections;
-        List<ClassifiedImage> images;
         TextBlockFactory textBlockFactory;
 
 
@@ -253,7 +268,6 @@ public class DocumentGraphFactory {
             documentTree = new DocumentTree(document);
             pages = new HashMap<>();
             sections = new LinkedList<>();
-            images = new LinkedList<>();
             textBlockFactory = new TextBlockFactory();
         }
 

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

@@ -1,6 +1,7 @@
 package com.knecon.fforesight.service.layoutparser.processor.services.factory;
 
-import java.awt.geom.AffineTransform;
+import static com.knecon.fforesight.service.layoutparser.processor.model.text.RedTextPosition.HEIGHT_PADDING;
+
 import java.awt.geom.Rectangle2D;
 import java.util.Collection;
 import java.util.Collections;
@@ -11,7 +12,6 @@ import java.util.Objects;
 
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.TextRange;
 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.TextPositionSequence;
 
 import lombok.experimental.UtilityClass;
@@ -19,14 +19,13 @@ import lombok.experimental.UtilityClass;
 @UtilityClass
 public class SearchTextWithTextPositionFactory {
 
-    public final int HEIGHT_PADDING = 2;
     // when checking for a hyphen linebreak, we need to check after a linebreak if the last hyphen was less than three symbols away.
     // We detect a linebreak as either a "\n" character or if two adjacent symbol's position differ in y-coordinates by at least one character height.
     // If there is a hyphen linebreak, the hyphen will be 1 position in front of a "\n" or 2 positions in front of the character which has a lower y-coordinate
     // This is why, we need to initialize this to < -2, otherwise, if the very first symbol is a \n we would detect a hyphen linebreak that isn't there.
     // Also, Integer.MIN_VALUE is a bad idea due to potential overflow during arithmetic operations. This is why the default should be -3.
     public final int MAX_HYPHEN_LINEBREAK_DISTANCE = 3;
-    public static final double LINEBREAK_DELTA_TOLERANCE = 1.05;
+    public static final double LINEBREAK_DELTA_TOLERANCE = 1.5;
 
 
     public SearchTextWithTextPositionDto buildSearchTextToTextPositionDto(List<TextPositionSequence> sequences) {
@@ -38,15 +37,13 @@ public class SearchTextWithTextPositionFactory {
 
         Context context = new Context();
 
-        RedTextPosition currentTextPosition = sequences.get(0).getTextPositions()
-                .get(0);
+        RedTextPosition currentTextPosition = sequences.get(0).getTextPositions().get(0);
         RedTextPosition previousTextPosition = RedTextPosition.builder().unicode(" ").bBoxDirAdj(currentTextPosition.getBBoxDirAdj()).build();
 
         for (TextPositionSequence word : sequences) {
             for (int i = 0; i < word.getTextPositions().size(); ++i) {
 
-                currentTextPosition = word.getTextPositions()
-                        .get(i);
+                currentTextPosition = word.getTextPositions().get(i);
                 if (isLineBreak(currentTextPosition, previousTextPosition)) {
                     removeHyphenLinebreaks(context);
                     context.lineBreaksStringIdx.add(context.stringIdx);
@@ -68,11 +65,10 @@ public class SearchTextWithTextPositionFactory {
             ++context.stringIdx;
         }
 
-
         List<Rectangle2D> positions = sequences.stream()
                 .map(TextPositionSequence::getTextPositions)
                 .flatMap(Collection::stream)
-                .map(RedTextPosition::getBBoxInitialUserSpace)
+                .map(RedTextPosition::getBBoxPdf)
                 .toList();
 
         assert context.stringBuilder.length() == context.stringIdxToPositionIdx.size();
@@ -161,8 +157,8 @@ public class SearchTextWithTextPositionFactory {
             return false;
         }
 
-        double deltaY = Math.abs(currentPosition.getYDirAdj() - previousPosition.getYDirAdj()) * LINEBREAK_DELTA_TOLERANCE;
-        return deltaY >= currentPosition.getHeightDir() || deltaY >= previousPosition.getHeightDir();
+        double deltaY = (Math.abs(currentPosition.getYDirAdj() - previousPosition.getYDirAdj()) * LINEBREAK_DELTA_TOLERANCE) + (2 * HEIGHT_PADDING);
+        return deltaY >= currentPosition.getHeightDirAdj() || deltaY >= previousPosition.getHeightDirAdj();
     }
 
 
@@ -188,32 +184,6 @@ public class SearchTextWithTextPositionFactory {
     }
 
 
-    public Rectangle2D mapRedTextPositionToInitialUserSpace(RedTextPosition textPosition, TextPositionSequence sequence) {
-
-        float textHeight = sequence.getTextHeight() + HEIGHT_PADDING;
-        Rectangle2D rectangle2D = new Rectangle2D.Double(textPosition.getXDirAdj(),
-                textPosition.getYDirAdj() - textHeight,
-                textPosition.getWidthDirAdj(),
-                textHeight + HEIGHT_PADDING);
-
-        AffineTransform transform = new AffineTransform();
-
-        if (sequence.getDir() == TextDirection.ZERO || sequence.getDir() == TextDirection.HALF_CIRCLE) {
-            transform.rotate(sequence.getDir().getRadians(), sequence.getPageWidth() / 2f, sequence.getPageHeight() / 2f);
-            transform.translate(0f, sequence.getPageHeight());
-        } else if (sequence.getDir() == TextDirection.QUARTER_CIRCLE) {
-            transform.rotate(sequence.getDir().getRadians(), sequence.getPageWidth() / 2f, sequence.getPageWidth() / 2f);
-            transform.translate(0f, sequence.getPageWidth());
-        } else {
-            transform.rotate(sequence.getDir().getRadians(), sequence.getPageHeight() / 2f, sequence.getPageHeight() / 2f);
-            transform.translate(0f, sequence.getPageWidth());
-        }
-        transform.scale(1., -1.);
-
-        return transform.createTransformedShape(rectangle2D).getBounds2D();
-    }
-
-
     private class Context {
 
         List<Integer> stringIdxToPositionIdx = new LinkedList<>();

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

@@ -2,13 +2,11 @@ package com.knecon.fforesight.service.layoutparser.processor.services.factory;
 
 import static java.lang.String.format;
 import static java.util.Collections.emptyList;
-import static java.util.stream.Collectors.groupingBy;
 
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 
@@ -17,7 +15,6 @@ import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBl
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.AbstractSemanticNode;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Document;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.GenericSemanticNode;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Page;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Section;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.SuperSection;
 import com.knecon.fforesight.service.layoutparser.processor.model.image.ClassifiedImage;
@@ -30,13 +27,13 @@ import lombok.experimental.UtilityClass;
 @UtilityClass
 public class SectionNodeFactory {
 
-    public Optional<AbstractSemanticNode> addSection(LayoutParsingType layoutParsingType,
-                                                     GenericSemanticNode parentNode,
-                                                     boolean isLeaf,
-                                                     List<AbstractPageBlock> pageBlocks,
-                                                     List<ClassifiedImage> images,
-                                                     DocumentGraphFactory.Context context,
-                                                     Document document) {
+    public Optional<GenericSemanticNode> addSection(LayoutParsingType layoutParsingType,
+                                                    GenericSemanticNode parentNode,
+                                                    boolean isLeaf,
+                                                    List<AbstractPageBlock> pageBlocks,
+                                                    List<ClassifiedImage> images,
+                                                    DocumentGraphFactory.Context context,
+                                                    Document document) {
 
         // This is for the case where we have images on a page without any text/footer/header.
         // The pageBlocks list is empty, but we still need to add those images to the document.
@@ -51,24 +48,19 @@ public class SectionNodeFactory {
             return Optional.empty();
         }
 
-        Map<Integer, List<AbstractPageBlock>> blocksPerPage = pageBlocks.stream()
-                .collect(groupingBy(AbstractPageBlock::getPage));
-
         AbstractSemanticNode section;
-        boolean containsTablesAndTextBlocks = containsTablesAndTextBlocks(pageBlocks);
-        if (isLeaf && !containsTablesAndTextBlocks) {
+        if (isLeaf) {
             section = Section.builder().documentTree(context.getDocumentTree()).build();
         } else {
             section = SuperSection.builder().documentTree(context.getDocumentTree()).build();
         }
 
         context.getSections().add(section);
-        blocksPerPage.keySet()
-                .forEach(pageNumber -> addSectionNodeToPageNode(context, section, pageNumber));
 
         section.setTreeId(getTreeId(parentNode, context, section));
 
         addFirstHeadlineDirectlyToSection(layoutParsingType, pageBlocks, context, section, document);
+        boolean containsTablesAndTextBlocks = containsTablesAndTextBlocks(pageBlocks);
         if (containsTablesAndTextBlocks) {
             splitPageBlocksIntoSubSections(pageBlocks).forEach(subSectionPageBlocks -> addSection(layoutParsingType,
                                                                                                   section,
@@ -158,7 +150,8 @@ public class SectionNodeFactory {
     private boolean containsTablesAndTextBlocks(List<AbstractPageBlock> pageBlocks) {
 
         return pageBlocks.stream()
-                       .anyMatch(pageBlock -> pageBlock instanceof TablePageBlock) && pageBlocks.stream()
+                       .anyMatch(pageBlock -> pageBlock instanceof TablePageBlock) //
+               && pageBlocks.stream()
                        .anyMatch(pageBlock -> pageBlock instanceof TextPageBlock);
     }
 
@@ -234,18 +227,11 @@ public class SectionNodeFactory {
                 .filter(abstractTextContainer -> !abstractTextContainer.equals(atc))
                 .filter(abstractTextContainer -> abstractTextContainer.getPage() == atc.getPage())
                 .filter(abstractTextContainer -> abstractTextContainer instanceof TextPageBlock)
-                .filter(abstractTextContainer -> abstractTextContainer.intersectsY(atc))
+                .filter(abstractTextContainer -> abstractTextContainer.intersectsYPdf(atc))
                 .map(abstractTextContainer -> (TextPageBlock) abstractTextContainer)
                 .filter(abstractTextContainer -> abstractTextContainer.getDir() == atc.getDir())
                 .filter(abstractTextContainer -> !abstractTextContainer.isToDuplicate())
                 .toList();
     }
 
-
-    private void addSectionNodeToPageNode(DocumentGraphFactory.Context context, AbstractSemanticNode section, Integer pageNumber) {
-
-        Page page = context.getPage(pageNumber);
-        page.getMainBody().add(section);
-    }
-
 }

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

@@ -4,7 +4,6 @@ import static java.util.Collections.emptyList;
 
 import java.util.Collection;
 import java.util.List;
-import java.util.Set;
 import java.util.stream.Collectors;
 
 import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingType;
@@ -12,7 +11,6 @@ import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBl
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Document;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.GenericSemanticNode;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Page;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.SemanticNode;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Table;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.TableCell;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;
@@ -36,10 +34,7 @@ public class TableNodeFactory {
                          Document document) {
 
         setPageNumberInCells(tablesToMerge);
-        Set<Page> pages = tablesToMerge.stream()
-                .map(AbstractPageBlock::getPage)
-                .map(context::getPage)
-                .collect(Collectors.toSet());
+
         List<List<Cell>> mergedRows = tablesToMerge.stream()
                 .map(TablePageBlock::getRows)
                 .flatMap(Collection::stream)
@@ -51,8 +46,6 @@ public class TableNodeFactory {
                 .numberOfRows(mergedRows.size())
                 .build();
 
-        pages.forEach(page -> addTableToPage(page, parentNode, table));
-
         List<Integer> treeId = context.getDocumentTree().createNewChildEntryAndReturnId(parentNode, table);
         table.setTreeId(treeId);
         addTableCells(layoutParsingType, mergedRows, table, context, document);
@@ -82,17 +75,6 @@ public class TableNodeFactory {
     }
 
 
-    @SuppressWarnings("PMD.UnusedPrivateMethod") // PMD actually flags this wrong
-    private void addTableToPage(Page page, SemanticNode parentNode, Table table) {
-
-        if (!page.getMainBody().contains(parentNode)) {
-            parentNode.getPages().add(page);
-        }
-
-        page.getMainBody().add(table);
-    }
-
-
     private void ifTableHasNoHeadersSetFirstRowAsHeaders(Table table) {
 
         if (table.streamHeaders()
@@ -107,14 +89,7 @@ public class TableNodeFactory {
 
         for (int rowIndex = 0; rowIndex < rows.size(); rowIndex++) {
             for (int colIndex = 0; colIndex < rows.get(rowIndex).size(); colIndex++) {
-                addTableCell(layoutParsingType,
-                             rows.get(rowIndex)
-                                     .get(colIndex),
-                             rowIndex,
-                             colIndex,
-                             table,
-                             context,
-                             document);
+                addTableCell(layoutParsingType, rows.get(rowIndex).get(colIndex), rowIndex, colIndex, table, context, document);
             }
         }
     }
@@ -131,14 +106,7 @@ public class TableNodeFactory {
 
         Page page = context.getPage(cell.getPageNumber());
 
-        TableCell tableCell = TableCell.builder()
-                .documentTree(context.getDocumentTree())
-                .row(rowIndex)
-                .col(colIndex)
-                .header(cell.isHeaderCell())
-                .bBox(cell.getBBoxInitialUserSpace())
-                .build();
-        page.getMainBody().add(tableCell);
+        TableCell tableCell = TableCell.builder().documentTree(context.getDocumentTree()).row(rowIndex).col(colIndex).header(cell.isHeaderCell()).bBox(cell.getBBoxPdf()).build();
 
         List<Integer> treeId = context.getDocumentTree().createNewTableChildEntryAndReturnId(tableNode, tableCell);
         tableCell.setTreeId(treeId);
@@ -147,9 +115,7 @@ public class TableNodeFactory {
         if (cell.getTextBlocks().isEmpty()) {
             tableCell.setLeafTextBlock(context.getTextBlockFactory().emptyTextBlock(tableNode, context, page));
         } else if (cell.getTextBlocks().size() == 1) {
-            textBlock = context.getTextBlockFactory()
-                    .buildAtomicTextBlock(cell.getTextBlocks()
-                                                  .get(0).getSequences(), tableCell, context, page);
+            textBlock = context.getTextBlockFactory().buildAtomicTextBlock(cell.getTextBlocks().get(0).getSequences(), tableCell, context, page);
             tableCell.setLeafTextBlock(textBlock);
         } else if (firstTextBlockIsHeadline(cell)) {
             SectionNodeFactory.addSection(layoutParsingType,
@@ -163,7 +129,7 @@ public class TableNodeFactory {
                                           context,
                                           document);
         } else if (cellAreaIsSmallerThanPageAreaTimesThreshold(cell, page)) {
-            List<TextPositionSequence> sequences = TextPositionOperations.mergeAndSortTextPositionSequenceByYThenX(cell.getTextBlocks());
+            List<TextPositionSequence> sequences = TextPositionOperations.mergeAndSort(cell.getTextBlocks());
             textBlock = context.getTextBlockFactory().buildAtomicTextBlock(sequences, tableCell, context, page);
             tableCell.setLeafTextBlock(textBlock);
         } else {
@@ -181,8 +147,7 @@ public class TableNodeFactory {
 
     private boolean firstTextBlockIsHeadline(Cell cell) {
 
-        return cell.getTextBlocks()
-                .get(0).isHeadline();
+        return cell.getTextBlocks().get(0).isHeadline();
     }
 
 }

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

@@ -32,35 +32,34 @@ public class TextBlockFactory {
         long idx = textBlockIdx;
         textBlockIdx++;
         String orientation;
-        int textDirection;
+        int textRotation;
         if (sequences.isEmpty()) {
             orientation = null;
-            textDirection = 0;
+            textRotation = 0;
         } else {
             orientation = sequences.get(0).getDir().toString();
-            textDirection = sequences.get(0).getRotation();
+            textRotation = sequences.get(0).getDir().getRotation();
         }
-        return AtomicTextBlock.fromSearchTextWithTextPosition(searchTextWithTextPositionDto.getSearchText(),
-                searchTextWithTextPositionDto.getLineBreaks(),
-                searchTextWithTextPositionDto.getBoldTextBoundaries(),
-                searchTextWithTextPositionDto.getItalicTextBoundaries(),
-                searchTextWithTextPositionDto.getPositions(),
-                searchTextWithTextPositionDto.getStringIdxToPositionIdx(),
-                idx,
-                parent,
-                numberOnPage,
-                page,
-                offset,
-                orientation,
-                textDirection);
+        var atb = AtomicTextBlock.fromSearchTextWithTextPosition(searchTextWithTextPositionDto.getSearchText(),
+                                                                 searchTextWithTextPositionDto.getLineBreaks(),
+                                                                 searchTextWithTextPositionDto.getBoldTextBoundaries(),
+                                                                 searchTextWithTextPositionDto.getItalicTextBoundaries(),
+                                                                 searchTextWithTextPositionDto.getPositions(),
+                                                                 searchTextWithTextPositionDto.getStringIdxToPositionIdx(),
+                                                                 idx,
+                                                                 parent,
+                                                                 numberOnPage,
+                                                                 page,
+                                                                 offset,
+                                                                 orientation,
+                                                                 textRotation);
+        return atb;
     }
 
 
     public AtomicTextBlock emptyTextBlock(SemanticNode parent, DocumentGraphFactory.Context context, Page page) {
 
-        long idx = textBlockIdx;
-        textBlockIdx++;
-        return AtomicTextBlock.empty(idx, stringOffset, page, context.getAndIncrementTextBlockNumberOnPage(page), parent);
+        return emptyTextBlock(parent, context.getAndIncrementTextBlockNumberOnPage(page), page);
     }
 
 
@@ -68,7 +67,8 @@ public class TextBlockFactory {
 
         long idx = textBlockIdx;
         textBlockIdx++;
-        return AtomicTextBlock.empty(idx, stringOffset, page, numberOnPage, parent);
+        var atb = AtomicTextBlock.empty(idx, stringOffset, page, numberOnPage, parent);
+        return atb;
     }
 
 }

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

@@ -8,12 +8,11 @@ import org.apache.pdfbox.pdmodel.PDDocument;
 import org.apache.pdfbox.pdmodel.PDPage;
 import org.springframework.stereotype.Service;
 
+import com.knecon.fforesight.service.layoutparser.processor.docstrum.model.BoundingBox;
 import com.knecon.fforesight.service.layoutparser.processor.model.table.CleanRulings;
 import com.knecon.fforesight.service.layoutparser.processor.model.table.Ruling;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
-import com.knecon.fforesight.service.layoutparser.processor.services.factory.SearchTextWithTextPositionFactory;
 import com.knecon.fforesight.service.layoutparser.processor.utils.PageInformation;
-import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
 
 import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;
@@ -67,10 +66,7 @@ public class GraphicExtractorService {
     private List<Box> getCharacterBBoxes(List<TextPositionSequence> textPositionSequences) {
 
         return textPositionSequences.stream()
-                .map(pos -> pos.getTextPositions()
-                        .stream()
-                        .map(tp -> SearchTextWithTextPositionFactory.mapRedTextPositionToInitialUserSpace(tp, pos))
-                        .collect(RectangleTransformations.collectBBox()))
+                .map(BoundingBox::getBBoxPdf)
                 .map(Box::new)
                 .collect(Collectors.toList());
     }