Merge branch 'feature/RED-9010' into 'main'

RED-9010: remove redaction log See merge request fforesight/layout-parser!231
RED-9010: remove redaction log
2024-09-19 11:34:32 +02:00 · 2024-09-19 11:34:32 +02:00 · 2024-09-18 11:29:51 +02:00 · 2024-09-18 11:22:37 +02:00 · 2024-09-16 14:06:48 +02:00 · 2024-09-16 14:06:48 +02:00
193 changed files with 6381 additions and 2931 deletions
@@ -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
@@ -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()
@@ -43,6 +43,8 @@ public class DocumentStructure implements Serializable {
        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.")
@@ -67,11 +69,25 @@ public class DocumentStructure implements Serializable {

    public static Rectangle2D parseRectangle2D(String bBox) {

-        List<Float> floats = Arrays.stream(bBox.split(RECTANGLE_DELIMITER)).map(Float::parseFloat).toList();
+        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()) {
@@ -87,19 +103,24 @@ public class DocumentStructure implements Serializable {

    public Stream<EntryData> streamAllEntries() {

-        return Stream.concat(Stream.of(root), root.children.stream()).flatMap(DocumentStructure::flatten);
+        return Stream.concat(Stream.of(root), root.children.stream())
+                .flatMap(DocumentStructure::flatten);
    }


    public String toString() {

-        return String.join("\n", streamAllEntries().map(EntryData::toString).toList());
+        return String.join("\n",
+                           streamAllEntries().map(EntryData::toString)
+                                   .toList());
    }


    private static Stream<EntryData> flatten(EntryData entry) {

-        return Stream.concat(Stream.of(entry), entry.children.stream().flatMap(DocumentStructure::flatten));
+        return Stream.concat(Stream.of(entry),
+                             entry.children.stream()
+                                     .flatMap(DocumentStructure::flatten));
    }


@@ -14,7 +14,7 @@ import lombok.NoArgsConstructor;
 public class SimplifiedSectionText {

    @Schema(description = "The number of this Section. This is used to map the simplified section text back to the original Section.")
-    private int sectionNumber;
+    private String sectionNumber;
    @Schema(description = "The text in this Section.")
    private String text;

@@ -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<>();

 }
@@ -1,5 +1,7 @@
 package com.knecon.fforesight.service.layoutparser.internal.api.data.taas;

+import java.util.List;
+
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -13,6 +15,8 @@ public class StructureObject {

    @Schema(description = "The ID of this StructureObject.")
    Integer structureObjectNumber;
+    @Schema(description = "The Tree ID of this StructureObject.")
+    List<Integer> treeId;
    @Schema(description = "This value indicates the start of the string offsets in this Object, with respect to the reading order.")
    int page;
    @Schema(description = "This stringOffset indicates the start of the string offsets in this Object, with respect to the reading order of the entire document. It is equal to the previous' StructureObject stringOffset + its length.")
@@ -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";
 }
@@ -19,7 +19,6 @@ public record LayoutParsingRequest(
        @Schema(description = "Path to the original PDF file.")//
        @NonNull String originFileStorageId,//

-
        @Schema(description = "Optional Path to the table extraction file.")//
        Optional<String> tablesFileStorageId,//
        @Schema(description = "Optional Path to the image classification file.")//
@@ -37,9 +36,12 @@ public record LayoutParsingRequest(
        @NonNull String positionBlockFileStorageId,//
        @Schema(description = "Path where the Document Pages File will be stored.")//
        @NonNull String pageFileStorageId,//
+        @Schema(description = "Path where the Document Markdown File will be stored.")//
+        Optional<String> documentMarkdownFileStorageId,//
        @Schema(description = "Path where the Simplified Text File will be stored.")//
        @NonNull String simplifiedTextStorageId,//
        @Schema(description = "Path where the Viewer Document PDF will be stored.")//
-        @NonNull String viewerDocumentStorageId) {
+        @NonNull String viewerDocumentStorageId
+) {

 }
@@ -12,11 +12,11 @@ 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.knecon.fforesight:tenant-commons:0.30.0")
    implementation("com.iqser.red.commons:storage-commons:2.45.0")

    implementation("org.apache.pdfbox:pdfbox:${pdfBoxVersion}")
@@ -25,5 +25,13 @@ 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")
+
 }
@@ -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;
@@ -24,6 +24,7 @@ import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.No
 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.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;
@@ -68,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;
@@ -116,29 +118,14 @@ public class LayoutParsingPipeline {
        log.info("Starting layout parsing for {}", layoutParsingRequest.identifier());

        File originFile = layoutParsingStorageService.getOriginFile(layoutParsingRequest.originFileStorageId());
-//        File viewerDocumentFile = layoutParsingStorageService.getViewerDocFile(layoutParsingRequest.viewerDocumentStorageId()).orElse(originFile);
-        File viewerDocumentFile = originFile;
+        File viewerDocumentFile = layoutParsingStorageService.getViewerDocFile(layoutParsingRequest.viewerDocumentStorageId()).orElse(originFile);

-        VisualLayoutParsingResponse visualLayoutParsingResponse = new VisualLayoutParsingResponse();
-        if (layoutParsingRequest.visualLayoutParsingFileId()
-                .isPresent()) {
-            visualLayoutParsingResponse = layoutParsingStorageService.getVisualLayoutParsingFile(layoutParsingRequest.visualLayoutParsingFileId()
-                                                                                                         .get());
-        }
-
-        ImageServiceResponse imageServiceResponse = new ImageServiceResponse();
-        if (layoutParsingRequest.imagesFileStorageId()
-                .isPresent()) {
-            imageServiceResponse = layoutParsingStorageService.getImagesFile(layoutParsingRequest.imagesFileStorageId()
-                                                                                     .get());
-        }
-
-        TableServiceResponse tableServiceResponse = new TableServiceResponse();
-        if (layoutParsingRequest.tablesFileStorageId()
-                .isPresent()) {
-            tableServiceResponse = layoutParsingStorageService.getTablesFile(layoutParsingRequest.tablesFileStorageId()
-                                                                                     .get());
-        }
+        VisualLayoutParsingResponse visualLayoutParsingResponse = layoutParsingRequest.visualLayoutParsingFileId()
+                .map(layoutParsingStorageService::getVisualLayoutParsingFile).orElse(new VisualLayoutParsingResponse());
+        ImageServiceResponse imageServiceResponse = layoutParsingRequest.imagesFileStorageId()
+                .map(layoutParsingStorageService::getImagesFile).orElse(new ImageServiceResponse());
+        TableServiceResponse tableServiceResponse = layoutParsingRequest.tablesFileStorageId()
+                .map(layoutParsingStorageService::getTablesFile).orElse(new TableServiceResponse());

        ClassificationDocument classificationDocument = parseLayout(settings.getLayoutParsingTypeOverride() == null //
                                                                            ? layoutParsingRequest.layoutParsingType() : settings.getLayoutParsingTypeOverride(),
@@ -155,15 +142,18 @@ public class LayoutParsingPipeline {

        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()) {
+            layoutParsingStorageService.storeMarkdownFile(layoutParsingRequest.documentMarkdownFileStorageId().get(), new MarkdownMapper().toMarkdownContent(documentGraph));
+        }
        layoutParsingStorageService.storeSimplifiedText(layoutParsingRequest, simplifiedSectionTextService.toSimplifiedText(documentGraph));
        layoutParsingStorageService.storeViewerDocument(layoutParsingRequest, viewerDocumentFile);

-        if (layoutParsingRequest.layoutParsingType().equals(LayoutParsingType.CLARIFYND)) {
+        if (layoutParsingRequest.researchDocumentStorageId() != null) {
            log.info("Building research document data for {}", layoutParsingRequest.identifier());
            var researchDocumentData = TaasDocumentDataMapper.fromDocument(documentGraph);
            layoutParsingStorageService.storeResearchDocumentData(layoutParsingRequest, researchDocumentData);
@@ -244,17 +234,18 @@ public class LayoutParsingPipeline {
        Map<Integer, List<TableCells>> pdfTableCells = cvTableParsingAdapter.buildCvParsedTablesPerPage(tableServiceResponse);
        Map<Integer, List<ClassifiedImage>> pdfImages = imageServiceResponseAdapter.buildClassifiedImagesPerPage(imageServiceResponse);
        Map<Integer, List<ClassifiedImage>> signatures = visualLayoutParsingAdapter.buildExtractedSignaturesPerPage(visualLayoutParsingResponse);
+
        ClassificationDocument classificationDocument = new ClassificationDocument();

        if (settings.isDebug() || identifier.containsKey("debug")) {
-            classificationDocument.getVisualizations().setActive(true);
+            classificationDocument.getLayoutDebugLayer().setActive(true);
        }

        List<ClassificationPage> classificationPages = new ArrayList<>();
        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));
        }

@@ -280,12 +271,14 @@ 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();
-            classificationDocument.getVisualizations().addTextVisualizations(words, pageNumber);
+            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();

@@ -293,42 +286,34 @@ public class LayoutParsingPipeline {
            boolean isLandscape = pdr.getWidth() > pdr.getHeight() && (rotation == 0 || rotation == 180) || pdr.getHeight() > pdr.getWidth() && (rotation == 90 || rotation == 270);

            PDRectangle cropbox = pdPage.getCropBox();
-            classificationDocument.getVisualizations().addRulingVisualization(stripper.getRulings(), pageNumber);
+            classificationDocument.getLayoutDebugLayer().addRulingVisualization(stripper.getRulings(), pageNumber);
            CleanRulings cleanRulings = rulingCleaningService.deduplicateAndStraightenRulings(pdfTableCells.get(pageNumber), stripper.getRulings());

            PageInformation pageInformation = PageInformation.fromPDPage(pageNumber, pdPage);
            List<Cell> emptyTableCells = TableExtractionService.findCells(cleanRulings.getHorizontals(), cleanRulings.getVerticals(), pageInformation);
-            classificationDocument.getVisualizations().addCellVisualizations(emptyTableCells, pageNumber);
+            classificationDocument.getLayoutDebugLayer().addCellVisualizations(emptyTableCells, pageNumber);

            TextRulingsClassifier.classifyUnderlinedAndStrikethroughText(words, cleanRulings);

-            List<Box> graphics = graphicExtractorService.extractPathElementGraphics(originDocument,
-                                                                              pdPage,
-                                                                              pageNumber,
-                                                                              cleanRulings,
-                                                                              stripper.getTextPositionSequences(),
-
-                                                                              false);
+            List<Box> graphics = graphicExtractorService.extractPathElementGraphics(originDocument, pdPage, pageNumber, cleanRulings, stripper.getTextPositionSequences(), false);

            pdfImages.computeIfAbsent(pageNumber, x -> new ArrayList<>())
                    .addAll(graphics.stream()
-                                    .map(g -> new ClassifiedImage(new Rectangle2D.Double(g.x1, g.y1, g.width(), g.height()), ImageType.GRAPHIC, false, stripper.getPageNumber()))
+                                    .map(g -> new ClassifiedImage(new Rectangle2D.Double(g.x1, g.y1, g.width(), g.height()),
+                                                                  ImageType.GRAPHIC,
+                                                                  false,
+                                                                  stripper.getPageNumber(),
+                                                                  ""))
                                    .toList());

            ClassificationPage classificationPage = switch (layoutParsingType) {
                case REDACT_MANAGER_OLD ->
-                        redactManagerBlockificationService.blockify(stripper.getTextPositionSequences(), cleanRulings, classificationDocument.getVisualizations());
+                        redactManagerBlockificationService.blockify(stripper.getTextPositionSequences(), cleanRulings, classificationDocument.getLayoutDebugLayer());
                case DOCUMINE_OLD -> docuMineBlockificationService.blockify(words, cleanRulings);
-                case DOCUMINE, REDACT_MANAGER, REDACT_MANAGER_PARAGRAPH_DEBUG, REDACT_MANAGER_WITHOUT_DUPLICATE_PARAGRAPH -> docstrumBlockificationService.blockify(words,
-                                                                                                                                                                    cleanRulings,
-                                                                                                                                                                    true,
-                                                                                                                                                                    classificationDocument.getVisualizations(),
-                                                                                                                                                                    layoutParsingType);
-                case CLARIFYND, CLARIFYND_PARAGRAPH_DEBUG -> docstrumBlockificationService.blockify(words,
-                                                                                                    cleanRulings,
-                                                                                                    false,
-                                                                                                    classificationDocument.getVisualizations(),
-                                                                                                    layoutParsingType);
+                case DOCUMINE, REDACT_MANAGER, REDACT_MANAGER_PARAGRAPH_DEBUG, REDACT_MANAGER_WITHOUT_DUPLICATE_PARAGRAPH ->
+                        docstrumBlockificationService.blockify(words, cleanRulings, true, classificationDocument.getLayoutDebugLayer(), layoutParsingType);
+                case CLARIFYND, CLARIFYND_PARAGRAPH_DEBUG ->
+                        docstrumBlockificationService.blockify(words, cleanRulings, false, classificationDocument.getLayoutDebugLayer(), layoutParsingType);
            };

            classificationPage.setCleanRulings(cleanRulings);
@@ -338,21 +323,22 @@ 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.getVisualizations().addMarkedContentVisualizations(stripper.getMarkedContents(), pageNumber);
+            classificationDocument.getLayoutDebugLayer().addMarkedContentVisualizations(stripper.getMarkedContents(), pageNumber);
            // MarkedContent needs to be converted at this point, otherwise it leads to GC Problems in Pdfbox.
            classificationPage.setMarkedContentBboxPerType(convertMarkedContents(stripper.getMarkedContents()));

@@ -383,16 +369,22 @@ public class LayoutParsingPipeline {
        log.info("Calculating BodyTextFrame for {}", identifier);
        bodyTextFrameService.setBodyTextFrames(classificationDocument, layoutParsingType);
        for (ClassificationPage page : classificationDocument.getPages()) {
-            classificationDocument.getVisualizations().addCleanRulingVisualization(page.getCleanRulings(), page.getPageNumber());
+            classificationDocument.getLayoutDebugLayer().addCleanRulingVisualization(page.getCleanRulings(), page.getPageNumber());
        }
        log.info("Classify TextBlocks for {}", identifier);
        switch (layoutParsingType) {
-            case REDACT_MANAGER, REDACT_MANAGER_PARAGRAPH_DEBUG, REDACT_MANAGER_OLD, CLARIFYND_PARAGRAPH_DEBUG, REDACT_MANAGER_WITHOUT_DUPLICATE_PARAGRAPH -> redactManagerClassificationService.classifyDocument(
-                    classificationDocument);
+            case REDACT_MANAGER, REDACT_MANAGER_PARAGRAPH_DEBUG, REDACT_MANAGER_OLD, CLARIFYND_PARAGRAPH_DEBUG, REDACT_MANAGER_WITHOUT_DUPLICATE_PARAGRAPH ->
+                    redactManagerClassificationService.classifyDocument(classificationDocument);
            case DOCUMINE_OLD, DOCUMINE -> docuMineClassificationService.classifyDocument(classificationDocument);
            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()
@@ -5,7 +5,7 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;

-import com.knecon.fforesight.service.viewerdoc.service.ViewerDocumentService;
+import com.knecon.fforesight.service.viewerdoc.service.PDFTronViewerDocumentService;

 import io.micrometer.observation.ObservationRegistry;

@@ -13,12 +13,11 @@ import io.micrometer.observation.ObservationRegistry;
@ComponentScan
 public class LayoutParsingServiceProcessorConfiguration {

-
    @Bean
    @Autowired
-    public ViewerDocumentService viewerDocumentService(ObservationRegistry registry) {
+    public PDFTronViewerDocumentService viewerDocumentService(ObservationRegistry registry) {

-        return new ViewerDocumentService(registry);
+        return new PDFTronViewerDocumentService(registry);
    }

 }
@@ -1,9 +1,11 @@
 package com.knecon.fforesight.service.layoutparser.processor;

+import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -21,6 +23,7 @@ import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsi
 import com.knecon.fforesight.service.layoutparser.processor.python_api.model.image.ImageServiceResponse;
 import com.knecon.fforesight.service.layoutparser.processor.python_api.model.table.TableServiceResponse;
 import com.knecon.fforesight.service.layoutparser.processor.python_api.model.table.VisualLayoutParsingResponse;
+import com.knecon.fforesight.service.viewerdoc.service.ViewerDocVersioningUtility;
 import com.knecon.fforesight.tenantcommons.TenantContext;

 import io.micrometer.observation.annotation.Observed;
@@ -36,6 +39,7 @@ public class LayoutParsingStorageService {
    private final StorageService storageService;
    private final ObjectMapper objectMapper;

+
    @Observed(name = "LayoutParsingStorageService", contextualName = "get-origin-file")
    public File getOriginFile(String storageId) throws IOException {

@@ -53,11 +57,18 @@ public class LayoutParsingStorageService {
        }
        File tempFile = createTempFile("viewerDocument", ".pdf");
        storageService.downloadTo(TenantContext.getTenantId(), storageId, tempFile);
+
+        if (!ViewerDocVersioningUtility.isCurrentVersion(tempFile)) {
+            assert tempFile.delete();
+            return Optional.empty();
+        }
+
        return Optional.of(tempFile);
    }


-    public ImageServiceResponse getImagesFile(String storageId) throws IOException {
+    @SneakyThrows
+    public ImageServiceResponse getImagesFile(String storageId) {

        try (InputStream inputStream = getObject(storageId)) {

@@ -68,7 +79,8 @@ public class LayoutParsingStorageService {
    }


-    public TableServiceResponse getTablesFile(String storageId) throws IOException {
+    @SneakyThrows
+    public TableServiceResponse getTablesFile(String storageId) {

        try (var tableClassificationStream = getObject(storageId)) {

@@ -78,11 +90,12 @@ public class LayoutParsingStorageService {
        }
    }

-    public VisualLayoutParsingResponse getVisualLayoutParsingFile(String storageId) throws IOException {
+
+@SneakyThrows
+    public VisualLayoutParsingResponse getVisualLayoutParsingFile(String storageId) {

        try (InputStream inputStream = getObject(storageId)) {
-            VisualLayoutParsingResponse visualLayoutParsingResponse = objectMapper.readValue(inputStream, VisualLayoutParsingResponse.class);
-            return visualLayoutParsingResponse;
+            return objectMapper.readValue(inputStream, VisualLayoutParsingResponse.class);
        }
    }

@@ -154,4 +167,16 @@ public class LayoutParsingStorageService {
        }
    }

+
+    @SneakyThrows
+    @Observed(name = "LayoutParsingStorageService", contextualName = "store-markdown-file")
+    public void storeMarkdownFile(String markdownFileStorageId, String markdownContent) {
+
+        try (InputStream inputStream = new ByteArrayInputStream(markdownContent.getBytes(StandardCharsets.UTF_8))) {
+
+            storageService.storeObject(TenantContext.getTenantId(), markdownFileStorageId, inputStream);
+        }
+
+    }
+
 }
@@ -17,4 +17,5 @@ public class LayoutparserSettings {

    boolean debug;
    LayoutParsingType layoutParsingTypeOverride;
+    String pdftronLicense;
 }
@@ -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;

@@ -18,7 +19,7 @@ import com.knecon.fforesight.service.layoutparser.processor.model.table.CleanRul
 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 com.knecon.fforesight.service.layoutparser.processor.visualization.LayoutparsingVisualizations;
+import com.knecon.fforesight.service.layoutparser.processor.visualization.LayoutDebugLayer;

 import lombok.RequiredArgsConstructor;

@@ -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;
@@ -33,19 +35,50 @@ public class DocstrumSegmentationService {
    private final ReadingOrderService readingOrderService;


-    public List<Zone> segmentPage(List<TextPositionSequence> textPositions, boolean xyOrder, CleanRulings usedRulings, LayoutparsingVisualizations visualizations) {
+    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 List<Zone> computeZones(List<TextPositionSequence> textPositions, CleanRulings rulings, LayoutparsingVisualizations visualizations, TextDirection direction) {
+    private boolean mostSameDirection(EnumMap<TextDirection, Integer> directionCounts) {
+
+        int total = directionCounts.values()
+                .stream()
+                .mapToInt(i -> i).sum();
+
+        if ((double) directionCounts.get(TextDirection.ZERO) / total > SAME_DIRECTION_THRESHOLD) {
+            return true;
+        } else if ((double) directionCounts.get(TextDirection.QUARTER_CIRCLE) / total > SAME_DIRECTION_THRESHOLD) {
+            return true;
+        } else if ((double) directionCounts.get(TextDirection.HALF_CIRCLE) / total > SAME_DIRECTION_THRESHOLD) {
+            return true;
+        } else if ((double) directionCounts.get(TextDirection.THREE_QUARTER_CIRCLE) / total > SAME_DIRECTION_THRESHOLD) {
+            return true;
+        }
+        return false;
+    }
+
+
+    private List<Zone> computeZones(List<TextPositionSequence> textPositions, CleanRulings rulings, LayoutDebugLayer visualizations, TextDirection direction) {

        List<RedTextPosition> positions = textPositions.stream()
                .filter(t -> t.getDir() == direction)
@@ -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;
        }
    }

@@ -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();
    }

 }
@@ -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);
@@ -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());
    }


@@ -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();
+    }
+
+}
@@ -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;

@@ -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;
@@ -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;
@@ -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);
    }

 }
@@ -7,7 +7,7 @@ import com.knecon.fforesight.service.layoutparser.processor.model.outline.Outlin
 import com.knecon.fforesight.service.layoutparser.processor.model.outline.TableOfContents;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.StringFrequencyCounter;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.UnclassifiedText;
-import com.knecon.fforesight.service.layoutparser.processor.visualization.LayoutparsingVisualizations;
+import com.knecon.fforesight.service.layoutparser.processor.visualization.LayoutDebugLayer;

 import lombok.Data;
 import lombok.NoArgsConstructor;
@@ -25,7 +25,7 @@ public class ClassificationDocument {
    private FloatFrequencyCounter fontSizeCounter = new FloatFrequencyCounter();
    private StringFrequencyCounter fontCounter = new StringFrequencyCounter();
    private StringFrequencyCounter fontStyleCounter = new StringFrequencyCounter();
-    private LayoutparsingVisualizations visualizations = new LayoutparsingVisualizations();
+    private LayoutDebugLayer layoutDebugLayer = new LayoutDebugLayer();
    private boolean headlines;

    private long rulesVersion;
@@ -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<>();

@@ -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;
            }
@@ -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;
+    }
+
 }
@@ -0,0 +1,94 @@
+package com.knecon.fforesight.service.layoutparser.processor.model.graph;
+
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Document;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Footer;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Header;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Headline;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Image;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Paragraph;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Section;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.SemanticNode;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.SuperSection;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Table;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.TableCell;
+
+public abstract class AbstractNodeVisitor implements NodeVisitor {
+
+    @Override
+    public void visit(Document document) {
+
+        visitChildren(document);
+    }
+
+
+    @Override
+    public void visit(SuperSection superSection) {
+
+        visitChildren(superSection);
+    }
+
+
+    @Override
+    public void visit(Section section) {
+
+        visitChildren(section);
+    }
+
+
+    @Override
+    public void visit(Headline headline) {
+
+        visitChildren(headline);
+    }
+
+
+    @Override
+    public void visit(Paragraph paragraph) {
+
+        visitChildren(paragraph);
+    }
+
+
+    @Override
+    public void visit(Footer footer) {
+
+        visitChildren(footer);
+    }
+
+
+    @Override
+    public void visit(Header header) {
+
+        visitChildren(header);
+    }
+
+
+    @Override
+    public void visit(Image image) {
+
+        visitChildren(image);
+    }
+
+
+    @Override
+    public void visit(Table table) {
+
+        visitChildren(table);
+    }
+
+
+    @Override
+    public void visit(TableCell tableCell) {
+
+        visitChildren(tableCell);
+    }
+
+
+    protected void visitChildren(SemanticNode semanticNode) {
+
+        semanticNode.streamChildren()
+                .forEach(node -> node.accept(this));
+
+    }
+
+}
@@ -2,6 +2,7 @@ package com.knecon.fforesight.service.layoutparser.processor.model.graph;

 import static java.lang.String.format;

+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
@@ -39,7 +40,10 @@ public class DocumentTree {

    public TextBlock buildTextBlock() {

-        return allEntriesInOrder().map(Entry::getNode).filter(SemanticNode::isLeaf).map(SemanticNode::getLeafTextBlock).collect(new TextBlockCollector());
+        return allEntriesInOrder().map(Entry::getNode)
+                .filter(SemanticNode::isLeaf)
+                .map(SemanticNode::getLeafTextBlock)
+                .collect(new TextBlockCollector());
    }


@@ -113,13 +117,16 @@ public class DocumentTree {

    public Stream<SemanticNode> childNodes(List<Integer> treeId) {

-        return getEntryById(treeId).children.stream().map(Entry::getNode);
+        return getEntryById(treeId).children.stream()
+                .map(Entry::getNode);
    }


    public Stream<SemanticNode> childNodesOfType(List<Integer> treeId, NodeType nodeType) {

-        return getEntryById(treeId).children.stream().filter(entry -> entry.node.getType().equals(nodeType)).map(Entry::getNode);
+        return getEntryById(treeId).children.stream()
+                .filter(entry -> entry.node.getType().equals(nodeType))
+                .map(Entry::getNode);
    }


@@ -156,26 +163,32 @@ public class DocumentTree {

    public Stream<Entry> allEntriesInOrder() {

-        return Stream.of(root).flatMap(DocumentTree::flatten);
+        return Stream.of(root)
+                .flatMap(DocumentTree::flatten);
    }


    public Stream<Entry> allSubEntriesInOrder(List<Integer> parentId) {

-        return getEntryById(parentId).children.stream().flatMap(DocumentTree::flatten);
+        return getEntryById(parentId).children.stream()
+                .flatMap(DocumentTree::flatten);
    }


    @Override
    public String toString() {

-        return String.join("\n", allEntriesInOrder().map(Entry::toString).toList());
+        return String.join("\n",
+                           allEntriesInOrder().map(Entry::toString)
+                                   .toList());
    }


    private static Stream<Entry> flatten(Entry entry) {

-        return Stream.concat(Stream.of(entry), entry.children.stream().flatMap(DocumentTree::flatten));
+        return Stream.concat(Stream.of(entry),
+                             entry.children.stream()
+                                     .flatMap(DocumentTree::flatten));
    }


@@ -0,0 +1,45 @@
+package com.knecon.fforesight.service.layoutparser.processor.model.graph;
+
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Document;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Footer;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Header;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Headline;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Image;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Paragraph;
+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.graph.nodes.Table;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.TableCell;
+
+public interface NodeVisitor {
+
+    void visit(Document document);
+
+
+    void visit(SuperSection superSection);
+
+
+    void visit(Section section);
+
+
+    void visit(Headline headline);
+
+
+    void visit(Paragraph paragraph);
+
+
+    void visit(Footer footer);
+
+
+    void visit(Header header);
+
+
+    void visit(Image image);
+
+
+    void visit(Table table);
+
+
+    void visit(TableCell tableCell);
+
+}
@@ -13,13 +13,13 @@ import lombok.Setter;
@Setter
@EqualsAndHashCode
@SuppressWarnings("PMD.AvoidFieldNameMatchingMethodName")
-public class Boundary implements Comparable<Boundary> {
+public class TextRange implements Comparable<TextRange> {

    private int start;
    private int end;


-    public Boundary(int start, int end) {
+    public TextRange(int start, int end) {

        if (start > end) {
            throw new IllegalArgumentException(format("start: %d > end: %d", start, end));
@@ -47,15 +47,15 @@ public class Boundary implements Comparable<Boundary> {
    }


-    public boolean contains(Boundary boundary) {
+    public boolean contains(TextRange textRange) {

-        return start <= boundary.start() && boundary.end() <= end;
+        return start <= textRange.start() && textRange.end() <= end;
    }


-    public boolean containedBy(Boundary boundary) {
+    public boolean containedBy(TextRange textRange) {

-        return boundary.contains(this);
+        return textRange.contains(this);
    }


@@ -79,22 +79,33 @@ public class Boundary implements Comparable<Boundary> {

    public boolean contains(int index) {

+        return start <= index && index <= end;
+    }
+
+
+    public boolean containsExclusive(int index) {
+
        return start <= index && index < end;
    }


-    public boolean intersects(Boundary boundary) {
+    public boolean intersects(TextRange textRange) {

-        return boundary.start() < this.end && this.start < boundary.end();
+        return textRange.start() < this.end && this.start < textRange.end();
    }


-    public List<Boundary> split(List<Integer> splitIndices) {
+    public List<TextRange> split(List<Integer> splitIndices) {

-        if (splitIndices.stream().anyMatch(idx -> !this.contains(idx))) {
-            throw new IndexOutOfBoundsException(format("%s splitting indices are out of range for %s", splitIndices.stream().filter(idx -> !this.contains(idx)).toList(), this));
+        if (splitIndices.stream()
+                .anyMatch(idx -> !this.containsExclusive(idx))) {
+            throw new IndexOutOfBoundsException(format("%s splitting indices are out of range for %s",
+                                                       splitIndices.stream()
+                                                               .filter(idx -> !this.containsExclusive(idx))
+                                                               .toList(),
+                                                       this));
        }
-        List<Boundary> splitBoundaries = new LinkedList<>();
+        List<TextRange> splitBoundaries = new LinkedList<>();
        int previousIndex = start;
        for (int splitIndex : splitIndices) {

@@ -102,23 +113,31 @@ public class Boundary implements Comparable<Boundary> {
            if (splitIndex == previousIndex) {
                continue;
            }
-            splitBoundaries.add(new Boundary(previousIndex, splitIndex));
+            splitBoundaries.add(new TextRange(previousIndex, splitIndex));
            previousIndex = splitIndex;
        }
-        splitBoundaries.add(new Boundary(previousIndex, end));
+        splitBoundaries.add(new TextRange(previousIndex, end));
        return splitBoundaries;
    }

+
    public IntStream intStream() {

        return IntStream.range(start, end);
    }

-    public static Boundary merge(Collection<Boundary> boundaries) {

-        int minStart = boundaries.stream().mapToInt(Boundary::start).min().orElseThrow(IllegalArgumentException::new);
-        int maxEnd = boundaries.stream().mapToInt(Boundary::end).max().orElseThrow(IllegalArgumentException::new);
-        return new Boundary(minStart, maxEnd);
+    public static TextRange merge(Collection<TextRange> boundaries) {
+
+        int minStart = boundaries.stream()
+                .mapToInt(TextRange::start)
+                .min()
+                .orElseThrow(IllegalArgumentException::new);
+        int maxEnd = boundaries.stream()
+                .mapToInt(TextRange::end)
+                .max()
+                .orElseThrow(IllegalArgumentException::new);
+        return new TextRange(minStart, maxEnd);
    }


@@ -130,12 +149,12 @@ public class Boundary implements Comparable<Boundary> {


    @Override
-    public int compareTo(Boundary boundary) {
+    public int compareTo(TextRange textRange) {

-        if (end < boundary.end() && start < boundary.start()) {
+        if (end < textRange.end() && start < textRange.start()) {
            return -1;
        }
-        if (start > boundary.start() && end > boundary.end()) {
+        if (start > textRange.start() && end > textRange.end()) {
            return 1;
        }

@@ -11,7 +11,7 @@ import java.util.Map;
 import java.util.Set;

 import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Engine;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.Boundary;
+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;
 import com.knecon.fforesight.service.layoutparser.processor.utils.IdBuilder;
@@ -28,11 +28,11 @@ import lombok.experimental.FieldDefaults;
@AllArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE)
@EqualsAndHashCode(onlyExplicitlyIncluded = true)
-public class RedactionEntity {
+public class TextEntity {

    // initial values
    @EqualsAndHashCode.Include
-    final Boundary boundary;
+    final TextRange textRange;
    @EqualsAndHashCode.Include
    final String type;
    @EqualsAndHashCode.Include
@@ -47,7 +47,7 @@ public class RedactionEntity {
    boolean dictionaryEntry;
    boolean dossierDictionaryEntry;
    Set<Engine> engines;
-    Set<RedactionEntity> references;
+    Set<TextEntity> references;
    @Builder.Default
    Deque<Integer> matchedRules = new LinkedList<>();
    String redactionReason;
@@ -66,9 +66,9 @@ public class RedactionEntity {
    SemanticNode deepestFullyContainingNode;


-    public static RedactionEntity initialEntityNode(Boundary boundary, String type, EntityType entityType) {
+    public static TextEntity initialEntityNode(TextRange textRange, String type, EntityType entityType) {

-        return RedactionEntity.builder().type(type).entityType(entityType).boundary(boundary).engines(new HashSet<>()).references(new HashSet<>()).build();
+        return TextEntity.builder().type(type).entityType(entityType).textRange(textRange).engines(new HashSet<>()).references(new HashSet<>()).build();
    }


@@ -132,7 +132,7 @@ public class RedactionEntity {
    public List<RedactionPosition> getRedactionPositionsPerPage() {

        if (redactionPositionsPerPage == null || redactionPositionsPerPage.isEmpty()) {
-            Map<Page, List<Rectangle2D>> rectanglesPerLinePerPage = deepestFullyContainingNode.getTextBlock().getPositionsPerPage(boundary);
+            Map<Page, List<Rectangle2D>> rectanglesPerLinePerPage = deepestFullyContainingNode.getTextBlock().getPositionsPerPage(textRange);

            Page firstPage = rectanglesPerLinePerPage.keySet()
                    .stream()
@@ -155,21 +155,21 @@ public class RedactionEntity {
    }


-    public boolean containedBy(RedactionEntity redactionEntity) {
+    public boolean containedBy(TextEntity textEntity) {

-        return this.boundary.containedBy(redactionEntity.getBoundary());
+        return this.textRange.containedBy(textEntity.getTextRange());
    }


-    public boolean contains(RedactionEntity redactionEntity) {
+    public boolean contains(TextEntity textEntity) {

-        return this.boundary.contains(redactionEntity.getBoundary());
+        return this.textRange.contains(textEntity.getTextRange());
    }


-    public boolean intersects(RedactionEntity redactionEntity) {
+    public boolean intersects(TextEntity textEntity) {

-        return this.boundary.intersects(redactionEntity.getBoundary());
+        return this.textRange.intersects(textEntity.getTextRange());
    }


@@ -185,13 +185,13 @@ public class RedactionEntity {
    }


-    public void addReference(RedactionEntity reference) {
+    public void addReference(TextEntity reference) {

        references.add(reference);
    }


-    public void addReferences(List<RedactionEntity> references) {
+    public void addReferences(List<TextEntity> references) {

        this.references.addAll(references);
    }
@@ -210,7 +210,7 @@ public class RedactionEntity {
        sb.append("Entity[\"");
        sb.append(value);
        sb.append("\", ");
-        sb.append(boundary);
+        sb.append(textRange);
        sb.append(", pages[");
        pages.forEach(page -> {
            sb.append(page.getNumber());
@@ -8,7 +8,7 @@ import java.util.Set;

 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.LayoutEngine;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.DocumentTree;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.entity.RedactionEntity;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.entity.TextEntity;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;

 import lombok.AccessLevel;
@@ -39,7 +39,7 @@ public abstract class AbstractSemanticNode implements GenericSemanticNode {

    @Builder.Default
    @EqualsAndHashCode.Exclude
-    Set<RedactionEntity> entities = new HashSet<>();
+    Set<TextEntity> entities = new HashSet<>();

    @EqualsAndHashCode.Exclude
    Map<Page, Rectangle2D> bBoxCache;
@@ -11,8 +11,9 @@ import java.util.stream.Stream;

 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.NodeType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.DocumentTree;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;
-import com.knecon.fforesight.service.layoutparser.processor.visualization.LayoutparsingVisualizations;
+import com.knecon.fforesight.service.layoutparser.processor.visualization.LayoutDebugLayer;

 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -33,7 +34,7 @@ public class Document extends AbstractSemanticNode {
    Set<Page> pages;
    Integer numberOfPages;

-    LayoutparsingVisualizations visualizations;
+    LayoutDebugLayer layoutDebugLayer;


    @Override
@@ -60,8 +61,8 @@ public class Document extends AbstractSemanticNode {
     *
     * @return A list of main sections within the document
     * @deprecated This method is marked for removal.
-     *  Use {@link #streamChildrenOfType(NodeType)} instead,
-     *  or {@link #getChildrenOfTypeSectionOrSuperSection()} which returns children of type SECTION as well as SUPER_SECTION.
+     * Use {@link #streamChildrenOfType(NodeType)} instead,
+     * or {@link #getChildrenOfTypeSectionOrSuperSection()} which returns children of type SECTION as well as SUPER_SECTION.
     */
    @Deprecated(forRemoval = true)
    public List<Section> getMainSections() {
@@ -101,8 +102,7 @@ public class Document extends AbstractSemanticNode {
    public Headline getHeadline() {

        return streamAllSubNodesOfType(NodeType.HEADLINE).map(node -> (Headline) node)
-                .findFirst()
-                .orElse(Headline.builder().build());
+                .findFirst().orElse(Headline.builder().build());
    }


@@ -163,4 +163,11 @@ public class Document extends AbstractSemanticNode {
        return bBox;
    }

+
+    @Override
+    public void accept(NodeVisitor visitor) {
+
+        visitor.visit(this);
+    }
+
 }
@@ -25,11 +25,4 @@ public class DuplicatedParagraph extends Paragraph {

    }

-
-    @Override
-    public String toString() {
-
-        return super.toString();
-    }
-
 }
@@ -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.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;

 import lombok.AccessLevel;
@@ -34,6 +35,12 @@ public class Footer extends AbstractSemanticNode {
    }


+    @Override
+    public void accept(NodeVisitor visitor) {
+        visitor.visit(this);
+    }
+
+
    @Override
    public TextBlock getTextBlock() {

@@ -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.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;

 import lombok.AccessLevel;
@@ -27,6 +28,13 @@ public class Header extends AbstractSemanticNode {
    }


+    @Override
+    public void accept(NodeVisitor visitor) {
+
+        visitor.visit(this);
+    }
+
+
    @Override
    public NodeType getType() {

@@ -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.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;

 import lombok.AccessLevel;
@@ -34,6 +35,13 @@ public class Headline extends AbstractSemanticNode {
    }


+    @Override
+    public void accept(NodeVisitor visitor) {
+
+        visitor.visit(this);
+    }
+
+
    @Override
    public TextBlock getTextBlock() {

@@ -7,6 +7,7 @@ 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.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;

 import lombok.AccessLevel;
@@ -28,6 +29,8 @@ public class Image extends AbstractSemanticNode {

    String id;

+    String representationHash;
+
    ImageType imageType;
    boolean transparent;
    Rectangle2D position;
@@ -84,10 +87,29 @@ public class Image extends AbstractSemanticNode {
    }


+    @Override
+    public void accept(NodeVisitor visitor) {
+
+        visitor.visit(this);
+    }
+
+
    @Override
    public boolean isLeaf() {

        return true;
    }

+
+    public double getArea() {
+
+        return position.getWidth() * position.getHeight();
+    }
+
+
+    public boolean isFullPageImage() {
+
+        return imageType.equals(ImageType.OCR) || getArea() >= 0.5 * page.getArea();
+    }
+
 }
@@ -6,7 +6,6 @@ public enum ImageType {
    LOGO,
    FORMULA,
    SIGNATURE,
-
    SIGNATURE_VISUAL,
    OTHER,
    OCR,
@@ -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.RedactionEntity;
+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
@@ -39,7 +41,7 @@ public class Page {

    @Builder.Default
    @EqualsAndHashCode.Exclude
-    Set<RedactionEntity> entities = new HashSet<>();
+    Set<TextEntity> entities = new HashSet<>();

    @Builder.Default
    @EqualsAndHashCode.Exclude
@@ -53,14 +55,41 @@ 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).collect(new TextBlockCollector());
+        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;
    }


@@ -84,4 +113,10 @@ public class Page {
        return o instanceof Page && o.hashCode() == this.hashCode();
    }

+
+    public double getArea() {
+
+        return height * width;
+    }
+
 }
@@ -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.processor.model.graph.NodeVisitor;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;

 import lombok.AccessLevel;
@@ -34,6 +35,13 @@ public class Paragraph extends AbstractSemanticNode {
    }


+    @Override
+    public void accept(NodeVisitor visitor) {
+
+        visitor.visit(this);
+    }
+
+
    @Override
    public TextBlock getTextBlock() {

@@ -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.processor.model.graph.NodeVisitor;

 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -26,15 +27,20 @@ public class Section extends AbstractSemanticNode {
    public Headline getHeadline() {

        return streamChildrenOfType(NodeType.HEADLINE).map(node -> (Headline) node)
-                .findFirst()
-                .orElseGet(() -> getParent().getHeadline());
+                .findFirst().orElseGet(() -> getParent().getHeadline());
+    }
+
+
+    @Override
+    public void accept(NodeVisitor visitor) {
+
+        visitor.visit(this);
    }


    public boolean hasTables() {

-        return streamAllSubNodesOfType(NodeType.TABLE).findAny()
-                .isPresent();
+        return streamAllSubNodesOfType(NodeType.TABLE).findAny().isPresent();
    }


@@ -14,14 +14,16 @@ 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.processor.model.graph.Boundary;
 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;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.entity.RedactionEntity;
+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;
+import com.knecon.fforesight.service.layoutparser.processor.utils.BBoxMergingUtility;
 import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.NodeVisitor;

 public interface SemanticNode {

@@ -42,7 +44,9 @@ public interface SemanticNode {
     */
    default TextBlock getTextBlock() {

-        return streamAllSubNodes().filter(SemanticNode::isLeaf).map(SemanticNode::getTextBlock).collect(new TextBlockCollector());
+        return streamAllSubNodes().filter(SemanticNode::isLeaf)
+                .map(SemanticNode::getTextBlock)
+                .collect(new TextBlockCollector());
    }


@@ -52,7 +56,7 @@ public interface SemanticNode {
     *
     * @return Set of all Entities associated with this Node
     */
-    Set<RedactionEntity> getEntities();
+    Set<TextEntity> getEntities();


    /**
@@ -68,7 +72,10 @@ public interface SemanticNode {

    default Page getFirstPage() {

-        return getTextBlock().getPages().stream().min(Comparator.comparingInt(Page::getNumber)).orElseThrow(() -> new IllegalStateException("SemanticNode has no Page!"));
+        return getTextBlock().getPages()
+                .stream()
+                .min(Comparator.comparingInt(Page::getNumber))
+                .orElseThrow(() -> new IllegalStateException("SemanticNode has no Page!"));
    }


@@ -77,18 +84,19 @@ public interface SemanticNode {
     *
     * @return Set of PageNodes this node appears on.
     */
-    default Set<Page> getPages(Boundary boundary) {
+    default Set<Page> getPages(TextRange textRange) {

-        if (!getBoundary().contains(boundary)) {
-            throw new IllegalArgumentException(format("%s which was used to query for pages is not contained in the %s of this node!", boundary, getBoundary()));
+        if (!getBoundary().contains(textRange)) {
+            throw new IllegalArgumentException(format("%s which was used to query for pages is not contained in the %s of this node!", textRange, getBoundary()));
        }
-        return getTextBlock().getPages(boundary);
+        return getTextBlock().getPages(textRange);
    }


    default boolean isOnPage(int pageNumber) {

-        return getPages().stream().anyMatch(page -> page.getNumber() == pageNumber);
+        return getPages().stream()
+                .anyMatch(page -> page.getNumber() == pageNumber);
    }


@@ -203,7 +211,9 @@ public interface SemanticNode {
     */
    default boolean hasEntitiesOfType(String type) {

-        return getEntities().stream().filter(entity -> entity.getEntityType().equals(EntityType.ENTITY)).anyMatch(redactionEntity -> redactionEntity.getType().equals(type));
+        return getEntities().stream()
+                .filter(entity -> entity.getEntityType().equals(EntityType.ENTITY))
+                .anyMatch(redactionEntity -> redactionEntity.getType().equals(type));
    }


@@ -213,9 +223,11 @@ public interface SemanticNode {
     * @param type string representing the type of entities to return
     * @return List of RedactionEntities of any the type
     */
-    default List<RedactionEntity> getEntitiesOfType(String type) {
+    default List<TextEntity> getEntitiesOfType(String type) {

-        return getEntities().stream().filter(redactionEntity -> redactionEntity.getType().equals(type)).toList();
+        return getEntities().stream()
+                .filter(redactionEntity -> redactionEntity.getType().equals(type))
+                .toList();
    }


@@ -225,9 +237,11 @@ public interface SemanticNode {
     * @param types A list of strings representing the types of entities to return
     * @return List of RedactionEntities of any provided type
     */
-    default List<RedactionEntity> getEntitiesOfType(List<String> types) {
+    default List<TextEntity> getEntitiesOfType(List<String> types) {

-        return getEntities().stream().filter(redactionEntity -> redactionEntity.isAnyType(types)).toList();
+        return getEntities().stream()
+                .filter(redactionEntity -> redactionEntity.isAnyType(types))
+                .toList();
    }


@@ -279,7 +293,8 @@ public interface SemanticNode {
     */
    default boolean containsStrings(List<String> strings) {

-        return strings.stream().allMatch(this::containsString);
+        return strings.stream()
+                .allMatch(this::containsString);
    }


@@ -303,7 +318,8 @@ public interface SemanticNode {
     */
    default boolean containsAnyString(List<String> strings) {

-        return strings.stream().anyMatch(this::containsString);
+        return strings.stream()
+                .anyMatch(this::containsString);
    }


@@ -315,7 +331,8 @@ public interface SemanticNode {
     */
    default boolean containsAnyStringIgnoreCase(List<String> strings) {

-        return strings.stream().anyMatch(this::containsStringIgnoreCase);
+        return strings.stream()
+                .anyMatch(this::containsStringIgnoreCase);
    }


@@ -323,19 +340,19 @@ public interface SemanticNode {
     * This function is used during insertion of EntityNodes into the graph, it checks if the boundary of the RedactionEntity intersects or even contains the RedactionEntity.
     * It sets the fields accordingly and recursively calls this function on all its children.
     *
-     * @param redactionEntity RedactionEntity, which is being inserted into the graph
+     * @param textEntity RedactionEntity, which is being inserted into the graph
     */
-    default void addThisToEntityIfIntersects(RedactionEntity redactionEntity) {
+    default void addThisToEntityIfIntersects(TextEntity textEntity) {

        TextBlock textBlock = getTextBlock();
-        if (textBlock.getBoundary().intersects(redactionEntity.getBoundary())) {
-            if (textBlock.containsBoundary(redactionEntity.getBoundary())) {
-                redactionEntity.setDeepestFullyContainingNode(this);
+        if (textBlock.getTextRange().intersects(textEntity.getTextRange())) {
+            if (textBlock.containsBoundary(textEntity.getTextRange())) {
+                textEntity.setDeepestFullyContainingNode(this);
            }

-            redactionEntity.addIntersectingNode(this);
-            streamChildren().filter(semanticNode -> semanticNode.getBoundary().intersects(redactionEntity.getBoundary()))
-                    .forEach(node -> node.addThisToEntityIfIntersects(redactionEntity));
+            textEntity.addIntersectingNode(this);
+            streamChildren().filter(semanticNode -> semanticNode.getBoundary().intersects(textEntity.getTextRange()))
+                    .forEach(node -> node.addThisToEntityIfIntersects(textEntity));
        }
    }

@@ -386,7 +403,8 @@ public interface SemanticNode {
     */
    default Stream<SemanticNode> streamAllSubNodes() {

-        return getDocumentTree().allSubEntriesInOrder(getTreeId()).map(DocumentTree.Entry::getNode);
+        return getDocumentTree().allSubEntriesInOrder(getTreeId())
+                .map(DocumentTree.Entry::getNode);
    }


@@ -397,7 +415,9 @@ public interface SemanticNode {
     */
    default Stream<SemanticNode> streamAllSubNodesOfType(NodeType nodeType) {

-        return getDocumentTree().allSubEntriesInOrder(getTreeId()).filter(entry -> entry.getType().equals(nodeType)).map(DocumentTree.Entry::getNode);
+        return getDocumentTree().allSubEntriesInOrder(getTreeId())
+                .filter(entry -> entry.getType().equals(nodeType))
+                .map(DocumentTree.Entry::getNode);
    }


@@ -406,9 +426,9 @@ public interface SemanticNode {
     *
     * @return Boundary of this Node's TextBlock
     */
-    default Boundary getBoundary() {
+    default TextRange getBoundary() {

-        return getTextBlock().getBoundary();
+        return getTextBlock().getTextRange();
    }


@@ -453,17 +473,19 @@ public interface SemanticNode {
     */
    private Map<Page, Rectangle2D> getBBoxFromChildren() {

-        Map<Page, Rectangle2D> bBoxPerPage = new HashMap<>();
-        List<Map<Page, Rectangle2D>> childrenBBoxes = streamChildren().map(SemanticNode::getBBox).toList();
-        Set<Page> pages = childrenBBoxes.stream().flatMap(map -> map.keySet().stream()).collect(Collectors.toSet());
-        for (Page page : pages) {
-            Rectangle2D bBoxOnPage = childrenBBoxes.stream()
-                    .filter(childBboxPerPage -> childBboxPerPage.containsKey(page))
-                    .map(childBboxPerPage -> childBboxPerPage.get(page))
-                    .collect(RectangleTransformations.collectBBox());
-            bBoxPerPage.put(page, bBoxOnPage);
+        List<Map<Page, Rectangle2D>> childrenBBoxes = streamChildren().filter(child -> !isFullPageImage(child))
+                .map(SemanticNode::getBBox)
+                .toList();
+        return BBoxMergingUtility.mergeBBoxes(childrenBBoxes);
+    }
+
+
+    private static boolean isFullPageImage(SemanticNode child) {
+
+        if (!child.getType().equals(NodeType.IMAGE)) {
+            return false;
        }
-        return bBoxPerPage;
+        return ((Image) child).isFullPageImage();
    }


@@ -473,9 +495,27 @@ public interface SemanticNode {
    private Map<Page, Rectangle2D> getBBoxFromLeafTextBlock() {

        Map<Page, Rectangle2D> bBoxPerPage = new HashMap<>();
-        Map<Page, List<AtomicTextBlock>> atomicTextBlockPerPage = getTextBlock().getAtomicTextBlocks().stream().collect(Collectors.groupingBy(AtomicTextBlock::getPage));
+        Map<Page, List<AtomicTextBlock>> atomicTextBlockPerPage = getTextBlock().getAtomicTextBlocks()
+                .stream()
+                .collect(Collectors.groupingBy(AtomicTextBlock::getPage));
        atomicTextBlockPerPage.forEach((page, atbs) -> bBoxPerPage.put(page, RectangleTransformations.bBoxUnionAtomicTextBlock(atbs)));
        return bBoxPerPage;
    }

+
+    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);
+    }
+
 }
@@ -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.processor.model.graph.NodeVisitor;

 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -26,8 +27,14 @@ public class SuperSection extends AbstractSemanticNode {
    public Headline getHeadline() {

        return streamChildrenOfType(NodeType.HEADLINE).map(node -> (Headline) node)
-                .findFirst()
-                .orElseGet(() -> getParent().getHeadline());
+                .findFirst().orElseGet(() -> getParent().getHeadline());
+    }
+
+
+    @Override
+    public void accept(NodeVisitor visitor) {
+
+        visitor.visit(this);
    }


@@ -15,7 +15,8 @@ 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.processor.model.graph.DocumentTree;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.entity.RedactionEntity;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.NodeVisitor;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.entity.TextEntity;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.textblock.TextBlockCollector;

@@ -43,7 +44,7 @@ public class Table implements SemanticNode {

    @Builder.Default
    @EqualsAndHashCode.Exclude
-    Set<RedactionEntity> entities = new HashSet<>();
+    Set<TextEntity> entities = new HashSet<>();

    @EqualsAndHashCode.Exclude
    Map<Page, Rectangle2D> bBoxCache;
@@ -54,7 +55,7 @@ public class Table implements SemanticNode {
     * @param strings Strings to check whether a row contains them
     * @return Stream of all entities in this table, that appear in a row, which contains any of the provided strings
     */
-    public Stream<RedactionEntity> streamEntitiesWhereRowContainsStringsIgnoreCase(List<String> strings) {
+    public Stream<TextEntity> streamEntitiesWhereRowContainsStringsIgnoreCase(List<String> strings) {

        return IntStream.range(0, numberOfRows).boxed()
                .filter(row -> rowContainsStringsIgnoreCase(row, strings))
@@ -88,7 +89,7 @@ public class Table implements SemanticNode {
     * @param value  the string which the table cell should contain
     * @return a stream of all entities, which appear in a row where at least one cell has the provided header and the provided value.
     */
-    public Stream<RedactionEntity> streamEntitiesWhereRowHasHeaderAndValue(String header, String value) {
+    public Stream<TextEntity> streamEntitiesWhereRowHasHeaderAndValue(String header, String value) {

        List<Integer> vertebrateStudyCols = streamHeaders().filter(headerNode -> headerNode.containsString(header))
                .map(TableCell::getCol)
@@ -107,7 +108,7 @@ public class Table implements SemanticNode {
     * @param values the strings which the table cell should contain
     * @return a stream of all entities, which appear in a row where at least one cell has the provided header and any provided value.
     */
-    public Stream<RedactionEntity> streamEntitiesWhereRowHasHeaderAndAnyValue(String header, List<String> values) {
+    public Stream<TextEntity> streamEntitiesWhereRowHasHeaderAndAnyValue(String header, List<String> values) {

        List<Integer> colsWithHeader = streamHeaders().filter(headerNode -> headerNode.containsString(header))
                .map(TableCell::getCol)
@@ -125,7 +126,7 @@ public class Table implements SemanticNode {
     * @param types type strings to check whether a row contains an entity like them
     * @return Stream of all entities in this table, that appear in a row, which contains at least one entity with any of the provided types.
     */
-    public Stream<RedactionEntity> streamEntitiesWhereRowContainsEntitiesOfType(List<String> types) {
+    public Stream<TextEntity> streamEntitiesWhereRowContainsEntitiesOfType(List<String> types) {

        List<Integer> rowsWithEntityOfType = IntStream.range(0, numberOfRows).boxed()
                .filter(rowNumber -> streamEntityTypesInRow(rowNumber).anyMatch(existingType -> types.stream()
@@ -145,7 +146,7 @@ public class Table implements SemanticNode {
     * @param types type strings to check whether a row doesn't contain an entity like it
     * @return Stream of all entities in this table, that appear in a row, which does not contain any entity with any of the provided types.
     */
-    public Stream<RedactionEntity> streamEntitiesWhereRowContainsNoEntitiesOfType(List<String> types) {
+    public Stream<TextEntity> streamEntitiesWhereRowContainsNoEntitiesOfType(List<String> types) {

        List<Integer> rowsWithNoEntityOfType = IntStream.range(0, numberOfRows).boxed()
                .filter(rowNumber -> streamEntityTypesInRow(rowNumber).noneMatch(existingType -> types.stream()
@@ -163,7 +164,7 @@ public class Table implements SemanticNode {

        return streamRow(rowNumber).map(TableCell::getEntities)
                .flatMap(Collection::stream)
-                .map(RedactionEntity::getType)
+                .map(TextEntity::getType)
                .distinct();
    }

@@ -304,12 +305,12 @@ public class Table implements SemanticNode {
     * Finds all entities of the provided type, which appear in the same row that the provided entity appears in.
     *
     * @param type            the type of entities to search for
-     * @param redactionEntity the entity, which appears in the row to search
+     * @param textEntity the entity, which appears in the row to search
     * @return List of all entities of the provided type, which appear in the same row that the provided entity appears in.
     */
-    public List<RedactionEntity> getEntitiesOfTypeInSameRow(String type, RedactionEntity redactionEntity) {
+    public List<TextEntity> getEntitiesOfTypeInSameRow(String type, TextEntity textEntity) {

-        return redactionEntity.getIntersectingNodes()
+        return textEntity.getIntersectingNodes()
                .stream()
                .filter(node -> node instanceof TableCell)
                .map(node -> (TableCell) node)
@@ -353,4 +354,10 @@ public class Table implements SemanticNode {
        return bBoxCache;
    }

+
+    @Override
+    public void accept(NodeVisitor visitor) {
+        visitor.visit(this);
+    }
+
 }
@@ -5,6 +5,7 @@ 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.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;

@@ -42,6 +43,13 @@ public class TableCell extends AbstractSemanticNode {
    }


+    @Override
+    public void accept(NodeVisitor visitor) {
+
+        visitor.visit(this);
+    }
+
+
    @Override
    public NodeType getType() {

@@ -10,10 +10,12 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 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.processor.model.graph.Boundary;
+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;
 import com.knecon.fforesight.service.layoutparser.processor.utils.RectangleTransformations;
@@ -36,14 +38,14 @@ public class AtomicTextBlock implements TextBlock {
    Page page;

    //string coordinates
-    Boundary boundary;
+    TextRange textRange;
    String searchText;
    @Builder.Default
    List<Integer> lineBreaks = new ArrayList<>();
    @Builder.Default
-    List<Boundary> boldTextBoundaries = new ArrayList<>();
+    List<TextRange> boldTextBoundaries = new ArrayList<>();
    @Builder.Default
-    List<Boundary> italicTextBoundaries = new ArrayList<>();
+    List<TextRange> italicTextBoundaries = new ArrayList<>();
    String orientation;
    int textDirection;

@@ -64,10 +66,44 @@ public class AtomicTextBlock implements TextBlock {
    }


+    @Override
+    public String subSequenceWithLineBreaks(TextRange stringTextRange) {
+
+        if (stringTextRange.length() == 0 || !getTextRange().contains(stringTextRange)) {
+            return "";
+        }
+
+        Set<Integer> lbInBoundary = lineBreaks.stream()
+                .map(i -> i + this.textRange.start())
+                .filter(stringTextRange::contains)
+                .collect(Collectors.toSet());
+        if (stringTextRange.end() == getTextRange().end()) {
+            lbInBoundary.add(getTextRange().end());
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = stringTextRange.start(); i < stringTextRange.end(); i++) {
+            char character = this.charAt(i);
+            if (lbInBoundary.contains(i + 1)) {
+                // always plus one, due to the linebreaks being an exclusive end index
+                if (!Character.isWhitespace(character)) {
+                    lbInBoundary.remove(i + 1);
+                    lbInBoundary.add(i + 2);
+                    sb.append(character);
+                    continue;
+                }
+                sb.append("\n");
+            } else {
+                sb.append(character);
+            }
+        }
+        return sb.toString();
+    }
+
+
    public static AtomicTextBlock fromSearchTextWithTextPosition(String searchText,
                                                                 List<Integer> lineBreaks,
-                                                                 List<Boundary> boldTextBoundaries,
-                                                                 List<Boundary> italicTextBoundaries,
+                                                                 List<TextRange> boldTextBoundaries,
+                                                                 List<TextRange> italicTextBoundaries,
                                                                 List<Rectangle2D> positions,
                                                                 List<Integer> stringIdxToPositionIdx,
                                                                 long idx,
@@ -89,7 +125,7 @@ public class AtomicTextBlock implements TextBlock {
                .italicTextBoundaries(italicTextBoundaries)
                .positions(positions)
                .stringIdxToPositionIdx(stringIdxToPositionIdx)
-                .boundary(new Boundary(offset, offset + searchText.length()))
+                .textRange(new TextRange(offset, offset + searchText.length()))
                .textDirection(textDirection)
                .orientation(orientation)
                .build();
@@ -100,7 +136,7 @@ public class AtomicTextBlock implements TextBlock {

        return AtomicTextBlock.builder()
                .id(textBlockIdx)
-                .boundary(new Boundary(stringOffset, stringOffset))
+                .textRange(new TextRange(stringOffset, stringOffset))
                .searchText("")
                .page(page)
                .numberOnPage(numberOnPage)
@@ -109,19 +145,18 @@ 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())
                .numberOnPage(documentTextData.getNumberOnPage())
                .page(page)
-                .boundary(new Boundary(documentTextData.getStart(), documentTextData.getEnd()))
+                .textRange(new TextRange(documentTextData.getStart(), documentTextData.getEnd()))
                .searchText(documentTextData.getSearchText())
-                .lineBreaks(Arrays.stream(documentTextData.getLineBreaks()).boxed().toList())
-                .stringIdxToPositionIdx(Arrays.stream(documentPositionData.getStringIdxToPositionIdx()).boxed().toList())
+                .lineBreaks(Arrays.stream(documentTextData.getLineBreaks()).boxed()
+                                    .toList())
+                .stringIdxToPositionIdx(Arrays.stream(documentPositionData.getStringIdxToPositionIdx()).boxed()
+                                                .toList())
                .positions(toRectangle2DList(documentPositionData.getPositions()))
                .parent(parent)
                .build();
@@ -130,7 +165,9 @@ 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();
    }


@@ -140,11 +177,14 @@ public class AtomicTextBlock implements TextBlock {
            throw new IndexOutOfBoundsException(format("line %d out of range for AtomicTextBlock with %d lines", lineNumber, numberOfLines()));
        }
        if (lineNumber == 0) {
-            return subSequence(boundary.start(), lineBreaks.get(0) + boundary.start());
+            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) + boundary.start(), boundary.end());
+            return subSequence(lineBreaks.get(lineBreaks.size() - 1) + textRange.start(), textRange.end());
        }
-        return subSequence(lineBreaks.get(lineNumber - 1) + boundary.start(), lineBreaks.get(lineNumber) + boundary.start());
+        return subSequence(lineBreaks.get(lineNumber - 1) + textRange.start(), lineBreaks.get(lineNumber) + textRange.start());
    }


@@ -159,9 +199,9 @@ public class AtomicTextBlock implements TextBlock {
    public int getNextLinebreak(int fromIndex) {

        return lineBreaks.stream()//
-                .filter(linebreak -> linebreak > fromIndex - boundary.start()) //
-                .findFirst() //
-                .orElse(searchText.length()) + boundary.start();
+                       .filter(linebreak -> linebreak > fromIndex - textRange.start()) //
+                       .findFirst() //
+                       .orElse(searchText.length()) + textRange.start();
    }


@@ -169,43 +209,43 @@ public class AtomicTextBlock implements TextBlock {
    public int getPreviousLinebreak(int fromIndex) {

        return lineBreaks.stream()//
-                .filter(linebreak -> linebreak <= fromIndex - boundary.start())//
-                .reduce((a, b) -> b)//
-                .orElse(0) + boundary.start();
+                       .filter(linebreak -> linebreak <= fromIndex - textRange.start())//
+                       .reduce((a, b) -> b)//
+                       .orElse(0) + textRange.start();
    }


    @Override
    public Rectangle2D getPosition(int stringIdx) {

-        return positions.get(stringIdxToPositionIdx.get(stringIdx - boundary.start()));
+        return positions.get(stringIdxToPositionIdx.get(stringIdx - textRange.start()));
    }


    @Override
-    public List<Rectangle2D> getPositions(Boundary stringBoundary) {
+    public List<Rectangle2D> getPositions(TextRange stringTextRange) {

-        if (!containsBoundary(stringBoundary)) {
-            throw new IndexOutOfBoundsException(format("%s is out of bounds for %s", stringBoundary, this.boundary));
+        if (!containsBoundary(stringTextRange)) {
+            throw new IndexOutOfBoundsException(format("%s is out of bounds for %s", stringTextRange, this.textRange));
        }
-        if (stringBoundary.length() == 0) {
+        if (stringTextRange.length() == 0) {
            return Collections.emptyList();
        }

-        int startPositionIdx = stringIdxToPositionIdx.get(stringBoundary.start() - this.boundary.start());
+        int startPositionIdx = stringIdxToPositionIdx.get(stringTextRange.start() - this.textRange.start());

-        if (stringBoundary.end() == this.boundary.end()) {
+        if (stringTextRange.end() == this.textRange.end()) {
            return positions.subList(startPositionIdx, positions.size());
        }

-        return positions.subList(startPositionIdx, stringIdxToPositionIdx.get(stringBoundary.end() - this.boundary.start()));
+        return positions.subList(startPositionIdx, stringIdxToPositionIdx.get(stringTextRange.end() - this.textRange.start()));

    }


-    public Map<Page, List<Rectangle2D>> getPositionsPerPage(Boundary stringBoundary) {
+    public Map<Page, List<Rectangle2D>> getPositionsPerPage(TextRange stringTextRange) {

-        List<Rectangle2D> rectanglesPerLine = stringBoundary.split(getAllLineBreaksInBoundary(stringBoundary))
+        List<Rectangle2D> rectanglesPerLine = stringTextRange.split(getAllLineBreaksInBoundary(stringTextRange))
                .stream()
                .map(this::getPositions)
                .map(RectangleTransformations::rectangleBBoxWithGaps)
@@ -217,9 +257,12 @@ public class AtomicTextBlock implements TextBlock {
    }


-    private List<Integer> getAllLineBreaksInBoundary(Boundary boundary) {
+    protected List<Integer> getAllLineBreaksInBoundary(TextRange textRange) {

-        return getLineBreaks().stream().map(linebreak -> linebreak + this.boundary.start()).filter(boundary::contains).toList();
+        return getLineBreaks().stream()
+                .map(linebreak -> linebreak + this.textRange.start())
+                .filter(textRange::contains)
+                .toList();
    }


@@ -11,7 +11,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.stream.Stream;

-import com.knecon.fforesight.service.layoutparser.processor.model.graph.Boundary;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.TextRange;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Page;

 import lombok.AccessLevel;
@@ -24,7 +24,7 @@ public class ConcatenatedTextBlock implements TextBlock {

    List<AtomicTextBlock> atomicTextBlocks;
    String searchText;
-    Boundary boundary;
+    TextRange textRange;


    public static ConcatenatedTextBlock empty() {
@@ -37,29 +37,30 @@ public class ConcatenatedTextBlock implements TextBlock {

        this.atomicTextBlocks = new LinkedList<>();
        if (atomicTextBlocks.isEmpty()) {
-            boundary = new Boundary(-1, -1);
+            textRange = new TextRange(-1, -1);
            return;
        }
        var firstTextBlock = atomicTextBlocks.get(0);
        this.atomicTextBlocks.add(firstTextBlock);
-        boundary = new Boundary(firstTextBlock.getBoundary().start(), firstTextBlock.getBoundary().end());
+        textRange = new TextRange(firstTextBlock.getTextRange().start(), firstTextBlock.getTextRange().end());

-        atomicTextBlocks.subList(1, atomicTextBlocks.size()).forEach(this::concat);
+        atomicTextBlocks.subList(1, atomicTextBlocks.size())
+                .forEach(this::concat);
    }


    public ConcatenatedTextBlock concat(TextBlock textBlock) {

-        int start = textBlock.getBoundary().start();
-        int end = textBlock.getBoundary().end();
+        int start = textBlock.getTextRange().start();
+        int end = textBlock.getTextRange().end();
        if (this.atomicTextBlocks.isEmpty()) {
-            boundary.setStart(start);
-            boundary.setEnd(end);
-        } else if (boundary.end() != start) {
-            throw new UnsupportedOperationException(format("Can only concat consecutive TextBlocks, trying to concat %s and %s", boundary, textBlock.getBoundary()));
+            textRange.setStart(start);
+            textRange.setEnd(end);
+        } else if (textRange.end() != start) {
+            throw new UnsupportedOperationException(format("Can only concat consecutive TextBlocks, trying to concat %s and %s", textRange, textBlock.getTextRange()));
        }
        this.atomicTextBlocks.addAll(textBlock.getAtomicTextBlocks());
-        boundary.setEnd(end);
+        textRange.setEnd(end);
        this.searchText = null;
        return this;
    }
@@ -67,13 +68,18 @@ public class ConcatenatedTextBlock implements TextBlock {

    private AtomicTextBlock getAtomicTextBlockByStringIndex(int stringIdx) {

-        return atomicTextBlocks.stream().filter(textBlock -> textBlock.getBoundary().contains(stringIdx)).findAny().orElseThrow(IndexOutOfBoundsException::new);
+        return atomicTextBlocks.stream()
+                .filter(textBlock -> textBlock.getTextRange().containsExclusive(stringIdx))
+                .findAny()
+                .orElseThrow(IndexOutOfBoundsException::new);
    }


-    private List<AtomicTextBlock> getAllAtomicTextBlocksPartiallyInStringBoundary(Boundary boundary) {
+    private List<AtomicTextBlock> getAllAtomicTextBlocksPartiallyInStringBoundary(TextRange textRange) {

-        return atomicTextBlocks.stream().filter(tb -> tb.getBoundary().intersects(boundary)).toList();
+        return atomicTextBlocks.stream()
+                .filter(tb -> tb.getTextRange().intersects(textRange))
+                .toList();
    }


@@ -92,7 +98,9 @@ public class ConcatenatedTextBlock implements TextBlock {
    @Override
    public int numberOfLines() {

-        return atomicTextBlocks.stream().map(AtomicTextBlock::getLineBreaks).mapToInt(List::size).sum();
+        return atomicTextBlocks.stream()
+                .map(AtomicTextBlock::getLineBreaks)
+                .mapToInt(List::size).sum();
    }


@@ -113,7 +121,10 @@ public class ConcatenatedTextBlock implements TextBlock {
    @Override
    public List<Integer> getLineBreaks() {

-        return getAtomicTextBlocks().stream().flatMap(atomicTextBlock -> atomicTextBlock.getLineBreaks().stream()).toList();
+        return getAtomicTextBlocks().stream()
+                .flatMap(atomicTextBlock -> atomicTextBlock.getLineBreaks()
+                        .stream())
+                .toList();
    }


@@ -125,47 +136,48 @@ public class ConcatenatedTextBlock implements TextBlock {


    @Override
-    public List<Rectangle2D> getPositions(Boundary stringBoundary) {
+    public List<Rectangle2D> getPositions(TextRange stringTextRange) {

-        List<AtomicTextBlock> textBlocks = getAllAtomicTextBlocksPartiallyInStringBoundary(stringBoundary);
+        List<AtomicTextBlock> textBlocks = getAllAtomicTextBlocksPartiallyInStringBoundary(stringTextRange);

        if (textBlocks.size() == 1) {
-            return textBlocks.get(0).getPositions(stringBoundary);
+            return textBlocks.get(0).getPositions(stringTextRange);
        }

        AtomicTextBlock firstTextBlock = textBlocks.get(0);
-        List<Rectangle2D> positions = new LinkedList<>(firstTextBlock.getPositions(new Boundary(stringBoundary.start(), firstTextBlock.getBoundary().end())));
+        List<Rectangle2D> positions = new LinkedList<>(firstTextBlock.getPositions(new TextRange(stringTextRange.start(), firstTextBlock.getTextRange().end())));

        for (AtomicTextBlock textBlock : textBlocks.subList(1, textBlocks.size() - 1)) {
            positions.addAll(textBlock.getPositions());
        }

        var lastTextBlock = textBlocks.get(textBlocks.size() - 1);
-        positions.addAll(lastTextBlock.getPositions(new Boundary(lastTextBlock.getBoundary().start(), stringBoundary.end())));
+        positions.addAll(lastTextBlock.getPositions(new TextRange(lastTextBlock.getTextRange().start(), stringTextRange.end())));

        return positions;
    }


    @Override
-    public Map<Page, List<Rectangle2D>> getPositionsPerPage(Boundary stringBoundary) {
+    public Map<Page, List<Rectangle2D>> getPositionsPerPage(TextRange stringTextRange) {

-        List<AtomicTextBlock> textBlocks = getAllAtomicTextBlocksPartiallyInStringBoundary(stringBoundary);
+        List<AtomicTextBlock> textBlocks = getAllAtomicTextBlocksPartiallyInStringBoundary(stringTextRange);

        if (textBlocks.size() == 1) {
-            return textBlocks.get(0).getPositionsPerPage(stringBoundary);
+            return textBlocks.get(0).getPositionsPerPage(stringTextRange);
        }

        AtomicTextBlock firstTextBlock = textBlocks.get(0);
-        Map<Page, List<Rectangle2D>> rectanglesPerLinePerPage = firstTextBlock.getPositionsPerPage(new Boundary(stringBoundary.start(), firstTextBlock.getBoundary().end()));
+        Map<Page, List<Rectangle2D>> rectanglesPerLinePerPage = firstTextBlock.getPositionsPerPage(new TextRange(stringTextRange.start(), firstTextBlock.getTextRange().end()));

        for (AtomicTextBlock textBlock : textBlocks.subList(1, textBlocks.size() - 1)) {
-            rectanglesPerLinePerPage = mergeEntityPositionsWithSamePageNode(rectanglesPerLinePerPage, textBlock.getPositionsPerPage(textBlock.getBoundary()));
+            rectanglesPerLinePerPage = mergeEntityPositionsWithSamePageNode(rectanglesPerLinePerPage, textBlock.getPositionsPerPage(textBlock.getTextRange()));
        }

        AtomicTextBlock lastTextBlock = textBlocks.get(textBlocks.size() - 1);
        rectanglesPerLinePerPage = mergeEntityPositionsWithSamePageNode(rectanglesPerLinePerPage,
-                lastTextBlock.getPositionsPerPage(new Boundary(lastTextBlock.getBoundary().start(), stringBoundary.end())));
+                                                                        lastTextBlock.getPositionsPerPage(new TextRange(lastTextBlock.getTextRange().start(),
+                                                                                                                        stringTextRange.end())));

        return rectanglesPerLinePerPage;
    }
@@ -174,11 +186,42 @@ public class ConcatenatedTextBlock implements TextBlock {
    private Map<Page, List<Rectangle2D>> mergeEntityPositionsWithSamePageNode(Map<Page, List<Rectangle2D>> map1, Map<Page, List<Rectangle2D>> map2) {

        Map<Page, List<Rectangle2D>> mergedMap = new HashMap<>(map1);
-        map2.forEach((pageNode, rectangles) -> mergedMap.merge(pageNode, rectangles, (l1, l2) -> Stream.concat(l1.stream(), l2.stream()).toList()));
+        map2.forEach((pageNode, rectangles) -> mergedMap.merge(pageNode,
+                                                               rectangles,
+                                                               (l1, l2) -> Stream.concat(l1.stream(), l2.stream())
+                                                                       .toList()));
        return mergedMap;
    }


+    @Override
+    public String subSequenceWithLineBreaks(TextRange stringTextRange) {
+
+        if (stringTextRange.length() == 0 || !getTextRange().contains(stringTextRange)) {
+            return "";
+        }
+
+        List<AtomicTextBlock> textBlocks = getAllAtomicTextBlocksPartiallyInStringBoundary(stringTextRange);
+
+        if (textBlocks.size() == 1) {
+            return textBlocks.get(0).subSequenceWithLineBreaks(stringTextRange);
+        }
+
+        StringBuilder sb = new StringBuilder();
+        AtomicTextBlock firstTextBlock = textBlocks.get(0);
+        sb.append(firstTextBlock.subSequenceWithLineBreaks(new TextRange(stringTextRange.start(), firstTextBlock.getTextRange().end())));
+
+        for (AtomicTextBlock textBlock : textBlocks.subList(1, textBlocks.size() - 1)) {
+            sb.append(textBlock.searchTextWithLineBreaks());
+        }
+
+        var lastTextBlock = textBlocks.get(textBlocks.size() - 1);
+        sb.append(lastTextBlock.subSequenceWithLineBreaks(new TextRange(lastTextBlock.getTextRange().start(), stringTextRange.end())));
+
+        return sb.toString();
+    }
+
+
    @Override
    public String toString() {

@@ -187,16 +230,22 @@ public class ConcatenatedTextBlock implements TextBlock {


    @Override
-    public List<Boundary> getBoldTextBoundaries() {
+    public List<TextRange> getBoldTextBoundaries() {

-        return getAtomicTextBlocks().stream().map(AtomicTextBlock::getBoldTextBoundaries).flatMap(Collection::stream).toList();
+        return getAtomicTextBlocks().stream()
+                .map(AtomicTextBlock::getBoldTextBoundaries)
+                .flatMap(Collection::stream)
+                .toList();
    }


    @Override
-    public List<Boundary> getItalicTextBoundaries() {
+    public List<TextRange> getItalicTextBoundaries() {

-        return getAtomicTextBlocks().stream().map(AtomicTextBlock::getItalicTextBoundaries).flatMap(Collection::stream).toList();
+        return getAtomicTextBlocks().stream()
+                .map(AtomicTextBlock::getItalicTextBoundaries)
+                .flatMap(Collection::stream)
+                .toList();
    }


@@ -10,7 +10,7 @@ import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;

-import com.knecon.fforesight.service.layoutparser.processor.model.graph.Boundary;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.TextRange;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Page;

 public interface TextBlock extends CharSequence {
@@ -21,10 +21,10 @@ public interface TextBlock extends CharSequence {
    List<AtomicTextBlock> getAtomicTextBlocks();


-    List<Boundary> getBoldTextBoundaries();
+    List<TextRange> getBoldTextBoundaries();


-    List<Boundary> getItalicTextBoundaries();
+    List<TextRange> getItalicTextBoundaries();


    String getOrientation();
@@ -33,7 +33,7 @@ public interface TextBlock extends CharSequence {
    int getTextDirection();


-    Boundary getBoundary();
+    TextRange getTextRange();


    int getNextLinebreak(int fromIndex);
@@ -48,31 +48,41 @@ public interface TextBlock extends CharSequence {
    Rectangle2D getPosition(int stringIdx);


-    List<Rectangle2D> getPositions(Boundary stringBoundary);
+    List<Rectangle2D> getPositions(TextRange stringTextRange);


-    Map<Page, List<Rectangle2D>> getPositionsPerPage(Boundary stringBoundary);
+    Map<Page, List<Rectangle2D>> getPositionsPerPage(TextRange stringTextRange);


    int numberOfLines();


+    String subSequenceWithLineBreaks(TextRange stringTextRange);
+
+
+    default String searchTextWithLineBreaks() {
+
+        return subSequenceWithLineBreaks(getTextRange());
+    }
+
    default int indexOf(String searchTerm) {

-        return indexOf(searchTerm, getBoundary().start());
+        return indexOf(searchTerm, getTextRange().start());
    }


    default Set<Page> getPages() {

-        return getAtomicTextBlocks().stream().map(AtomicTextBlock::getPage).collect(Collectors.toUnmodifiableSet());
+        return getAtomicTextBlocks().stream()
+                .map(AtomicTextBlock::getPage)
+                .collect(Collectors.toUnmodifiableSet());
    }


-    default Set<Page> getPages(Boundary boundary) {
+    default Set<Page> getPages(TextRange textRange) {

        return getAtomicTextBlocks().stream()
-                .filter(atomicTextBlock -> atomicTextBlock.getBoundary().intersects(boundary))
+                .filter(atomicTextBlock -> atomicTextBlock.getTextRange().intersects(textRange))
                .map(AtomicTextBlock::getPage)
                .collect(Collectors.toUnmodifiableSet());
    }
@@ -80,38 +90,38 @@ public interface TextBlock extends CharSequence {

    default int indexOf(String searchTerm, int startOffset) {

-        int start = getSearchText().indexOf(searchTerm, startOffset - getBoundary().start());
+        int start = getSearchText().indexOf(searchTerm, startOffset - getTextRange().start());
        if (start == -1) {
            return -1;
        }
-        return start + getBoundary().start();
+        return start + getTextRange().start();
    }


    default CharSequence getFirstLine() {

-        return subSequence(getBoundary().start(), getNextLinebreak(getBoundary().start()));
+        return subSequence(getTextRange().start(), getNextLinebreak(getTextRange().start()));
    }


-    default boolean containsBoundary(Boundary boundary) {
+    default boolean containsBoundary(TextRange textRange) {

-        if (boundary.end() < boundary.start()) {
-            throw new IllegalArgumentException(format("Invalid %s, StartIndex must be smaller than EndIndex", boundary));
+        if (textRange.end() < textRange.start()) {
+            throw new IllegalArgumentException(format("Invalid %s, StartIndex must be smaller than EndIndex", textRange));
        }
-        return getBoundary().contains(boundary);
+        return getTextRange().contains(textRange);
    }


    default boolean containsIndex(int stringIndex) {

-        return getBoundary().contains(stringIndex);
+        return getTextRange().containsExclusive(stringIndex);
    }


-    default CharSequence subSequence(Boundary boundary) {
+    default CharSequence subSequence(TextRange textRange) {

-        return subSequence(boundary.start(), boundary.end());
+        return subSequence(textRange.start(), textRange.end());
    }


@@ -128,21 +138,21 @@ public interface TextBlock extends CharSequence {
    @Override
    default CharSequence subSequence(int start, int end) {

-        return getSearchText().substring(start - getBoundary().start(), end - getBoundary().start());
+        return getSearchText().substring(start - getTextRange().start(), end - getTextRange().start());
    }


    @Override
    default int length() {

-        return getBoundary().length();
+        return getTextRange().length();
    }


    @Override
    default char charAt(int index) {

-        return getSearchText().charAt(index - getBoundary().start());
+        return getSearchText().charAt(index - getTextRange().start());
    }

 }
@@ -10,8 +10,8 @@ import lombok.NonNull;
 import lombok.RequiredArgsConstructor;

@Data
-@RequiredArgsConstructor
@AllArgsConstructor
+@RequiredArgsConstructor
 public class ClassifiedImage {

    @NonNull
@@ -20,9 +20,18 @@ public class ClassifiedImage {
    private ImageType imageType;
    private boolean sourceByAi;
    private boolean isAppendedToSection;
-    @NonNull
    private boolean hasTransparency;
-    @NonNull
    private int page;
+    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;
+    }

 }
@@ -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;

@@ -82,11 +86,20 @@ public class OutlineExtractorService {

        String title = item.getTitle();

-        PDPage page = item.findDestinationPage(document);
-        if (page == null) {
+        PDPage page;
+        try {
+            // Can throw: "Error: can't convert to Destination COSArray" for some OCR'd PDFs
+            page = item.findDestinationPage(document);
+            if (page == null) {
+                return Optional.empty();
+            }
+        } 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();

@@ -115,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);
    }


@@ -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;
+    }
+
 }
@@ -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);
+        }
+    }
+
 }
@@ -12,12 +12,14 @@ import org.springframework.stereotype.Service;

 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;

+import io.micrometer.observation.annotation.Observed;
 import lombok.extern.slf4j.Slf4j;

@Service
@Slf4j
 public class OutlineValidationService {

+    @Observed(name = "OutlineValidationService", contextualName = "create-toc")
    public TableOfContents createToC(List<TextPageBlock> headlines) {

        List<TableOfContentItem> mainSections = new ArrayList<>();
@@ -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;
            }
@@ -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 + '}';
    }

-
-
 }
@@ -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());
    }


@@ -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());
    }


@@ -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))
@@ -0,0 +1,9 @@
+package com.knecon.fforesight.service.layoutparser.processor.model.text;
+
+
+public enum FontStyle {
+    REGULAR,
+    BOLD,
+    ITALIC,
+    BOLD_ITALIC;
+}
@@ -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;
-    }
-
 }
@@ -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());
    }

 }
@@ -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;
+        };
+    }
 }
@@ -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;
    }


@@ -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;
+    }
+
 }

@@ -32,7 +32,7 @@ public class ImageServiceResponseAdapter {
                    .add(new ClassifiedImage(new Rectangle2D.Double(imageMetadata.getPosition().getX1(),
                            imageMetadata.getPosition().getY1(),
                            imageMetadata.getGeometry().getWidth(),
-                            imageMetadata.getGeometry().getHeight()), classification, imageMetadata.isAlpha(), imageMetadata.getPosition().getPageNumber()));
+                            imageMetadata.getGeometry().getHeight()), classification, imageMetadata.isAlpha(), imageMetadata.getPosition().getPageNumber(),imageMetadata.getRepresentation()));
        });

        // Currently This is a copy but, it will be changed later because i don' t think that we should unclassified images.
@@ -44,7 +44,7 @@ public class ImageServiceResponseAdapter {
                    .add(new ClassifiedImage(new Rectangle2D.Double(imageMetadata.getPosition().getX1(),
                            imageMetadata.getPosition().getY1(),
                            imageMetadata.getGeometry().getWidth(),
-                            imageMetadata.getGeometry().getHeight()), classification, imageMetadata.isAlpha(), imageMetadata.getPosition().getPageNumber()));
+                            imageMetadata.getGeometry().getHeight()), classification, imageMetadata.isAlpha(), imageMetadata.getPosition().getPageNumber(),imageMetadata.getRepresentation()));
        });

        return images;
@@ -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;
                    }
@@ -79,7 +79,7 @@ public class VisualLayoutParsingAdapter {
                ClassifiedImage signature = new ClassifiedImage(new Rectangle2D.Float(t.getBox().getX1(),
                        t.getBox().getY1(),
                        t.getBox().getX2() - t.getBox().getX1(),
-                        t.getBox().getY2() - t.getBox().getY1()), ImageType.SIGNATURE, true, false, false, pageNumber);
+                        t.getBox().getY2() - t.getBox().getY1()), ImageType.SIGNATURE, true, false, false, pageNumber,"");

                signatures.add(signature);
            }
@@ -14,6 +14,7 @@ import lombok.NoArgsConstructor;
@AllArgsConstructor
 public class Classification {

+    @Builder.Default
    private Map<String, Float> probabilities = new HashMap<>();
    private String label;

@@ -12,6 +12,7 @@ import lombok.NoArgsConstructor;
 public class ImageMetadata {

    private Classification classification;
+    private String representation;
    private Position position;
    private Geometry geometry;
    private Filters filters;
@@ -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<>();


@@ -15,6 +15,7 @@ import lombok.NoArgsConstructor;
 public class TableData {

    private PageInfo pageInfo;
+    @Builder.Default
    private List<TableCells> tableCells = new ArrayList<>();

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

 }
@@ -33,7 +33,7 @@ public class BodyTextFrameService {
        for (ClassificationPage page : classificationDocument.getPages()) {
            var updatedBodyTextFrame = getBodyTextFrameFromRulings(page, bodyTextFrame, landscapeBodyTextFrame);
            setBodyTextFrameAdjustedToPage(page, bodyTextFrame, landscapeBodyTextFrame);
-            classificationDocument.getVisualizations().addMainBodyVisualization(page.isLandscape() ? landscapeBodyTextFrame : bodyTextFrame, page.getPageNumber());
+            classificationDocument.getLayoutDebugLayer().addMainBodyVisualization(page.isLandscape() ? landscapeBodyTextFrame : bodyTextFrame, page.getPageNumber());
        }
    }

@@ -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);

@@ -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;
    }


@@ -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();
    }


@@ -42,9 +57,20 @@ public class SimplifiedSectionTextService {

        return SimplifiedSectionText.builder()
                .sectionNumber(section.getTreeId()
-                                       .get(0))
+                                       .stream()
+                                       .map(String::valueOf)
+                                       .collect(Collectors.joining(".")))
                .text(section.getTextBlock().getSearchText())
                .build();
    }

+
+    private String getSectionNumber(SemanticNode semanticNode) {
+
+        return semanticNode.getTreeId()
+                .stream()
+                .map(String::valueOf)
+                .collect(Collectors.joining("."));
+    }
+
 }
@@ -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);
                }
            }
@@ -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);
@@ -2,14 +2,13 @@ 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;
@@ -19,23 +18,13 @@ import com.knecon.fforesight.service.layoutparser.processor.model.SectionIdentif
 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,6 +258,10 @@ public class BlockificationPostprocessingService {
        List<TextPositionSequence> postSequence = new ArrayList<>();
        StringBuilder currentSequence = new StringBuilder();

+        if (target.isBlank()) {
+            return new WordSequenceResult();
+        }
+
        for (TextPositionSequence sequence : textPositionSequences) {

            currentSequence.append(sanitizeString(sequence.toString()));
@@ -332,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();

@@ -368,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);
                    }
                }
@@ -416,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);
    }


@@ -435,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);

@@ -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,14 +9,13 @@ 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;
 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;
-import com.knecon.fforesight.service.layoutparser.processor.visualization.LayoutparsingVisualizations;
+import com.knecon.fforesight.service.layoutparser.processor.visualization.LayoutDebugLayer;

 import lombok.RequiredArgsConstructor;

@@ -35,12 +33,12 @@ public class DocstrumBlockificationService {
    public ClassificationPage blockify(List<TextPositionSequence> textPositions,
                                       CleanRulings rulings,
                                       boolean xyOrder,
-                                       LayoutparsingVisualizations visualizations,
+                                       LayoutDebugLayer visualizations,
                                       LayoutParsingType layoutParsingType) {

        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);
@@ -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);
+    }

 }

@@ -1,9 +1,6 @@
 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.Iterator;
 import java.util.List;

@@ -11,13 +8,11 @@ import org.springframework.stereotype.Service;

 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.text.TextPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
-import com.knecon.fforesight.service.layoutparser.processor.visualization.LayoutparsingVisualizations;
+import com.knecon.fforesight.service.layoutparser.processor.visualization.LayoutDebugLayer;

@SuppressWarnings("all")
@Service
@@ -35,7 +30,7 @@ public class RedactManagerBlockificationService {
     * @param visualizations
     * @return Page object that contains the Textblock and text statistics.
     */
-    public ClassificationPage blockify(List<TextPositionSequence> textPositions, CleanRulings cleanRulings, LayoutparsingVisualizations visualizations) {
+    public ClassificationPage blockify(List<TextPositionSequence> textPositions, CleanRulings cleanRulings, LayoutDebugLayer visualizations) {

        CleanRulings usedRulings = cleanRulings.withoutTextRulings();

@@ -43,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());

@@ -74,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);
@@ -97,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();
@@ -166,7 +161,6 @@ public class RedactManagerBlockificationService {
        }
        if (!textPositions.isEmpty()) {
            visualizations.addTextBlockVisualizations(chunkBlockList.stream()
-                                                              .map(tb -> (TextPageBlock) tb)
                                                              .toList(), textPositions.get(0).getPage());
        }

@@ -21,33 +21,38 @@ import lombok.extern.slf4j.Slf4j;
@RequiredArgsConstructor
 public class ClarifyndClassificationService {

-    private final HeadlineClassificationService headlineClassificationService;
-
    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.resetContext();
+        HeadlineClassificationService headlineClassificationService = new HeadlineClassificationService();

        for (ClassificationPage page : document.getPages()) {
-            classifyPage(page, document, headlineFontSizes);
+            classifyPage(headlineClassificationService, page, document, headlineFontSizes);
        }
    }


-    private void classifyPage(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) {
-                classifyBlock((TextPageBlock) textBlock, page, document, headlineFontSizes);
+                classifyBlock(headlineClassificationService, (TextPageBlock) textBlock, page, document, headlineFontSizes);
            }
        }
    }


-    private void classifyBlock(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();

@@ -59,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);
@@ -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,61 +25,101 @@ import lombok.extern.slf4j.Slf4j;
@RequiredArgsConstructor
 public class DocuMineClassificationService {

-    private final HeadlineClassificationService headlineClassificationService;
-    private static final Pattern 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 pattern2 = Pattern.compile("\\p{L}{3,}", Pattern.CASE_INSENSITIVE);
-    private static final Pattern pattern3 = Pattern.compile("^(\\d{1,1}\\.){1,3}\\d{1,2}\\.?\\s[a-z]{1,2}\\/[a-z]{1,2}.*");
+    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.resetContext();
+        HeadlineClassificationService headlineClassificationService = new HeadlineClassificationService();

        for (ClassificationPage page : document.getPages()) {
-            classifyPage(page, document, headlineFontSizes);
+            document.getLayoutDebugLayer().addTextBlockVisualizations(page.getTextBlocks(), page.getPageNumber());
+            classifyPage(headlineClassificationService, page, document, headlineFontSizes);
        }
    }


-    private void classifyPage(ClassificationPage page, ClassificationDocument document, List<Float> headlineFontSizes) {
+    private void classifyPage(HeadlineClassificationService headlineClassificationService,
+                              ClassificationPage page,
+                              ClassificationDocument document,
+                              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((TextPageBlock) textBlock, page, document, headlineFontSizes);
+                List<AbstractPageBlock> surroundingBlocks = getSurroundingBlocks(i, textBlocks);
+                classifyBlock(headlineClassificationService, (TextPageBlock) textBlock, surroundingBlocks, page, document, headlineFontSizes);
            }
        }
    }


-    private void classifyBlock(TextPageBlock textBlock, ClassificationPage page, ClassificationDocument document, List<Float> 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<Double> headlineFontSizes) {

        log.debug("headlineFontSizes: {}", headlineFontSizes);
        var bodyTextFrame = page.getBodyTextFrame();

-        Matcher matcher = pattern.matcher(textBlock.toString());
-        Matcher matcher2 = pattern2.matcher(textBlock.toString());
-        Matcher matcher3 = pattern3.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)
-            || (PositionUtils.isOverBodyTextFrame(bodyTextFrame,
-                                                  textBlock,
-                                                  page.getRotation()) && (document.getFontSizeCounter().getMostPopular()
-                                                                          == null
-                                                                          || textBlock.getHighestFontSize()
-                                                                             <= document.getFontSizeCounter()
-                                                                                     .getMostPopular()))) {
+        if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.HEADER) //
+            || (PositionUtils.isOverBodyTextFrame(bodyTextFrame, textBlock, page.getRotation()) //
+                && (document.getFontSizeCounter().getMostPopular() == null //
+                    || textBlock.getHighestFontSize() <= document.getFontSizeCounter().getMostPopular()))) {
            textBlock.setClassification(PageBlockType.HEADER);

        } else if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.FOOTER)
@@ -101,44 +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)) && matcher2.reset().find() && !textBlock.toString()
-                .contains(":")
-                       || textBlock.toString().equals(textBlock.toString().toUpperCase(Locale.ROOT)) && matcher2.reset().find() && !textBlock.toString().contains(":")
-                       || textBlock.toString().startsWith("APPENDIX")
-                       || textBlock.toString().startsWith("FIGURE")
+                   && ((textBlock.getMostPopularWordStyle().contains("bold") || textBlock.isUnderlined())//
+                       && Character.isDigit(textBlock.toString().charAt(0)) //
+                       && isAtLeast3Characters //
+                       && !textBlock.toString().contains(":") //
+                       || textBlock.toString().startsWith("APPENDIX") //
+                       || textBlock.toString().startsWith("FIGURE") //
+                       || textBlock.toString().startsWith("Continued TABLE") //
                       || textBlock.toString().startsWith("TABLE"))
                   && !textBlock.toString().endsWith(":")
-                   && matcher2.reset().find()) {
-            PageBlockType headlineType = PageBlockType.getHeadlineType(1);
-            headlineClassificationService.classifyHeadline(textBlock, headlineType);
-            document.setHeadlines(true);
+                   && isAtLeast3Characters
+                   && !isTocItem
+                   && !isAmount
+                   && enoughChars) {

-        } else if (matcher.reset().find() && PositionUtils.getApproxLineCount(textBlock) < 2.9 && matcher2.reset().find() && !matcher3.reset().matches()) {
-            PageBlockType headlineType = PageBlockType.getHeadlineType(2);
-            headlineClassificationService.classifyHeadline(textBlock, headlineType);
-            document.setHeadlines(true);
+            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
+                   && 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);
+    }
+
+}
+
+
+
@@ -2,15 +2,15 @@ package com.knecon.fforesight.service.layoutparser.processor.services.classifica

 import static com.knecon.fforesight.service.layoutparser.processor.model.PageBlockType.getHeadlineNumber;

-import org.springframework.stereotype.Service;
+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;
 import lombok.Setter;

-@Service
@Getter
@Setter
 public class HeadlineClassificationService {
@@ -19,12 +19,6 @@ public class HeadlineClassificationService {
    PageBlockType originalClassifiedBlockType;
    TextPageBlock lastHeadlineFromOutline;

-    public void resetContext() {
-        setLastHeadline(null);
-        setOriginalClassifiedBlockType(null);
-        setLastHeadlineFromOutline(null);
-    }
-

    public void setLastHeadlineFromOutline(TextPageBlock lastHeadlineFromOutline) {

@@ -35,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;
    }

 }
@@ -22,34 +22,38 @@ import lombok.extern.slf4j.Slf4j;
@RequiredArgsConstructor
 public class RedactManagerClassificationService {

-    private final HeadlineClassificationService headlineClassificationService;
-
-
    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.resetContext();
+        HeadlineClassificationService headlineClassificationService = new HeadlineClassificationService();

        for (ClassificationPage page : document.getPages()) {
-            classifyPage(page, document, headlineFontSizes);
+            classifyPage(headlineClassificationService, page, document, headlineFontSizes);
        }
    }


-    private void classifyPage(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) {
-                classifyBlock((TextPageBlock) textBlock, page, document, headlineFontSizes);
+                classifyBlock(headlineClassificationService, (TextPageBlock) textBlock, page, document, headlineFontSizes);
            }
        }
    }


-    private void classifyBlock(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();

@@ -58,7 +62,7 @@ public class RedactManagerClassificationService {
            return;
        }
        if (document.getFontSizeCounter().getMostPopular() == null) {
-            textBlock.setClassification(PageBlockType.OTHER);
+            textBlock.setClassification(PageBlockType.PARAGRAPH);
            return;
        }

@@ -73,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);
            }
@@ -90,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);
        }
    }

@@ -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;
@@ -22,6 +24,7 @@ import com.knecon.fforesight.service.layoutparser.processor.model.Classification
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationHeader;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.DocumentTree;
+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.DuplicatedParagraph;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Footer;
@@ -31,8 +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.AbstractSemanticNode;
+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;
@@ -45,36 +49,54 @@ import lombok.Builder;
 import lombok.Getter;
 import lombok.experimental.FieldDefaults;
 import lombok.experimental.UtilityClass;
+import lombok.extern.slf4j.Slf4j;

@UtilityClass
+@Slf4j
 public class DocumentGraphFactory {

    public Document buildDocumentGraph(LayoutParsingType layoutParsingType, ClassificationDocument document) {

        Document documentGraph = new Document();

-        documentGraph.setVisualizations(document.getVisualizations());
+        documentGraph.setLayoutDebugLayer(document.getLayoutDebugLayer());

        Context context = new Context(documentGraph);

        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(),
@@ -103,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);
        }

@@ -139,16 +159,15 @@ 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)
                .transparent(image.isHasTransparency())
                .page(page)
+                .representationHash(image.getRepresentation())
                .documentTree(context.getDocumentTree())
                .build();
-        page.getMainBody().add(imageNode);
-        return imageNode;
    }


@@ -188,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);
@@ -200,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);
@@ -241,7 +260,6 @@ public class DocumentGraphFactory {
        DocumentTree documentTree;
        Map<Page, Integer> pages;
        List<AbstractSemanticNode> sections;
-        List<ClassifiedImage> images;
        TextBlockFactory textBlockFactory;


@@ -250,7 +268,6 @@ public class DocumentGraphFactory {
            documentTree = new DocumentTree(document);
            pages = new HashMap<>();
            sections = new LinkedList<>();
-            images = new LinkedList<>();
            textBlockFactory = new TextBlockFactory();
        }

@@ -277,7 +294,8 @@ public class DocumentGraphFactory {
            return pages.keySet()
                    .stream()
                    .filter(page -> page.getNumber() == pageIndex)
-                    .findFirst().orElseThrow(() -> new NoSuchElementException(format("ClassificationPage with number %d not found", pageIndex)));
+                    .findFirst()
+                    .orElseThrow(() -> new NoSuchElementException(format("ClassificationPage with number %d not found", pageIndex)));
        }

    }
@@ -4,7 +4,7 @@ import java.awt.geom.Rectangle2D;
 import java.util.Collections;
 import java.util.List;

-import com.knecon.fforesight.service.layoutparser.processor.model.graph.Boundary;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.TextRange;

 import lombok.AccessLevel;
 import lombok.Builder;
@@ -19,8 +19,8 @@ public class SearchTextWithTextPositionDto {
    String searchText;
    List<Integer> lineBreaks;
    List<Integer> stringIdxToPositionIdx;
-    List<Boundary> boldTextBoundaries;
-    List<Boundary> italicTextBoundaries;
+    List<TextRange> boldTextBoundaries;
+    List<TextRange> italicTextBoundaries;
    List<Rectangle2D> positions;


@@ -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;
@@ -9,9 +10,8 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Objects;

-import com.knecon.fforesight.service.layoutparser.processor.model.graph.Boundary;
+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,13 +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.5;


    public SearchTextWithTextPositionDto buildSearchTextToTextPositionDto(List<TextPositionSequence> sequences) {
@@ -37,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);
@@ -67,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();
@@ -118,23 +115,23 @@ public class SearchTextWithTextPositionFactory {
    }


-    private static List<Boundary> mergeToBoundaries(List<Integer> integers) {
+    private static List<TextRange> mergeToBoundaries(List<Integer> integers) {

        if (integers.isEmpty()) {
            return Collections.emptyList();
        }
-        List<Boundary> boundaries = new LinkedList<>();
+        List<TextRange> boundaries = new LinkedList<>();
        int start = integers.get(0);
        int end = integers.get(0) + 1;
        for (int current : integers) {
            if (current > end + 1) {
-                boundaries.add(new Boundary(start, end));
+                boundaries.add(new TextRange(start, end));
                start = current;
            }
            end = current + 1;
        }
        if (boundaries.isEmpty()) {
-            boundaries.add(new Boundary(start, end));
+            boundaries.add(new TextRange(start, end));
        }
        return boundaries;
    }
@@ -160,8 +157,8 @@ public class SearchTextWithTextPositionFactory {
            return false;
        }

-        double deltaY = Math.abs(currentPosition.getYDirAdj() - previousPosition.getYDirAdj());
-        return deltaY >= currentPosition.getHeightDir();
+        double deltaY = (Math.abs(currentPosition.getYDirAdj() - previousPosition.getYDirAdj()) * LINEBREAK_DELTA_TOLERANCE) + (2 * HEIGHT_PADDING);
+        return deltaY >= currentPosition.getHeightDirAdj() || deltaY >= previousPosition.getHeightDirAdj();
    }


@@ -187,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<>();
@@ -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,9 +48,6 @@ public class SectionNodeFactory {
            return Optional.empty();
        }

-        Map<Integer, List<AbstractPageBlock>> blocksPerPage = pageBlocks.stream()
-                .collect(groupingBy(AbstractPageBlock::getPage));
-
        AbstractSemanticNode section;
        if (isLeaf) {
            section = Section.builder().documentTree(context.getDocumentTree()).build();
@@ -62,13 +56,12 @@ public class SectionNodeFactory {
        }

        context.getSections().add(section);
-        blocksPerPage.keySet()
-                .forEach(pageNumber -> addSectionNodeToPageNode(context, section, pageNumber));

        section.setTreeId(getTreeId(parentNode, context, section));

        addFirstHeadlineDirectlyToSection(layoutParsingType, pageBlocks, context, section, document);
-        if (containsTablesAndTextBlocks(pageBlocks)) {
+        boolean containsTablesAndTextBlocks = containsTablesAndTextBlocks(pageBlocks);
+        if (containsTablesAndTextBlocks) {
            splitPageBlocksIntoSubSections(pageBlocks).forEach(subSectionPageBlocks -> addSection(layoutParsingType,
                                                                                                  section,
                                                                                                  true,
@@ -157,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);
    }

@@ -233,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);
-    }
-
 }
@@ -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();
    }

 }
@@ -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;
    }

 }
@@ -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());
    }
@@ -116,8 +116,8 @@ public class DocumentDataMapper {
                .page(atomicTextBlock.getPage().getNumber().longValue())
                .searchText(atomicTextBlock.getSearchText())
                .numberOnPage(atomicTextBlock.getNumberOnPage())
-                .start(atomicTextBlock.getBoundary().start())
-                .end(atomicTextBlock.getBoundary().end())
+                .start(atomicTextBlock.getTextRange().start())
+                .end(atomicTextBlock.getTextRange().end())
                .lineBreaks(toPrimitiveIntArray(atomicTextBlock.getLineBreaks()))
                .build();
    }
@@ -41,7 +41,9 @@ public class DocumentGraphMapper {
        DocumentTree documentTree = new DocumentTree(document);
        Context context = new Context(documentData, documentTree);

-        context.pages.addAll(Arrays.stream(documentData.getDocumentPages()).map(DocumentGraphMapper::buildPage).toList());
+        context.pages.addAll(Arrays.stream(documentData.getDocumentPages())
+                                     .map(DocumentGraphMapper::buildPage)
+                                     .toList());

        context.documentTree.getRoot().getChildren().addAll(buildEntries(documentData.getDocumentStructure().getRoot().getChildren(), context));

@@ -59,7 +61,9 @@ public class DocumentGraphMapper {
        List<DocumentTree.Entry> newEntries = new LinkedList<>();
        for (DocumentStructure.EntryData entryData : entries) {

-            List<Page> pages = Arrays.stream(entryData.getPageNumbers()).map(pageNumber -> getPage(pageNumber, context)).toList();
+            List<Page> pages = Arrays.stream(entryData.getPageNumbers())
+                    .map(pageNumber -> getPage(pageNumber, context))
+                    .toList();

            SemanticNode node = switch (entryData.getType()) {
                case SECTION -> buildSection(context);
@@ -77,16 +81,18 @@ public class DocumentGraphMapper {
            if (entryData.getAtomicBlockIds().length > 0) {
                TextBlock textBlock = toTextBlock(entryData.getAtomicBlockIds(), context, node);
                node.setLeafTextBlock(textBlock);
+                switch (entryData.getType()) {
+                    case HEADER -> pages.forEach(page -> page.setHeader((Header) node));
+                    case FOOTER -> pages.forEach(page -> page.setFooter((Footer) node));
+                    case IMAGE -> pages.forEach(page -> page.getImages().add((Image) node));
+                    default -> textBlock.getAtomicTextBlocks()
+                            .forEach(atb -> atb.getPage().getTextBlocksOnPage().add(atb));
+                }
            }
-            List<Integer> treeId = Arrays.stream(entryData.getTreeId()).boxed().toList();
+            List<Integer> treeId = Arrays.stream(entryData.getTreeId()).boxed()
+                    .toList();
            node.setTreeId(treeId);

-            switch (entryData.getType()) {
-                case HEADER -> pages.forEach(page -> page.setHeader((Header) node));
-                case FOOTER -> pages.forEach(page -> page.setFooter((Footer) node));
-                default -> pages.forEach(page -> page.getMainBody().add(node));
-            }
-
            newEntries.add(DocumentTree.Entry.builder().treeId(treeId).children(buildEntries(entryData.getChildren(), context)).node(node).build());
        }
        return newEntries;
@@ -142,6 +148,7 @@ public class DocumentGraphMapper {
        return Section.builder().documentTree(context.documentTree).build();
    }

+
    private SuperSection buildSuperSection(Context context) {

        return SuperSection.builder().documentTree(context.documentTree).build();
@@ -166,22 +173,24 @@ public class DocumentGraphMapper {

    private TextBlock toTextBlock(Long[] atomicTextBlockIds, Context context, SemanticNode parent) {

-        return Arrays.stream(atomicTextBlockIds).map(atomicTextBlockId -> getAtomicTextBlock(context, parent, atomicTextBlockId)).collect(new TextBlockCollector());
+        return Arrays.stream(atomicTextBlockIds)
+                .map(atomicTextBlockId -> getAtomicTextBlock(context, parent, atomicTextBlockId))
+                .collect(new TextBlockCollector());
    }


    private AtomicTextBlock getAtomicTextBlock(Context context, SemanticNode parent, Long atomicTextBlockId) {

        return AtomicTextBlock.fromAtomicTextBlockData(context.documentTextDataBlockData.get(Math.toIntExact(atomicTextBlockId)),
-                context.atomicPositionBlockData.get(Math.toIntExact(atomicTextBlockId)),
-                parent,
-                getPage(context.documentTextDataBlockData.get(Math.toIntExact(atomicTextBlockId)).getPage(), context));
+                                                       context.atomicPositionBlockData.get(Math.toIntExact(atomicTextBlockId)),
+                                                       parent,
+                                                       getPage(context.documentTextDataBlockData.get(Math.toIntExact(atomicTextBlockId)).getPage(), context));
    }


    private Page buildPage(DocumentPage p) {

-        return Page.builder().rotation(p.getRotation()).height(p.getHeight()).width(p.getWidth()).number(p.getNumber()).mainBody(new LinkedList<>()).build();
+        return Page.builder().rotation(p.getRotation()).height(p.getHeight()).width(p.getWidth()).number(p.getNumber()).textBlocksOnPage(new LinkedList<>()).build();
    }


@@ -206,8 +215,10 @@ public class DocumentGraphMapper {

            this.documentTree = documentTree;
            this.pages = new LinkedList<>();
-            this.documentTextDataBlockData = Arrays.stream(documentData.getDocumentTextData()).toList();
-            this.atomicPositionBlockData = Arrays.stream(documentData.getDocumentPositions()).toList();
+            this.documentTextDataBlockData = Arrays.stream(documentData.getDocumentTextData())
+                    .toList();
+            this.atomicPositionBlockData = Arrays.stream(documentData.getDocumentPositions())
+                    .toList();

        }

@@ -0,0 +1,326 @@
+package com.knecon.fforesight.service.layoutparser.processor.services.mapper;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+import org.commonmark.Extension;
+import org.commonmark.ext.gfm.tables.TableBlock;
+import org.commonmark.ext.gfm.tables.TableBody;
+import org.commonmark.ext.gfm.tables.TableCell;
+import org.commonmark.ext.gfm.tables.TableHead;
+import org.commonmark.ext.gfm.tables.TableRow;
+import org.commonmark.ext.gfm.tables.TablesExtension;
+import org.commonmark.node.Block;
+import org.commonmark.node.Document;
+import org.commonmark.node.Emphasis;
+import org.commonmark.node.HardLineBreak;
+import org.commonmark.node.Heading;
+import org.commonmark.node.Node;
+import org.commonmark.node.Paragraph;
+import org.commonmark.node.StrongEmphasis;
+import org.commonmark.node.Text;
+import org.commonmark.renderer.markdown.MarkdownRenderer;
+
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.AbstractNodeVisitor;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.TextRange;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Headline;
+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.textblock.TextBlock;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.FontStyle;
+
+public class MarkdownMapper extends AbstractNodeVisitor {
+
+    Document markdownDocument = new Document();
+
+
+    public String toMarkdownContent(com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Document document) {
+
+        visit(document);
+
+        return buildRenderer().render(this.markdownDocument);
+    }
+
+
+    @Override
+    public void visit(Headline headline) {
+
+        markdownDocument.appendChild(parseHeadline(headline));
+    }
+
+
+    @Override
+    public void visit(com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Paragraph paragraph) {
+
+        markdownDocument.appendChild(parseParagraph(paragraph));
+    }
+
+
+    @Override
+    public void visit(Table table) {
+
+        markdownDocument.appendChild(parseTable(table));
+    }
+
+
+    private static MarkdownRenderer buildRenderer() {
+
+        List<Extension> extensions = List.of(TablesExtension.create());
+        return MarkdownRenderer.builder().extensions(extensions).build();
+    }
+
+
+    private Block parseTable(Table table) {
+
+//        if (table.getNumberOfRows() == 1 && table.getNumberOfCols() == 1) {
+//            org.commonmark.node.Paragraph markdownParagraph = new org.commonmark.node.Paragraph();
+//            parseTextBlock(table.getTextBlock(), true).forEach(markdownParagraph::appendChild);
+//            return markdownParagraph;
+//        }
+
+        TableBlock tableNode = new TableBlock();
+        TableHead head = new TableHead();
+        TableRow tableRow = createTableRow(table, 0);
+        head.appendChild(tableRow);
+        int row = 1;
+        tableNode.appendChild(head);
+        TableBody tableBody = new TableBody();
+        for (; row < table.getNumberOfRows(); row++) {
+            tableBody.appendChild(createTableRow(table, row));
+        }
+        tableNode.appendChild(tableBody);
+        return tableNode;
+    }
+
+
+    private TableRow createTableRow(Table table, int row) {
+
+        TableRow tableRow = new TableRow();
+        table.streamRow(row)
+                .map(this::createTableCell)
+                .forEach(tableRow::appendChild);
+        return tableRow;
+    }
+
+
+    private Node createTableCell(com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.TableCell tc) {
+
+        var cell = new TableCell();
+        List<SemanticNode> childNodes = tc.streamChildren()
+                .toList();
+        if (childNodes.isEmpty()) {
+            parseTextBlock(tc.getTextBlock(), false).forEach(cell::appendChild);
+        } else {
+            childNodes.forEach(semanticNode -> parseTextBlock(semanticNode.getTextBlock(), false).forEach(cell::appendChild));
+        }
+        return cell;
+    }
+
+
+    private Paragraph parseParagraph(com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Paragraph paragraph) {
+
+        org.commonmark.node.Paragraph markdownParagraph = new org.commonmark.node.Paragraph();
+        parseTextBlock(paragraph.getTextBlock(), true).forEach(markdownParagraph::appendChild);
+        return markdownParagraph;
+    }
+
+
+    private Heading parseHeadline(Headline headline) {
+
+        Heading heading = new Heading();
+        heading.setLevel(headline.getTreeId().size());
+        heading.appendChild(parseTextBlockAsText(headline.getTextBlock()));
+        return heading;
+
+    }
+
+
+    private Text parseTextBlockAsText(TextBlock textBlock) {
+
+        return new Text(textBlock.getSearchText());
+    }
+
+
+    private List<Node> parseTextBlock(TextBlock textBlock, boolean includeLineBreaks) {
+
+        LinkedList<Node> result = new LinkedList<>();
+        List<TextRangeWithTextType> textRanges = mergeTextStyles(textBlock);
+
+        String fullText = getText(textBlock, textBlock.getTextRange(), includeLineBreaks);
+        List<Integer> lineTextSizes = getLineTextSizes(fullText);
+        int idx = 0;
+        int charCount = 0;
+        for (TextRangeWithTextType textRange : textRanges) {
+            String text = getText(textBlock, textRange.textRange(), includeLineBreaks);
+            String[] lines = text.split("\n");
+            for (String line : lines) {
+                charCount += line.length();
+                switch (textRange.fontStyle()) {
+                    case REGULAR -> result.add(new Text(line));
+                    case BOLD -> {
+                        StrongEmphasis boldBlock = new StrongEmphasis();
+                        boldBlock.appendChild(new Text(line));
+                        result.add(boldBlock);
+                    }
+                    case ITALIC -> {
+                        Emphasis italicBlock = new Emphasis();
+                        italicBlock.appendChild(new Text(line));
+                        result.add(italicBlock);
+                    }
+                    case BOLD_ITALIC -> {
+                        Emphasis italicBlock = new Emphasis();
+
+                        StrongEmphasis boldBlock = new StrongEmphasis();
+                        boldBlock.appendChild(new Text(line));
+
+                        italicBlock.appendChild(boldBlock);
+                        result.add(italicBlock);
+                    }
+                }
+                if (includeLineBreaks && lineTextSizes.get(idx).equals(charCount)) {
+                    result.add(new HardLineBreak());
+                    idx++;
+                }
+
+            }
+        }
+        if (!result.isEmpty() && result.getLast() instanceof HardLineBreak) {
+            result.removeLast();
+        }
+        return result;
+    }
+
+
+    private static List<Integer> getLineTextSizes(String input) {
+
+        String[] parts = input.split("\n");
+        List<Integer> textSizes = new ArrayList<>();
+
+        int size = 0;
+        for (int i = 0; i < parts.length; i++) {
+            size += parts[i].length();
+            textSizes.add(size);
+        }
+
+        if (textSizes.isEmpty()) {
+            textSizes.add(0);
+        }
+
+        return textSizes;
+    }
+
+
+    private static String getText(TextBlock textBlock, TextRange textRange, boolean includeLineBreaks) {
+
+        return includeLineBreaks ? textBlock.subSequenceWithLineBreaks(textRange) : textBlock.subSequence(textRange).toString();
+    }
+
+
+    private List<TextRangeWithTextType> mergeTextStyles(TextBlock textBlock) {
+
+        List<TextRangeWithTextType> result = new ArrayList<>();
+
+        TreeMap<Integer, Set<FontStyleChange>> styleChanges = new TreeMap<>();
+
+        int start = textBlock.getTextRange().start();
+        int end = textBlock.getTextRange().end();
+
+        for (TextRange bold : textBlock.getBoldTextBoundaries()) {
+            styleChanges.computeIfAbsent(bold.start() + start, k -> new HashSet<>()).add(FontStyleChange.enter(FontStyle.BOLD));
+            styleChanges.computeIfAbsent(bold.end() + start, k -> new HashSet<>()).add(FontStyleChange.leave(FontStyle.BOLD));
+        }
+
+        for (TextRange italic : textBlock.getItalicTextBoundaries()) {
+            styleChanges.computeIfAbsent(italic.start() + start, k -> new HashSet<>()).add(FontStyleChange.enter(FontStyle.ITALIC));
+            styleChanges.computeIfAbsent(italic.end() + start, k -> new HashSet<>()).add(FontStyleChange.leave(FontStyle.ITALIC));
+        }
+
+        if (styleChanges.isEmpty()) {
+            result.add(new TextRangeWithTextType(new TextRange(start, end), FontStyle.REGULAR));
+            return result;
+        }
+
+        Set<FontStyle> currentStyles = new HashSet<>();
+        currentStyles.add(FontStyle.REGULAR);
+
+        for (Map.Entry<Integer, Set<FontStyleChange>> entry : styleChanges.entrySet()) {
+            int point = entry.getKey();
+            Set<FontStyleChange> changes = entry.getValue();
+
+            if (point > start) {
+                FontStyle style = determineFontStyle(currentStyles);
+                result.add(new TextRangeWithTextType(new TextRange(start, point), style));
+            }
+
+            changes.stream()
+                    .filter(FontStyleChange::leave)
+                    .map(FontStyleChange::style)
+                    .toList()
+                    .forEach(currentStyles::remove);
+
+            currentStyles.addAll(changes.stream()
+                                         .filter(FontStyleChange::enter)
+                                         .map(FontStyleChange::style)
+                                         .toList());
+
+            if (currentStyles.isEmpty()) {
+                currentStyles.add(FontStyle.REGULAR);
+            }
+
+            start = point;
+        }
+
+        if (start < end) {
+            FontStyle style = determineFontStyle(currentStyles);
+            result.add(new TextRangeWithTextType(new TextRange(start, textBlock.getTextRange().end()), style));
+        }
+
+        return result;
+    }
+
+
+    private FontStyle determineFontStyle(Set<FontStyle> styles) {
+
+        if (styles.contains(FontStyle.BOLD) && styles.contains(FontStyle.ITALIC)) {
+            return FontStyle.BOLD_ITALIC;
+        } else if (styles.contains(FontStyle.BOLD)) {
+            return FontStyle.BOLD;
+        } else if (styles.contains(FontStyle.ITALIC)) {
+            return FontStyle.ITALIC;
+        } else {
+            return FontStyle.REGULAR;
+        }
+    }
+
+
+
+    record FontStyleChange(boolean enter, FontStyle style) {
+
+        public static FontStyleChange enter(FontStyle style) {
+
+            return new FontStyleChange(true, style);
+        }
+
+
+        public static FontStyleChange leave(FontStyle style) {
+
+            return new FontStyleChange(false, style);
+        }
+
+
+        public boolean leave() {
+
+            return !enter;
+        }
+
+    }
+
+    record TextRangeWithTextType(TextRange textRange, FontStyle fontStyle) {
+
+    }
+}
@@ -0,0 +1,84 @@
+package com.knecon.fforesight.service.layoutparser.processor.services.mapper;
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Optional;
+
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Document;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Headline;
+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.SemanticNode;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.SuperSection;
+import com.knecon.fforesight.service.layoutparser.processor.utils.CoordinateTransforms;
+import com.knecon.fforesight.service.layoutparser.processor.utils.PageInformation;
+import com.knecon.fforesight.service.viewerdoc.model.Outline;
+
+import lombok.SneakyThrows;
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class OutlineMapper {
+
+    public Outline createOutline(Document document) {
+
+        Outline outline = new Outline();
+        addChildren(document, null, outline);
+        return outline;
+    }
+
+
+    public void addChildren(SemanticNode parentNode, Outline.Entry parentEntry, Outline outline) {
+
+        parentNode.streamChildren()
+                .filter(child -> child instanceof Section || child instanceof SuperSection)
+                .forEach(child -> {
+                    Optional<Headline> headline = findHeadline(child);
+                    if (headline.isPresent()) {
+                        Outline.Entry entry = buildEntry(child.getHeadline());
+                        if (parentEntry != null) {
+                            parentEntry.children().add(entry);
+                        } else {
+                            outline.getEntries().add(entry);
+                        }
+                        addChildren(child, entry, outline);
+                    } else {
+                        addChildren(child, parentEntry, outline);
+                    }
+                });
+    }
+
+
+    private static Optional<Headline> findHeadline(SemanticNode child) {
+
+        return child.streamChildren()
+                .filter(node -> node instanceof Headline)
+                .map(node -> (Headline) node)
+                .findFirst();
+    }
+
+
+    @SneakyThrows
+    private Outline.Entry buildEntry(Headline headline) {
+
+        Map<Page, Rectangle2D> bbox = headline.getBBox();
+        Rectangle2D r = bbox.get(headline.getFirstPage());
+        Point2D.Double position = new Point2D.Double(r.getMinX(), r.getMaxY());
+        PageInformation pageInformation = PageInformation.fromPage(headline.getFirstPage());
+
+        AffineTransform pdfToPage = CoordinateTransforms.calculateInitialUserSpaceCoordsToPageCoords(pageInformation);
+        pdfToPage.transform(position, position);
+
+        AffineTransform mirror = new AffineTransform(1, 0, 0, -1, 0, pageInformation.heightRot());
+        mirror.transform(position, position);
+
+        AffineTransform.getTranslateInstance(0, 5).transform(position, position);
+
+        Outline.JumpAction action = new Outline.JumpAction(headline.getFirstPage().getNumber(), position);
+        return new Outline.Entry(headline.getTextBlock().getSearchText(), action, new LinkedList<>());
+    }
+
+}
@@ -24,6 +24,7 @@ public class PropertiesMapper {
        properties.put(DocumentStructure.ImageProperties.TRANSPARENT, String.valueOf(image.isTransparent()));
        properties.put(DocumentStructure.ImageProperties.POSITION, toString(image.getPosition()));
        properties.put(DocumentStructure.ImageProperties.ID, image.getId());
+        properties.put(DocumentStructure.ImageProperties.REPRESENTATION_HASH, image.getRepresentationHash());
        return properties;
    }

@@ -13,7 +13,7 @@ import com.knecon.fforesight.service.layoutparser.internal.api.data.taas.Researc
 import com.knecon.fforesight.service.layoutparser.internal.api.data.taas.RowData;
 import com.knecon.fforesight.service.layoutparser.internal.api.data.taas.StructureObject;
 import com.knecon.fforesight.service.layoutparser.internal.api.data.taas.TableData;
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.Boundary;
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.TextRange;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Document;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Page;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.SemanticNode;
@@ -82,15 +82,15 @@ public class TaasDocumentDataMapper {
    }


-    private static Range toRange(Boundary boundary) {
+    private static Range toRange(TextRange textRange) {

-        return new Range(boundary.start(), boundary.end());
+        return new Range(textRange.start(), textRange.end());
    }


-    private static List<Range> toRange(List<Boundary> boundary) {
+    private static List<Range> toRange(List<TextRange> textRange) {

-        return boundary.stream().map(TaasDocumentDataMapper::toRange).toList();
+        return textRange.stream().map(TaasDocumentDataMapper::toRange).toList();
    }


@@ -99,6 +99,7 @@ public class TaasDocumentDataMapper {
        Page page = semanticNode.getFirstPage();
        Rectangle2D bBox = semanticNode.getBBox().get(page);
        return StructureObject.builder()
+                .treeId(semanticNode.getTreeId())
                .structureObjectNumber(structureObjectNumber)
                .boundingBox(toFloatArray(bBox))
                .stringOffset(semanticNode.getBoundary().start())
@@ -114,6 +115,7 @@ public class TaasDocumentDataMapper {
        Page page = table.getFirstPage();
        Rectangle2D bBox = table.getBBox().get(page);
        return StructureObject.builder()
+                .treeId(table.getTreeId())
                .structureObjectNumber(structureObjectNumber)
                .boundingBox(toFloatArray(bBox))
                .stringOffset(table.getBoundary().start())
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Maverick Studer	31de229fa5	Merge branch 'feature/RED-9010' into 'main' RED-9010: remove redaction log See merge request fforesight/layout-parser!231	2024-09-19 11:34:32 +02:00
Maverick Studer	8a80abfff1	RED-9010: remove redaction log	2024-09-19 11:34:32 +02:00
Dominique Eifländer	7c08905eda	Merge branch 'RED-9975-main' into 'main' RED-9975: Fixed missing section numbers in layout grid See merge request fforesight/layout-parser!230	2024-09-18 11:29:51 +02:00
Dominique Eifländer	4f40c9dbc9	RED-9975: Fixed missing section numbers in layout grid	2024-09-18 11:22:37 +02:00
Dominique Eifländer	32381b4472	Merge branch 'RED-9974' into 'main' Red 9974: improce headline classification, fix font size calculation See merge request fforesight/layout-parser!226	2024-09-16 14:06:48 +02:00
Kilian Schüttler	469da38952	Red 9974: improce headline classification, fix font size calculation	2024-09-16 14:06:48 +02:00
Dominique Eifländer	0f8c4674b3	Merge branch 'hotfix' into 'main' hotfix: viewerDocService doesn't remove existing marked content See merge request fforesight/layout-parser!225	2024-09-12 09:12:54 +02:00
Kilian Schuettler	8e165a41d7	hotfix: viewerDocService doesn't remove existing marked content	2024-09-11 16:34:21 +02:00
Kilian Schüttler	ed7a701ad9	Merge branch 'RED-9975' into 'main' RED-9975: improve SuperSection handling See merge request fforesight/layout-parser!223	2024-09-11 13:38:09 +02:00
Kilian Schüttler	393103e074	RED-9975: improve SuperSection handling	2024-09-11 13:38:09 +02:00
Dominique Eifländer	bd02066e2c	Merge branch 'RED-9976-main' into 'main' RED-9976: Removed sorting that scrambles text in PDFTextStripper See merge request fforesight/layout-parser!222	2024-09-10 13:02:36 +02:00
Dominique Eifländer	fec19f4afb	RED-9976: Removed sorting that scrambles text in PDFTextStripper	2024-09-10 12:50:37 +02:00
Kilian Schüttler	c726a643f0	Merge branch 'hotfix' into 'main' Hotfix: unmerge super large tables See merge request fforesight/layout-parser!220	2024-09-05 15:05:21 +02:00
Kilian Schüttler	519e95735c	Hotfix: unmerge super large tables	2024-09-05 15:05:21 +02:00
Maverick Studer	b52af2637f	Merge branch 'RED-9942-2' into 'main' RED-9942: File only with images not recognised See merge request fforesight/layout-parser!218	2024-09-05 10:49:12 +02:00
Maverick Studer	46ea7edc4c	RED-9942: File only with images not recognised	2024-09-05 10:49:12 +02:00
Kilian Schüttler	9650195afd	Merge branch 'hotfix-fp' into 'main' hotfix: add Java advanced imaging See merge request fforesight/layout-parser!217	2024-09-04 15:43:56 +02:00
Kilian Schuettler	ce628a99f7	hotfix: add Java advanced imaging	2024-09-04 15:18:12 +02:00
Maverick Studer	b66afe135c	Merge branch 'RED-9524' into 'main' RED-9524: File processing does not annotate images See merge request fforesight/layout-parser!214	2024-09-04 13:27:06 +02:00
Maverick Studer	dc892d0fec	RED-9524: File processing does not annotate images	2024-09-04 13:27:06 +02:00
Kilian Schüttler	af45f2cd8c	Merge branch 'RED-9964' into 'main' RED-9964: fix errors with images See merge request fforesight/layout-parser!212	2024-09-04 09:16:59 +02:00
Kilian Schuettler	befb6b1df6	RED-9964: fix errors with images	2024-09-03 16:37:48 +02:00
Maverick Studer	61efb4cae9	Merge branch 'update-tc' into 'main' Update tenant-commons for dlq fix See merge request fforesight/layout-parser!211	2024-09-03 13:50:02 +02:00
maverickstuder	4a06059258	Update tenant-commons for dlq fix	2024-09-03 13:15:08 +02:00
Dominique Eifländer	292e5b215e	Merge branch 'RED-9988-main' into 'main' RED-9988: Fixed NPE when image representation is not present See merge request fforesight/layout-parser!210	2024-09-02 09:56:53 +02:00
Dominique Eifländer	7c2db6c3c5	RED-9988: Fixed NPE when image representation is not present	2024-09-02 09:51:59 +02:00
Dominique Eifländer	4395074b21	Merge branch 'RED-9975' into 'main' Red 9975: fix outline detection See merge request fforesight/layout-parser!206	2024-09-02 09:02:36 +02:00
Kilian Schüttler	8e14b74da2	Red 9975: fix outline detection	2024-09-02 09:02:36 +02:00
Kilian Schüttler	3b91639ea9	Merge branch 'RED-9964-fp' into 'main' RED-9964: don't merge tables on non-consecutive pages See merge request fforesight/layout-parser!205	2024-08-30 14:00:48 +02:00
Kilian Schüttler	c5178ea5c2	RED-9964: don't merge tables on non-consecutive pages	2024-08-30 14:00:48 +02:00
Dominique Eifländer	cf39d4dfcc	Merge branch 'RED-9974' into 'main' RED-9974: Improved headline detection for documine old See merge request fforesight/layout-parser!202	2024-08-30 10:57:20 +02:00
Dominique Eifländer	bb40345f79	RED-9974: Improved headline detection for documine old	2024-08-30 10:36:22 +02:00
Kilian Schüttler	e3e9d16145	Merge branch 'RED-9975' into 'main' RED-9975: activate outline detection See merge request fforesight/layout-parser!201	2024-08-29 14:27:00 +02:00
Kilian Schuettler	f6ca5a3c17	RED-9975: activate outline detection	2024-08-29 14:18:29 +02:00
Maverick Studer	15e3dced35	Merge branch 'tenants-retry' into 'main' Tenants retry logic and queue renames See merge request fforesight/layout-parser!197	2024-08-29 13:46:54 +02:00
Maverick Studer	933054b332	Tenants retry logic and queue renames	2024-08-29 13:46:54 +02:00
Kilian Schüttler	ab86714cb3	Merge branch 'RED-9975' into 'main' RED-9975: activate outline detection See merge request fforesight/layout-parser!198	2024-08-29 12:25:42 +02:00
Kilian Schuettler	8626b106d0	RED-9975: activate outline detection	2024-08-29 12:16:07 +02:00
Maverick Studer	52e948e66c	Merge branch 'RED-9331' into 'main' RED-9331: Explore possibilities for fair upload / analysis processing per tenant See merge request fforesight/layout-parser!182	2024-08-27 09:27:37 +02:00
Maverick Studer	3b33405cbf	RED-9331: Explore possibilities for fair upload / analysis processing per tenant	2024-08-27 09:27:37 +02:00
Maverick Studer	b2fa14dde2	Merge branch 'AZURE_NER' into 'main' RED-9918: Azure entity recognition (Spike) See merge request fforesight/layout-parser!196	2024-08-26 14:34:46 +02:00
Maverick Studer	62e07686d7	RED-9918: Azure entity recognition (Spike)	2024-08-26 14:34:46 +02:00
Dominique Eifländer	3eb97d614f	Merge branch 'RED-9760-NPE' into 'main' RED-9760: Fixed nullpointer in TextPageBlock See merge request fforesight/layout-parser!194	2024-08-13 13:24:48 +02:00
Dominique Eifländer	81469413b0	RED-9760: Fixed nullpointer in TextPageBlock	2024-08-13 13:18:50 +02:00
Dominique Eifländer	2993676a6f	Merge branch 'RED-9670' into 'main' RED-9760: change compareDouble to something sensible See merge request fforesight/layout-parser!193	2024-08-12 16:02:51 +02:00
Kilian Schüttler	8e115dcd8a	RED-9760: change compareDouble to something sensible	2024-08-12 16:02:50 +02:00
Dominique Eifländer	173911b840	Merge branch 'hotfix-reading-order' into 'main' hotfix: threshold adjustements See merge request fforesight/layout-parser!192	2024-08-12 14:59:20 +02:00
Kilian Schuettler	b0ae00aa02	hotfix: threshold adjustements	2024-08-12 14:52:18 +02:00
Dominique Eifländer	00bf9f279e	Merge branch 'hotfix-reading-order' into 'main' hotfix: use center coordinates See merge request fforesight/layout-parser!191	2024-08-09 15:51:42 +02:00
Kilian Schuettler	d16377a24a	hotfix: line comparison with center coordinates	2024-08-09 15:45:23 +02:00
Dominique Eifländer	81179ee744	Merge branch 'RED-9760-dcold' into 'main' RED-9760: Changed lineSeparation threshold for documine old See merge request fforesight/layout-parser!190	2024-08-09 14:50:39 +02:00
Dominique Eifländer	1953b5924f	RED-9760: Changed lineSeparation threshold for documine old	2024-08-09 14:42:14 +02:00
Kilian Schüttler	6f6e8d5d4e	Merge branch 'hotfix-reading-order' into 'main' hotfix reading order See merge request fforesight/layout-parser!187	2024-08-09 11:49:12 +02:00
Kilian Schüttler	69bcd4f68d	hotfix reading order	2024-08-09 11:49:12 +02:00
Timo Bejan	b900cfaf31	Merge branch 'CLARI-140' into 'main' CLARI-140 - case issue See merge request fforesight/layout-parser!189	2024-08-08 21:49:40 +02:00
Timo Bejan	cdc2081785	CLARI-140 - case issue	2024-08-08 22:40:11 +03:00
Timo Bejan	a9287ec406	Merge branch 'CLARI-139' into 'main' CLAR-139 - fixed outline error for unparsable object See merge request fforesight/layout-parser!188	2024-08-08 16:36:41 +02:00
Timo Bejan	5b6a706c28	CLAR-139 - fixed outline error for unparsable object	2024-08-08 16:20:14 +03:00
Timo Bejan	28d8ad0a3f	Merge branch 'CLARI-128' into 'main' Fixed Index out of bounds exception in blockificationpostprocessingservice -... See merge request fforesight/layout-parser!186	2024-07-30 16:56:21 +02:00
Timo Bejan	0c1583c1be	Fixed Index out of bounds exception in blockificationpostprocessingservice - this could should be documented btw, there are also probably other use-cases where the code doesnt work	2024-07-30 17:45:05 +03:00
Andrei Isvoran	7633566d9b	Merge branch 'RED-9607-fp' into 'main' RED-9607 - Correctly determine text position sequence based on file rotation See merge request fforesight/layout-parser!184	2024-07-25 14:11:00 +02:00
Andrei Isvoran	cc4f09711e	RED-9607 - Correctly determine text position sequence based on file rotation	2024-07-24 16:35:11 +03:00
Kilian Schüttler	370165dc59	Merge branch 'document-data-markdown' into 'main' CLARI: document-data-markdown See merge request fforesight/layout-parser!181	2024-07-18 17:19:44 +02:00
Maverick Studer	8c052c38d7	CLARI: document-data-markdown	2024-07-18 17:19:43 +02:00
Kilian Schüttler	ea18d3d307	Merge branch 'RED-8800' into 'main' RED-8800: adjust coordinates in BE to ignore cropbox See merge request fforesight/layout-parser!179	2024-07-15 17:45:13 +02:00
Kilian Schüttler	2726fc3fe1	RED-8800: adjust coordinates in BE to ignore cropbox	2024-07-15 17:45:13 +02:00
Kilian Schüttler	033279e261	Merge branch 'RED-9353' into 'main' RED-9353: refactor PDFTronViewerDocumentService See merge request fforesight/layout-parser!178	2024-07-15 12:54:17 +02:00
Kilian Schüttler	ec0dd032c9	RED-9353: refactor PDFTronViewerDocumentService	2024-07-15 12:54:17 +02:00
Andrei Isvoran	598fa7f1c7	Merge branch 'RED-9496-shutdown-fp' into 'main' RED-9496 - Implement graceful shutdown See merge request fforesight/layout-parser!176	2024-07-04 14:26:00 +02:00
Andrei Isvoran	65b1f7d179	RED-9496 - Implement graceful shutdown	2024-07-04 14:21:20 +03:00
Kilian Schüttler	3173610be5	Merge branch 'CLARI-003' into 'main' CLARI-003: add treeId to StructureObject See merge request fforesight/layout-parser!176	2024-07-02 11:37:22 +02:00
Kilian Schuettler	e920eb5a78	CLARI-003: add treeId to StructureObject	2024-07-01 13:56:16 +02:00
Kilian Schüttler	7e4baea7e5	Merge branch 'RED-9353' into 'main' RED-9353: use azure ocr service See merge request fforesight/layout-parser!175	2024-07-01 11:13:27 +02:00
Kilian Schüttler	66d3433e04	RED-9353: use azure ocr service	2024-07-01 11:13:26 +02:00
Yannik Hampe	a2f559af51	Merge branch 'RED-3813' into 'main' RED-3813: Recategorize same image as experimental feature See merge request fforesight/layout-parser!155	2024-06-26 13:42:42 +02:00
Yannik Hampe	39f527a57c	Merge branch 'main' into 'RED-3813' # Conflicts: # layoutparser-service/layoutparser-service-processor/src/main/java/com/knecon/fforesight/service/layoutparser/processor/LayoutParsingPipeline.java	2024-06-26 09:10:59 +02:00
yhampe	5c2844fe31	RED-3813: Recategorize same image as experimental feature fixed failing test	2024-06-26 09:08:37 +02:00
Kilian Schüttler	b216f02e15	Merge branch 'RED-9194' into 'main' RED-9194: roll back single digit headline change See merge request fforesight/layout-parser!171	2024-06-21 15:13:40 +02:00
Kilian Schuettler	2e2f30ba35	RED-9194: roll back single digit headline change	2024-06-21 14:42:30 +02:00
Kilian Schuettler	9f7ed974ec	RED-9194: roll back single digit headline change	2024-06-21 14:41:30 +02:00
Kilian Schuettler	570a348a77	RED-9194: roll back single digit headline change	2024-06-21 14:39:47 +02:00
Maverick Studer	859dba2ecf	Merge branch 'RED-9374' into 'main' hotfix for table/paragraph section creation on document start before first headline See merge request fforesight/layout-parser!170	2024-06-18 17:36:04 +02:00
Maverick Studer	1c5d755111	hotfix for table/paragraph section creation on document start before first headline	2024-06-18 17:36:04 +02:00
Maverick Studer	133e06460f	Merge branch 'RED-9374' into 'main' RED-9374: Ner Entities are at wrong locations See merge request fforesight/layout-parser!169	2024-06-18 16:31:24 +02:00
Maverick Studer	da91fcff97	RED-9374: Ner Entities are at wrong locations	2024-06-18 16:31:24 +02:00
Kilian Schüttler	79795e408a	Merge branch 'RED-9194' into 'main' RED-9194: allow single digit headline identifiers See merge request fforesight/layout-parser!168	2024-06-07 09:09:25 +02:00
Kilian Schuettler	b719db86ab	RED-9194: allow single digit headline identifiers	2024-06-06 16:32:05 +02:00
Maverick Studer	797602e373	Merge branch 'thread-safe-hcs-fields' into 'main' fixed issue with thread-safety of local fields in the HeadlineClassificationService See merge request fforesight/layout-parser!167	2024-06-06 14:51:24 +02:00
maverickstuder	3d2f66cf10	fixed issue with thread-safety of local fields in the HeadlineClassificationService: * HeadlineClassificationService is no singleton anymore * instead initialize it in the ClassificationService and pass it to the classifyMethods as required	2024-06-06 14:39:23 +02:00
yhampe	9ecf9ca19f	RED-3813: Recategorize same image as experimental feature now writing hash into structure	2024-06-05 14:20:33 +02:00
yhampe	9be672c728	RED-3813: Recategorize same image as experimental feature working on pushing properties to persistence service	2024-05-28 13:51:45 +02:00
yhampe	a5fcebce30	RED-3813: Recategorize same image as experimental feature added representation to image and DocumentStructure	2024-05-17 07:34:05 +02:00