RED-7141: Fixed endless processing when only one character on page

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

@@ -1,10 +1,10 @@
 package com.knecon.fforesight.service.layoutparser.internal.api.queue;
 
 public enum LayoutParsingType {
-    REDACT_MANAGER,
     REDACT_MANAGER_OLD,
-    REDACT_MANAGER_PARAGRAPH_DEBUG,
+    TAAS,
     DOCUMINE,
-    CLARIFYND,
-    CLARIFYND_PARAGRAPH_DEBUG
+
+    DOCSTRUM,
+    REDACT_MANAGER
 }

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

@@ -24,5 +24,4 @@ dependencies {
     implementation("com.fasterxml.jackson.module:jackson-module-afterburner:${jacksonVersion}")
     implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:${jacksonVersion}")
     implementation("org.springframework.boot:spring-boot-starter-web:3.1.3")
-    implementation("org.jgrapht:jgrapht-core:1.5.2")
 }

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

@@ -47,8 +47,10 @@ import com.knecon.fforesight.service.layoutparser.processor.services.TableExtrac
 import com.knecon.fforesight.service.layoutparser.processor.services.blockification.DocstrumBlockificationService;
 import com.knecon.fforesight.service.layoutparser.processor.services.blockification.DocuMineBlockificationService;
 import com.knecon.fforesight.service.layoutparser.processor.services.blockification.RedactManagerBlockificationService;
+import com.knecon.fforesight.service.layoutparser.processor.services.blockification.TaasBlockificationService;
 import com.knecon.fforesight.service.layoutparser.processor.services.classification.DocuMineClassificationService;
 import com.knecon.fforesight.service.layoutparser.processor.services.classification.RedactManagerClassificationService;
+import com.knecon.fforesight.service.layoutparser.processor.services.classification.TaasClassificationService;
 import com.knecon.fforesight.service.layoutparser.processor.services.factory.DocumentGraphFactory;
 import com.knecon.fforesight.service.layoutparser.processor.services.mapper.DocumentDataMapper;
 import com.knecon.fforesight.service.layoutparser.processor.services.mapper.TaasDocumentDataMapper;
@@ -76,12 +78,14 @@ public class LayoutParsingPipeline {
     CvTableParsingAdapter cvTableParsingAdapter;
     LayoutParsingStorageService layoutParsingStorageService;
     SectionsBuilderService sectionsBuilderService;
+    TaasClassificationService taasClassificationService;
     RedactManagerClassificationService redactManagerClassificationService;
     DocuMineClassificationService docuMineClassificationService;
     SimplifiedSectionTextService simplifiedSectionTextService;
     BodyTextFrameService bodyTextFrameService;
     RulingCleaningService rulingCleaningService;
     TableExtractionService tableExtractionService;
+    TaasBlockificationService taasBlockificationService;
     DocuMineBlockificationService docuMineBlockificationService;
     RedactManagerBlockificationService redactManagerBlockificationService;
     DocstrumBlockificationService docstrumBlockificationService;
@@ -122,7 +126,7 @@ public class LayoutParsingPipeline {
 
         log.info("Building document graph for {}", layoutParsingRequest.identifier());
 
-        Document documentGraph = observeBuildDocumentGraph(layoutParsingRequest.layoutParsingType(), classificationDocument);
+        Document documentGraph = observeBuildDocumentGraph(classificationDocument);
 
         log.info("Creating viewer document for {}", layoutParsingRequest.identifier());
 
@@ -134,7 +138,7 @@ public class LayoutParsingPipeline {
         layoutParsingStorageService.storeSimplifiedText(layoutParsingRequest, simplifiedSectionTextService.toSimplifiedText(documentGraph));
         layoutParsingStorageService.storeViewerDocument(layoutParsingRequest, viewerDocumentFile);
 
-        if (layoutParsingRequest.layoutParsingType().equals(LayoutParsingType.CLARIFYND)) {
+        if (layoutParsingRequest.layoutParsingType().equals(LayoutParsingType.TAAS)) {
             log.info("Building research document data for {}", layoutParsingRequest.identifier());
             var researchDocumentData = TaasDocumentDataMapper.fromDocument(documentGraph);
             layoutParsingStorageService.storeResearchDocumentData(layoutParsingRequest, researchDocumentData);
@@ -174,13 +178,13 @@ public class LayoutParsingPipeline {
     }
 
 
-    private Document observeBuildDocumentGraph(LayoutParsingType layoutParsingType, ClassificationDocument classificationDocument) {
+    private Document observeBuildDocumentGraph(ClassificationDocument classificationDocument) {
 
         AtomicReference<Document> documentReference = new AtomicReference<>();
 
         Observation.createNotStarted("LayoutParsingPipeline", observationRegistry)
                 .contextualName("build-document-graph")
-                .observe(() -> documentReference.set(DocumentGraphFactory.buildDocumentGraph(layoutParsingType, classificationDocument)));
+                .observe(() -> documentReference.set(DocumentGraphFactory.buildDocumentGraph(classificationDocument)));
 
         return documentReference.get();
     }
@@ -252,16 +256,16 @@ public class LayoutParsingPipeline {
             PDRectangle cropbox = pdPage.getCropBox();
             CleanRulings cleanRulings = rulingCleaningService.getCleanRulings(pdfTableCells.get(pageNumber), stripper.getRulings());
 
-            List<Cell> emptyTableCells = TableExtractionService.findCells(cleanRulings.getHorizontal(), cleanRulings.getVertical());
+            List<Cell> emptyTableCells = tableExtractionService.findCells(cleanRulings.getHorizontal(), cleanRulings.getVertical());
 
             ClassificationPage classificationPage = switch (layoutParsingType) {
                 case REDACT_MANAGER_OLD ->
                         redactManagerBlockificationService.blockify(stripper.getTextPositionSequences(), cleanRulings.getHorizontal(), cleanRulings.getVertical());
+                case TAAS -> taasBlockificationService.blockify(stripper.getTextPositionSequences(), cleanRulings.getHorizontal(), cleanRulings.getVertical());
                 case DOCUMINE -> docuMineBlockificationService.blockify(stripper.getTextPositionSequences(), cleanRulings.getHorizontal(), cleanRulings.getVertical());
-                case REDACT_MANAGER, REDACT_MANAGER_PARAGRAPH_DEBUG -> docstrumBlockificationService.blockify(stripper.getTextPositionSequences(), emptyTableCells, true);
-                case CLARIFYND, CLARIFYND_PARAGRAPH_DEBUG -> docstrumBlockificationService.blockify(stripper.getTextPositionSequences(), emptyTableCells, false);
+                case DOCSTRUM -> docstrumBlockificationService.blockify(stripper.getTextPositionSequences(), emptyTableCells, false);
+                case REDACT_MANAGER -> docstrumBlockificationService.blockify(stripper.getTextPositionSequences(), emptyTableCells, true);
             };
-
             classificationPage.setCleanRulings(cleanRulings);
             classificationPage.setRotation(rotation);
             classificationPage.setLandscape(isLandscape);
@@ -288,10 +292,8 @@ public class LayoutParsingPipeline {
 
             tableExtractionService.extractTables(emptyTableCells, classificationPage);
 
-            if (layoutParsingType == LayoutParsingType.REDACT_MANAGER) {
+            if (layoutParsingType == LayoutParsingType.DOCSTRUM || layoutParsingType == LayoutParsingType.REDACT_MANAGER) {
                 docstrumBlockificationService.combineBlocks(classificationPage);
-            } else if (layoutParsingType == LayoutParsingType.CLARIFYND) {
-                docstrumBlockificationService.mergeZones(classificationPage.getTextBlocks());
             }
 
             buildPageStatistics(classificationPage);
@@ -306,21 +308,30 @@ public class LayoutParsingPipeline {
         bodyTextFrameService.setBodyTextFrames(classificationDocument, layoutParsingType);
         log.info("Classify TextBlocks for {}", identifier);
         switch (layoutParsingType) {
-            case REDACT_MANAGER, REDACT_MANAGER_PARAGRAPH_DEBUG, REDACT_MANAGER_OLD, CLARIFYND, CLARIFYND_PARAGRAPH_DEBUG ->
-                    redactManagerClassificationService.classifyDocument(classificationDocument);
+            case TAAS -> taasClassificationService.classifyDocument(classificationDocument);
             case DOCUMINE -> docuMineClassificationService.classifyDocument(classificationDocument);
+            case REDACT_MANAGER_OLD -> redactManagerClassificationService.classifyDocument(classificationDocument);
+            case REDACT_MANAGER -> redactManagerClassificationService.classifyDocument(classificationDocument);
+            case DOCSTRUM -> redactManagerClassificationService.classifyDocument(classificationDocument);
         }
 
         log.info("Building Sections for {}", identifier);
 
-        switch (layoutParsingType) {
-            case CLARIFYND_PARAGRAPH_DEBUG, REDACT_MANAGER_PARAGRAPH_DEBUG -> sectionsBuilderService.buildParagraphDebugSections(classificationDocument);
-            default -> {
-                sectionsBuilderService.buildSections(classificationDocument);
-                sectionsBuilderService.addImagesToSections(classificationDocument);
-            }
-        }
-
+//        if (layoutParsingType == DOCSTRUM || layoutParsingType == DOCSTRUM_XY) {
+//            // Currently for debugging return paragraphs as sections, because there is a merging logic in sectionBuilder
+//            List<ClassificationSection> sections = new ArrayList<>();
+//            for (var page : classificationPages) {
+//                page.getTextBlocks().forEach(block -> {
+//                    block.setPage(page.getPageNumber());
+//                    var section = sectionsBuilderService.buildTextBlock(List.of(block), "a");
+//                    sections.add(section);
+//                });
+//            }
+//            classificationDocument.setSections(sections);
+//        } else {
+        sectionsBuilderService.buildSections(classificationDocument);
+        sectionsBuilderService.addImagesToSections(classificationDocument);
+//        }
         return classificationDocument;
     }
 

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

@@ -25,7 +25,6 @@ public class BodyTextFrameService {
     private static final float RULING_HEIGHT_THRESHOLD = 0.15f; // multiplied with page height. Header/Footer Rulings must be within that border of the page.
     private static final float RULING_WIDTH_THRESHOLD = 0.75f; // multiplied with page width. Header/Footer Rulings must be at least that wide.
 
-
     public void setBodyTextFrames(ClassificationDocument classificationDocument, LayoutParsingType layoutParsingType) {
 
         Rectangle bodyTextFrame = calculateBodyTextFrame(classificationDocument.getPages(), classificationDocument.getFontSizeCounter(), false, layoutParsingType);
@@ -133,7 +132,12 @@ public class BodyTextFrameService {
                                                boolean landscape,
                                                LayoutParsingType layoutParsingType) {
 
-        float approximateHeaderLineCount = 2.9f;
+        float approximateHeaderLineCount;
+        if (layoutParsingType.equals(LayoutParsingType.TAAS)) {
+            approximateHeaderLineCount = 3.3f;
+        } else {
+            approximateHeaderLineCount = 2.9f;
+        }
 
         BodyTextFrameExpansionsRectangle expansionsRectangle = new BodyTextFrameExpansionsRectangle();
 
@@ -151,9 +155,8 @@ public class BodyTextFrameService {
                         continue;
                     }
 
-                    if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.HEADER) || MarkedContentUtils.intersects(textBlock,
-                            page.getMarkedContentBboxPerType(),
-                            MarkedContentUtils.FOOTER)) {
+                    if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.HEADER)
+                            || MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.FOOTER)) {
                         continue;
                     }
 

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

@@ -7,7 +7,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 
-import org.apache.logging.log4j.util.Strings;
 import org.springframework.stereotype.Service;
 
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
@@ -111,20 +110,6 @@ public class SectionsBuilderService {
     }
 
 
-    public void buildParagraphDebugSections(ClassificationDocument document) {
-
-        List<ClassificationSection> sections = new ArrayList<>();
-        for (var page : document.getPages()) {
-            page.getTextBlocks().forEach(block -> {
-                block.setPage(page.getPageNumber());
-                var section = buildTextBlock(List.of(block), Strings.EMPTY);
-                sections.add(section);
-            });
-        }
-        document.setSections(sections);
-    }
-
-
     public void addImagesToSections(ClassificationDocument document) {
 
         Map<Integer, List<ClassificationSection>> sectionMap = new HashMap<>();
@@ -255,7 +240,7 @@ public class SectionsBuilderService {
     }
 
 
-    private ClassificationSection buildTextBlock(List<AbstractPageBlock> wordBlockList, String lastHeadline) {
+    public ClassificationSection buildTextBlock(List<AbstractPageBlock> wordBlockList, String lastHeadline) {
 
         ClassificationSection section = new ClassificationSection();
 

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

@@ -38,7 +38,7 @@ public class DocstrumBlockificationService {
     static final float THRESHOLD = 1f;
 
 
-    public ClassificationPage blockify(List<TextPositionSequence> textPositions, List<Cell> cells, boolean xyOrder) {
+    public ClassificationPage blockify(List<TextPositionSequence> textPositions, List<Cell> cells, boolean xyOder) {
 
         // Underlined or strikethrough are also in rulings but we dont want to split blocks with them so we use cells.
         List<Ruling> usedHorizonalRulings = new ArrayList<>();
@@ -52,7 +52,7 @@ public class DocstrumBlockificationService {
         });
 
         List<AbstractPageBlock> abstractPageBlocks = new ArrayList<>();
-        var zones = docstrumSegmentationService.segmentPage(textPositions, xyOrder);
+        var zones = docstrumSegmentationService.segmentPage(textPositions, xyOder);
         zones.forEach(zone -> {
 
             List<TextPositionSequence> textPositionSequences = new ArrayList<>();
@@ -63,6 +63,7 @@ public class DocstrumBlockificationService {
             });
 
             abstractPageBlocks.addAll(splitZonesAtRulings(textPositionSequences, usedHorizonalRulings, usedVerticalRulings));
+//            abstractPageBlocks.add(buildTextBlock(textPositionSequences, 0));
         });
 
         return new ClassificationPage(abstractPageBlocks);
@@ -146,7 +147,6 @@ public class DocstrumBlockificationService {
         }
 
         mergeZones(page.getTextBlocks());
-
     }
 
 
@@ -188,7 +188,7 @@ public class DocstrumBlockificationService {
     }
 
 
-    public void mergeZones(List<AbstractPageBlock> zones) {
+    private void mergeZones(List<AbstractPageBlock> zones) {
 
         ListIterator<AbstractPageBlock> itty = zones.listIterator();
         Set<AbstractPageBlock> toRemove = new HashSet<>();

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

@@ -0,0 +1,330 @@
+package com.knecon.fforesight.service.layoutparser.processor.services.blockification;
+
+
+// TODO: figure out, why this fails the build
+// import static com.knecon.fforesight.service.layoutparser.processor.services.factory.SearchTextWithTextPositionFactory.HEIGHT_PADDING;
+
+import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
+import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
+import com.knecon.fforesight.service.layoutparser.processor.model.Orientation;
+import com.knecon.fforesight.service.layoutparser.processor.model.table.Ruling;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
+import com.knecon.fforesight.service.layoutparser.processor.utils.RulingTextDirAdjustUtil;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
+@Service
+@SuppressWarnings("all")
+public class TaasBlockificationService {
+
+    private static final float THRESHOLD = 1f;
+    private static final float Y_GAP_SPLIT_HEIGHT_MODIFIER = 1.25f; // multiplied with text height
+    private static final float INTERSECTS_Y_THRESHOLD = 4;// 2 * HEIGHT_PADDING // This is exactly 2 times our position height padding. This is required to find boxes that are visually intersecting.
+    private static final int X_GAP_SPLIT_CONSTANT = 50;
+    public static final int X_ALIGNMENT_THRESHOLD = 1;
+    public static final int NEGATIVE_X_GAP_THRESHOLD = -5;
+
+    private Pattern listIdentifier = Pattern.compile("^(?:(?:[1-9]|1\\d|20|[ivxlc]|[a-z])\\s*(?:[.)]))|\\uF0B7", Pattern.CASE_INSENSITIVE);
+
+
+    /**
+     * This method is building blocks by expanding the minX/maxX and minY/maxY value on each word that is not split by the conditions.
+     * This method must use text direction adjusted postions (DirAdj). Where {0,0} is on the upper left. Never try to change this!
+     * Rulings (Table lines) must be adjusted to the text directions as well, when checking if a block is split by a ruling.
+     *
+     * @param textPositions         The words of a page.
+     * @param horizontalRulingLines Horizontal table lines.
+     * @param verticalRulingLines   Vertical table lines.
+     * @return ClassificationPage object that contains the Textblock and text statistics.
+     */
+    public ClassificationPage blockify(List<TextPositionSequence> textPositions, List<Ruling> horizontalRulingLines, List<Ruling> verticalRulingLines) {
+
+        List<TextPageBlock> classificationTextBlocks = constructFineGranularTextPageBlocks(textPositions, horizontalRulingLines, verticalRulingLines);
+        classificationTextBlocks = mergeTextPageBlocksAligningX(classificationTextBlocks);
+        classificationTextBlocks = mergeIntersectingTextBlocksUntilConvergence(classificationTextBlocks);
+
+        return new ClassificationPage(new ArrayList<>(classificationTextBlocks.stream().map(classificationTextBlock -> (AbstractPageBlock) classificationTextBlock).toList()));
+    }
+
+
+    private List<TextPageBlock> mergeIntersectingTextBlocksUntilConvergence(List<TextPageBlock> classificationTextBlocks) {
+
+        int currentSize = classificationTextBlocks.size();
+        while (true) {
+            classificationTextBlocks = mergeTextPageBlocksAlmostIntersecting(classificationTextBlocks);
+            if (classificationTextBlocks.size() == currentSize) {
+                break;
+            }
+            currentSize = classificationTextBlocks.size();
+        }
+        return classificationTextBlocks;
+    }
+
+
+    private List<TextPageBlock> mergeTextPageBlocksAligningX(List<TextPageBlock> classificationTextBlocks) {
+
+        if (classificationTextBlocks.isEmpty()) {
+            return new ArrayList<>();
+        }
+        List<List<TextPageBlock>> textBlocksToMerge = new LinkedList<>();
+        List<TextPageBlock> currentTextBlocksToMerge = new LinkedList<>();
+        textBlocksToMerge.add(currentTextBlocksToMerge);
+        TextPageBlock previousTextBlock = null;
+        Float lastLineGap = null;
+        for (TextPageBlock currentTextBlock : classificationTextBlocks) {
+            if (previousTextBlock == null) {
+                currentTextBlocksToMerge.add(currentTextBlock);
+                previousTextBlock = currentTextBlock;
+                continue;
+            }
+
+
+            Matcher listIdentifierPattern = listIdentifier.matcher(currentTextBlock.getText());
+            boolean isListIdentifier = listIdentifierPattern.find();
+
+            boolean yGap = Math.abs(currentTextBlock.getPdfMaxY() - previousTextBlock.getPdfMinY()) < previousTextBlock.getMostPopularWordHeight() * Y_GAP_SPLIT_HEIGHT_MODIFIER;
+
+            boolean sameFont = previousTextBlock.getMostPopularWordFont().equals(currentTextBlock.getMostPopularWordFont()) && previousTextBlock.getMostPopularWordFontSize() == currentTextBlock.getMostPopularWordFontSize();
+//            boolean yGap = previousTextBlock != null && currentTextBlock.getMinYDirAdj() - maxY > Math.min(word.getHeight(), prev.getHeight()) * Y_GAP_SPLIT_HEIGHT_MODIFIER;
+
+            boolean alignsXRight = Math.abs(currentTextBlock.getPdfMaxX() - previousTextBlock.getPdfMaxX()) < X_ALIGNMENT_THRESHOLD;
+            boolean alignsXLeft = Math.abs(currentTextBlock.getPdfMinX() - previousTextBlock.getPdfMinX()) < X_ALIGNMENT_THRESHOLD;
+//            boolean smallYGap = Math.abs(currentTextBlock.getPdfMaxY() - previousTextBlock.getPdfMinY()) < yGap;
+            if (yGap && sameFont && !isListIdentifier) {
+                currentTextBlocksToMerge.add(currentTextBlock);
+
+            } else {
+                currentTextBlocksToMerge = new LinkedList<>();
+                currentTextBlocksToMerge.add(currentTextBlock);
+                textBlocksToMerge.add(currentTextBlocksToMerge);
+            }
+            previousTextBlock = currentTextBlock;
+        }
+        return textBlocksToMerge.stream().map(TextPageBlock::merge).toList();
+    }
+
+
+    private List<TextPageBlock> mergeTextPageBlocksAlmostIntersecting(List<TextPageBlock> textPageBlocks) {
+
+        Set<TextPageBlock> alreadyMerged = new HashSet<>();
+        List<List<TextPageBlock>> textBlocksToMerge = new LinkedList<>();
+        for (TextPageBlock textPageBlock : textPageBlocks) {
+            if (alreadyMerged.contains(textPageBlock)) {
+                continue;
+            }
+            alreadyMerged.add(textPageBlock);
+            textBlocksToMerge.add(Stream.concat(Stream.of(textPageBlock),
+                            textPageBlocks.stream().filter(textPageBlock2 -> textPageBlock.almostIntersects(textPageBlock2, INTERSECTS_Y_THRESHOLD, 0) && !alreadyMerged.contains(textPageBlock2)).peek(alreadyMerged::add))
+                    .toList());
+        }
+        return textBlocksToMerge.stream().map(TextPageBlock::merge).toList();
+    }
+
+
+    private void assignOrientations(List<TextPageBlock> classificationTextBlocks) {
+
+        Iterator<TextPageBlock> itty = classificationTextBlocks.iterator();
+
+        TextPageBlock previousLeft = null;
+        TextPageBlock previousRight = null;
+        while (itty.hasNext()) {
+            TextPageBlock block = (TextPageBlock) itty.next();
+
+            if (previousLeft != null && block.getOrientation().equals(Orientation.LEFT)) {
+                if (previousLeft.getMinY() > block.getMinY() && block.getMaxY() + block.getMostPopularWordHeight() > previousLeft.getMinY()) {
+                    previousLeft.add(block);
+                    itty.remove();
+                    continue;
+                }
+            }
+
+            if (previousRight != null && block.getOrientation().equals(Orientation.RIGHT)) {
+                if (previousRight.getMinY() > block.getMinY() && block.getMaxY() + block.getMostPopularWordHeight() > previousRight.getMinY()) {
+                    previousRight.add(block);
+                    itty.remove();
+                    continue;
+                }
+            }
+
+            if (block.getOrientation().equals(Orientation.LEFT)) {
+                previousLeft = block;
+            } else if (block.getOrientation().equals(Orientation.RIGHT)) {
+                previousRight = block;
+            }
+        }
+
+        itty = classificationTextBlocks.iterator();
+        TextPageBlock previous = null;
+        while (itty.hasNext()) {
+            TextPageBlock block = (TextPageBlock) itty.next();
+
+            if (previous != null && previous.getOrientation().equals(Orientation.LEFT) && block.getOrientation().equals(Orientation.LEFT) && equalsWithThreshold(
+                    block.getMaxY(),
+                    previous.getMaxY()) || previous != null && previous.getOrientation().equals(Orientation.LEFT) && block.getOrientation()
+                    .equals(Orientation.RIGHT) && equalsWithThreshold(block.getMaxY(), previous.getMaxY())) {
+                previous.add(block);
+                itty.remove();
+                continue;
+            }
+
+            previous = block;
+        }
+    }
+
+
+    private List<TextPageBlock> constructFineGranularTextPageBlocks(List<TextPositionSequence> textPositions,
+                                                                    List<Ruling> horizontalRulingLines,
+                                                                    List<Ruling> verticalRulingLines) {
+
+        int indexOnPage = 0;
+        List<TextPositionSequence> wordClusterToCombine = new ArrayList<>();
+        List<TextPageBlock> classificationTextBlocks = new ArrayList<>();
+
+        float minX = 1000, maxX = 0, minY = 1000, maxY = 0;
+        TextPositionSequence prev = null;
+        // TODO: make static final constant
+
+
+        boolean wasSplitted = false;
+        Float splitX1 = null;
+        for (TextPositionSequence word : textPositions) {
+
+            Matcher listIdentifierPattern = listIdentifier.matcher(word.toString());
+
+            boolean yGap = prev != null && word.getMinYDirAdj() - maxY > Math.min(word.getHeight(), prev.getHeight()) * Y_GAP_SPLIT_HEIGHT_MODIFIER;
+            boolean sameLine = prev != null && equalsWithThreshold(prev.getMinYDirAdj(), word.getMinYDirAdj());
+            boolean positiveXGapInline = prev != null && maxX + X_GAP_SPLIT_CONSTANT < word.getMinXDirAdj() && sameLine;
+            boolean negativeXGap = prev != null && word.getMinXDirAdj() - minX < NEGATIVE_X_GAP_THRESHOLD;
+            boolean startFromTop = prev != null && word.getMinYDirAdj() < prev.getMinYDirAdj() - prev.getTextHeight();
+            boolean newLineAfterSplit = prev != null && word.getMinYDirAdj() != prev.getMinYDirAdj() && wasSplitted && splitX1 != word.getMinXDirAdj();
+            boolean splitByRuling = isSplitByRuling(minX, minY, maxX, maxY, word, horizontalRulingLines, verticalRulingLines);
+            boolean splitByDir = prev != null && !prev.getDir().equals(word.getDir());
+            boolean fontChange = prev != null && (!word.getFont().equals(prev.getFont()) || !word.getFontStyle()
+                    .equals(prev.getFontStyle()) || word.getFontSize() != prev.getFontSize());
+            boolean newline = prev != null && Math.abs(word.getMinYDirAdj() - prev.getMinYDirAdj()) > word.getHeight();
+            boolean isListIdentifier = listIdentifierPattern.matches();
+
+            if (prev != null && (prev.isParagraphStart() || negativeXGap || positiveXGapInline || yGap || startFromTop || splitByRuling || (newline && (fontChange || isListIdentifier)))) {
+//            if (prev != null && (lineSeparation || startFromTop || splitByX || splitByDir || isSplitByRuling)) {
+
+                Orientation prevOrientation = null;
+                if (!classificationTextBlocks.isEmpty()) {
+                    prevOrientation = classificationTextBlocks.get(classificationTextBlocks.size() - X_ALIGNMENT_THRESHOLD).getOrientation();
+                }
+
+                TextPageBlock classificationTextBlock = TextPageBlock.fromTextPositionSequences(wordClusterToCombine);
+
+                classificationTextBlocks.add(classificationTextBlock);
+                wordClusterToCombine = new ArrayList<>();
+
+                if (positiveXGapInline && !splitByRuling) {
+                    wasSplitted = true;
+                    classificationTextBlock.setOrientation(Orientation.LEFT);
+                    splitX1 = word.getMinXDirAdj();
+                } else if (newLineAfterSplit && !splitByRuling) {
+                    wasSplitted = false;
+                    classificationTextBlock.setOrientation(Orientation.RIGHT);
+                    splitX1 = null;
+                } else if (prevOrientation != null && prevOrientation.equals(Orientation.RIGHT) && (yGap || !startFromTop || !positiveXGapInline || !newLineAfterSplit || !splitByRuling)) {
+                    classificationTextBlock.setOrientation(Orientation.LEFT);
+                }
+
+                minX = 1000;
+                maxX = 0;
+                minY = 1000;
+                maxY = 0;
+                prev = null;
+            }
+
+            wordClusterToCombine.add(word);
+
+            prev = word;
+            if (word.getMinXDirAdj() < minX) {
+                minX = word.getMinXDirAdj();
+            }
+            if (word.getMaxXDirAdj() > maxX) {
+                maxX = word.getMaxXDirAdj();
+            }
+            if (word.getMinYDirAdj() < minY) {
+                minY = word.getMinYDirAdj();
+            }
+            if (word.getMaxYDirAdj() > maxY) {
+                maxY = word.getMaxYDirAdj();
+            }
+        }
+
+        TextPageBlock classificationTextBlock = TextPageBlock.fromTextPositionSequences(wordClusterToCombine);
+        if (classificationTextBlock != null) {
+            classificationTextBlocks.add(classificationTextBlock);
+        }
+        return classificationTextBlocks;
+    }
+
+
+    private boolean equalsWithThreshold(float f1, float f2) {
+
+        return Math.abs(f1 - f2) < THRESHOLD;
+    }
+
+
+    private boolean isSplitByRuling(float minX,
+                                    float minY,
+                                    float maxX,
+                                    float maxY,
+                                    TextPositionSequence word,
+                                    List<Ruling> horizontalRulingLines,
+                                    List<Ruling> verticalRulingLines) {
+
+        return isSplitByRuling(maxX,
+                minY,
+                word.getMinXDirAdj(),
+                word.getMinYDirAdj(),
+                verticalRulingLines,
+                word.getDir().getDegrees(),
+                word.getPageWidth(),
+                word.getPageHeight()) //
+                || isSplitByRuling(minX,
+                minY,
+                word.getMinXDirAdj(),
+                word.getMaxYDirAdj(),
+                horizontalRulingLines,
+                word.getDir().getDegrees(),
+                word.getPageWidth(),
+                word.getPageHeight()) //
+                || isSplitByRuling(maxX,
+                minY,
+                word.getMinXDirAdj(),
+                word.getMinYDirAdj(),
+                horizontalRulingLines,
+                word.getDir().getDegrees(),
+                word.getPageWidth(),
+                word.getPageHeight()) //
+                || isSplitByRuling(minX,
+                minY,
+                word.getMinXDirAdj(),
+                word.getMaxYDirAdj(),
+                verticalRulingLines,
+                word.getDir().getDegrees(),
+                word.getPageWidth(),
+                word.getPageHeight()); //
+    }
+
+
+    private boolean isSplitByRuling(float previousX2, float previousY1, float currentX1, float currentY1, List<Ruling> rulingLines, float dir, float pageWidth, float pageHeight) {
+
+        for (Ruling ruling : rulingLines) {
+            var line = RulingTextDirAdjustUtil.convertToDirAdj(ruling, dir, pageWidth, pageHeight);
+            if (line.intersectsLine(previousX2, previousY1, currentX1, currentY1)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+}
+

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

@@ -0,0 +1,114 @@
+package com.knecon.fforesight.service.layoutparser.processor.services.classification;
+
+import java.util.List;
+import java.util.regex.Pattern;
+
+import com.knecon.fforesight.service.layoutparser.processor.utils.MarkedContentUtils;
+import org.springframework.stereotype.Service;
+
+import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
+import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationDocument;
+import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationPage;
+import com.knecon.fforesight.service.layoutparser.processor.model.PageBlockType;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPageBlock;
+import com.knecon.fforesight.service.layoutparser.processor.services.BodyTextFrameService;
+import com.knecon.fforesight.service.layoutparser.processor.utils.PositionUtils;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class TaasClassificationService {
+
+    private final BodyTextFrameService bodyTextFrameService;
+
+
+    public void classifyDocument(ClassificationDocument document) {
+
+
+        List<Float> headlineFontSizes = document.getFontSizeCounter().getHighterThanMostPopular();
+
+        log.debug("Document FontSize counters are: {}", document.getFontSizeCounter().getCountPerValue());
+
+        for (ClassificationPage page : document.getPages()) {
+
+            classifyPage(page, document, headlineFontSizes);
+        }
+    }
+
+
+    public void classifyPage(ClassificationPage page, ClassificationDocument document, List<Float> headlineFontSizes) {
+
+        for (AbstractPageBlock textBlock : page.getTextBlocks()) {
+            if (textBlock instanceof TextPageBlock) {
+                classifyBlock((TextPageBlock) textBlock, page, document, headlineFontSizes);
+            }
+        }
+    }
+
+
+    public void classifyBlock(TextPageBlock textBlock, ClassificationPage page, ClassificationDocument document, List<Float> headlineFontSizes) {
+
+        var bodyTextFrame = page.getBodyTextFrame();
+
+        if (document.getFontSizeCounter().getMostPopular() == null) {
+            textBlock.setClassification(PageBlockType.OTHER);
+            return;
+        }
+        if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.HEADER)
+                || PositionUtils.isOverBodyTextFrame(bodyTextFrame, textBlock, page.getRotation())) {
+            textBlock.setClassification(PageBlockType.HEADER);
+        } else if (MarkedContentUtils.intersects(textBlock, page.getMarkedContentBboxPerType(), MarkedContentUtils.FOOTER)
+                || PositionUtils.isUnderBodyTextFrame(bodyTextFrame, textBlock, page.getRotation())) {
+            textBlock.setClassification(PageBlockType.FOOTER);
+        } else if (page.getPageNumber() == 1 && (PositionUtils.getHeightDifferenceBetweenChunkWordAndDocumentWord(textBlock,
+                document.getTextHeightCounter().getMostPopular()) > 2.5 && textBlock.getHighestFontSize() > document.getFontSizeCounter().getMostPopular() || page.getTextBlocks()
+                .size() == 1)) {
+            if (!Pattern.matches("[0-9]+", textBlock.toString())) {
+                textBlock.setClassification(PageBlockType.TITLE);
+            }
+        } else if (textBlock.getMostPopularWordFontSize() > document.getFontSizeCounter()
+                .getMostPopular() && PositionUtils.getApproxLineCount(textBlock) < 4.9 && (textBlock.getMostPopularWordStyle().equals("bold") || !document.getFontStyleCounter()
+                .getCountPerValue()
+                .containsKey("bold") && textBlock.getMostPopularWordFontSize() > document.getFontSizeCounter().getMostPopular() + 1) && textBlock.getSequences()
+                .get(0)
+                .getTextPositions()
+                .get(0)
+                .getFontSizeInPt() >= textBlock.getMostPopularWordFontSize()) {
+
+            for (int i = 1; i <= headlineFontSizes.size(); i++) {
+                if (textBlock.getMostPopularWordFontSize() == headlineFontSizes.get(i - 1)) {
+                    textBlock.setClassification(PageBlockType.getHeadlineType(i));
+                    document.setHeadlines(true);
+                }
+            }
+        } else if (!textBlock.getText().startsWith("Figure ") && PositionUtils.isWithinBodyTextFrame(bodyTextFrame, textBlock) && textBlock.getMostPopularWordStyle()
+                .equals("bold") && !document.getFontStyleCounter().getMostPopular().equals("bold") && PositionUtils.getApproxLineCount(textBlock) < 2.9 && textBlock.getSequences()
+                .get(0)
+                .getTextPositions()
+                .get(0)
+                .getFontSizeInPt() >= textBlock.getMostPopularWordFontSize()) {
+            textBlock.setClassification(PageBlockType.getHeadlineType(headlineFontSizes.size() + 1));
+            document.setHeadlines(true);
+        } else if (PositionUtils.isWithinBodyTextFrame(bodyTextFrame, textBlock) && textBlock.getMostPopularWordFontSize() == document.getFontSizeCounter()
+                .getMostPopular() && textBlock.getMostPopularWordStyle().equals("bold") && !document.getFontStyleCounter().getMostPopular().equals("bold")) {
+            textBlock.setClassification(PageBlockType.PARAGRAPH_BOLD);
+        } else if (PositionUtils.isWithinBodyTextFrame(bodyTextFrame, textBlock) && textBlock.getMostPopularWordFont()
+                .equals(document.getFontCounter().getMostPopular()) && textBlock.getMostPopularWordStyle()
+                .equals(document.getFontStyleCounter().getMostPopular()) && textBlock.getMostPopularWordFontSize() == document.getFontSizeCounter().getMostPopular()) {
+            textBlock.setClassification(PageBlockType.PARAGRAPH);
+        } else if (PositionUtils.isWithinBodyTextFrame(bodyTextFrame, textBlock) && textBlock.getMostPopularWordFontSize() == document.getFontSizeCounter()
+                .getMostPopular() && textBlock.getMostPopularWordStyle().equals("italic") && !document.getFontStyleCounter()
+                .getMostPopular()
+                .equals("italic") && PositionUtils.getApproxLineCount(textBlock) < 2.9) {
+            textBlock.setClassification(PageBlockType.PARAGRAPH_ITALIC);
+        } else if (PositionUtils.isWithinBodyTextFrame(bodyTextFrame, textBlock)) {
+            textBlock.setClassification(PageBlockType.PARAGRAPH_UNKNOWN);
+        } else {
+            textBlock.setClassification(PageBlockType.OTHER);
+        }
+    }
+
+}

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

@@ -29,7 +29,7 @@ public class DocstrumSegmentationService {
     private final ReadingOrderService readingOrderService;
 
 
-    public List<Zone> segmentPage(List<TextPositionSequence> textPositions, boolean xyOrder) {
+    public List<Zone> segmentPage(List<TextPositionSequence> textPositions, boolean xyOder) {
 
         List<Zone> zones = new ArrayList<>();
         zones.addAll(computeZones(textPositions, TextDirection.ZERO));
@@ -37,7 +37,7 @@ public class DocstrumSegmentationService {
         zones.addAll(computeZones(textPositions, TextDirection.HALF_CIRCLE));
         zones.addAll(computeZones(textPositions, TextDirection.THREE_QUARTER_CIRCLE));
 
-        return readingOrderService.resolve(zones, xyOrder);
+        return readingOrderService.resolve(zones, xyOder);
     }
 
 

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

@@ -42,16 +42,7 @@ public abstract class BoundingBox {
 
     public boolean contains(Rectangle2D contained, double tolerance) {
 
-        return bBox.getX() <= contained.getX() + tolerance
-               && bBox.getY() <= contained.getY() + tolerance
-               && bBox.getX() + bBox.getWidth() >= contained.getX() + contained.getWidth() - tolerance
-               && bBox.getY() + bBox.getHeight() >= contained.getY() + contained.getHeight() - tolerance;
-    }
-
-
-    public boolean intersectsY(BoundingBox other) {
-
-        return this.getBBox().getMinY() <= other.getBBox().getMaxY() && this.getBBox().getMaxY() >= other.getBBox().getMinY();
+        return bBox.getX() <= contained.getX() + tolerance && bBox.getY() <= contained.getY() + tolerance && bBox.getX() + bBox.getWidth() >= contained.getX() + contained.getWidth() - tolerance && bBox.getY() + bBox.getHeight() >= contained.getY() + contained.getHeight() - tolerance;
     }
 
 }

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

@@ -0,0 +1,194 @@
+package com.knecon.fforesight.service.layoutparser.processor.services.docstrum.model;
+
+import java.util.AbstractSet;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+
+public class DisjointSets<E> implements Iterable<Set<E>> {
+
+    private final Map<E, Entry<E>> map = new HashMap<>();
+
+
+    public DisjointSets(Collection<? extends E> collection) {
+
+        for (E element : collection) {
+            map.put(element, new Entry<E>(element));
+        }
+    }
+
+
+    public boolean areTogether(E e1, E e2) {
+
+        return map.get(e1).findRepresentative().equals(map.get(e2).findRepresentative());
+    }
+
+
+    public void union(E e1, E e2) {
+
+        Entry<E> r1 = map.get(e1).findRepresentative();
+        Entry<E> r2 = map.get(e2).findRepresentative();
+        if (!r1.equals(r2)) {
+            if (r1.size <= r2.size) {
+                r2.mergeWith(r1);
+            } else {
+                r1.mergeWith(r2);
+            }
+        }
+    }
+
+
+    @Override
+    public Iterator<Set<E>> iterator() {
+
+        return new Iterator<>() {
+
+            private final Iterator<Entry<E>> iterator = map.values().iterator();
+            private Entry<E> nextRepresentative;
+
+            {
+                findNextRepresentative();
+            }
+
+            @Override
+            public boolean hasNext() {
+
+                return nextRepresentative != null;
+            }
+
+
+            @Override
+            public Set<E> next() {
+
+                if (nextRepresentative == null) {
+                    throw new NoSuchElementException();
+                }
+                Set<E> result = nextRepresentative.asSet();
+                findNextRepresentative();
+                return result;
+            }
+
+
+            private void findNextRepresentative() {
+
+                while (iterator.hasNext()) {
+                    Entry<E> candidate = iterator.next();
+                    if (candidate.isRepresentative()) {
+                        nextRepresentative = candidate;
+                        return;
+                    }
+                }
+                nextRepresentative = null;
+            }
+
+
+            @Override
+            public void remove() {
+
+                throw new UnsupportedOperationException();
+            }
+
+        };
+    }
+
+
+    private static class Entry<E> {
+
+        private int size = 1;
+        private final E value;
+        private Entry<E> parent = this;
+        private Entry<E> next;
+        private Entry<E> last = this;
+
+
+        Entry(E value) {
+
+            this.value = value;
+        }
+
+
+        void mergeWith(Entry<E> otherRepresentative) {
+
+            size += otherRepresentative.size;
+            last.next = otherRepresentative;
+            last = otherRepresentative.last;
+            otherRepresentative.parent = this;
+        }
+
+
+        Entry<E> findRepresentative() {
+
+            Entry<E> representative = parent;
+            while (!representative.parent.equals(representative)) {
+                representative = representative.parent;
+            }
+            for (Entry<E> entry = this; !entry.equals(representative); ) {
+                Entry<E> nextEntry = entry.parent;
+                entry.parent = representative;
+                entry = nextEntry;
+            }
+            return representative;
+        }
+
+
+        boolean isRepresentative() {
+
+            return parent.equals(this);
+        }
+
+
+        Set<E> asSet() {
+
+            return new AbstractSet<E>() {
+
+                @Override
+                public Iterator<E> iterator() {
+
+                    return new Iterator<E>() {
+
+                        private Entry<E> nextEntry = findRepresentative();
+
+
+                        @Override
+                        public boolean hasNext() {
+
+                            return nextEntry != null;
+                        }
+
+
+                        @Override
+                        public E next() {
+
+                            if (nextEntry == null) {
+                                throw new NoSuchElementException();
+                            }
+                            E result = nextEntry.value;
+                            nextEntry = nextEntry.next;
+                            return result;
+                        }
+
+
+                        @Override
+                        public void remove() {
+
+                            throw new UnsupportedOperationException();
+                        }
+
+                    };
+                }
+
+
+                @Override
+                public int size() {
+
+                    return findRepresentative().size;
+                }
+            };
+        }
+
+    }
+
+}

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

@@ -12,7 +12,7 @@ import lombok.Data;
 @Data
 public class Line extends BoundingBox {
 
-    private static final double WORD_DISTANCE_MULTIPLIER = 0.18;
+    private static final double WORD_DISTANCE_MULTIPLIER = 0.2;
 
     private final double x0;
     private final double y0;
@@ -78,7 +78,11 @@ public class Line extends BoundingBox {
 
     private double computeHeight() {
 
-        return characters.stream().map(Character::getHeight).reduce(0d, Double::sum) / characters.size();
+        double sum = 0.0;
+        for (Character component : characters) {
+            sum += component.getHeight();
+        }
+        return sum / characters.size();
     }
 
 

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

@@ -1,31 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.processor.services.docstrum.model;
-
-import java.util.Collection;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.Map;
-import java.util.Set;
-
-public class UnionFind<T> extends org.jgrapht.alg.util.UnionFind<T> {
-
-    public UnionFind(Set<T> elements) {
-
-        super(elements);
-    }
-
-
-    public Collection<Set<T>> getGroups() {
-
-        Map<T, Set<T>> setRep = new LinkedHashMap<>();
-        for (T t : getParentMap().keySet()) {
-            T representative = find(t);
-            if (!setRep.containsKey(representative)) {
-                setRep.put(representative, new LinkedHashSet<>());
-            }
-            setRep.get(representative).add(t);
-        }
-
-        return setRep.values();
-    }
-
-}

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

@@ -2,15 +2,14 @@ package com.knecon.fforesight.service.layoutparser.processor.services.docstrum.s
 
 import java.util.ArrayList;
 import java.util.Comparator;
-import java.util.HashSet;
 import java.util.List;
 
 import org.springframework.stereotype.Service;
 
 import com.knecon.fforesight.service.layoutparser.processor.services.docstrum.model.AngleFilter;
 import com.knecon.fforesight.service.layoutparser.processor.services.docstrum.model.Character;
+import com.knecon.fforesight.service.layoutparser.processor.services.docstrum.model.DisjointSets;
 import com.knecon.fforesight.service.layoutparser.processor.services.docstrum.model.Line;
-import com.knecon.fforesight.service.layoutparser.processor.services.docstrum.model.UnionFind;
 
 @Service
 public class LineBuilderService {
@@ -25,8 +24,7 @@ public class LineBuilderService {
         double maxHorizontalDistance = characterSpacing * CHARACTER_SPACING_DISTANCE_MULTIPLIER;
         double maxVerticalDistance = lineSpacing * MAX_VERTICAL_CHARACTER_DISTANCE;
 
-        UnionFind<Character> unionFind = new UnionFind<>(new HashSet<>(characters));
-
+        DisjointSets<Character> sets = new DisjointSets<>(characters);
         AngleFilter filter = new AngleFilter(-ANGLE_TOLERANCE, ANGLE_TOLERANCE);
 
         characters.forEach(character -> {
@@ -35,13 +33,13 @@ public class LineBuilderService {
                 double y = neighbor.getVerticalDistance() / maxVerticalDistance;
                 if (character.getTextPosition().getDir() == neighbor.getCharacter().getTextPosition().getDir() && filter.matches(neighbor) && Math.pow(x, 2) + Math.pow(y,
                         2) <= 1) {
-                    unionFind.union(character, neighbor.getCharacter());
+                    sets.union(character, neighbor.getCharacter());
                 }
             });
         });
 
         List<Line> lines = new ArrayList<>();
-        unionFind.getGroups().forEach(group -> {
+        sets.forEach(group -> {
             List<Character> lineCharacters = new ArrayList<>(group);
             lineCharacters.sort(Comparator.comparingDouble(Character::getX));
             lines.add(new Line(lineCharacters, characterSpacing));

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

@@ -2,10 +2,8 @@ package com.knecon.fforesight.service.layoutparser.processor.services.docstrum.s
 
 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 org.springframework.stereotype.Service;
 
@@ -17,43 +15,22 @@ import com.knecon.fforesight.service.layoutparser.processor.services.docstrum.ut
 public class ReadingOrderService {
 
     private static final double THRESHOLD = 5;
-    public static final double MULTI_COLUMN_DETECTION_THRESHOLD = 1.5;
 
 
-    public List<Zone> resolve(List<Zone> zones, boolean xyReadingOrder) {
+    public List<Zone> resolve(List<Zone> zones, boolean xyOrder) {
 
         if (zones.isEmpty() || zones.size() == 1) {
             return zones;
         }
 
-        if (xyReadingOrder) {
-            return resolveSingleColumnReadingOrder(zones);
+        if (xyOrder) {
+//            QuickSort.sort(zones, new ZoneComparator());
+            zones.sort(Comparator.comparing(BoundingBox::getY, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD))
+                    .thenComparing(BoundingBox::getX, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, 0)));
+            return zones;
         }
 
-        Map<Long, Integer> histogram = new HashMap<>();
-        for (Zone zone : zones) {
-            long minY = Math.round(zone.getBBox().getMinY());
-            long maxY = Math.round(zone.getBBox().getMaxY());
-            for (long i = minY; i <= maxY; i++) {
-                histogram.put(i, histogram.getOrDefault(i, 0) + 1);
-            }
-        }
-
-        if (histogram.values().stream().mapToInt(Integer::intValue).average().orElse(1) < MULTI_COLUMN_DETECTION_THRESHOLD) {
-            return resolveSingleColumnReadingOrder(zones);
-        } else {
-
-            return resolveMultiColumnReadingOder(zones);
-        }
-
-    }
-
-
-    private static List<Zone> resolveSingleColumnReadingOrder(List<Zone> zones) {
-
-        zones.sort(Comparator.comparing(BoundingBox::getY, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD))
-                .thenComparing(BoundingBox::getX, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD)));
-        return zones;
+        return resolveMultiColumnReadingOder(zones);
     }
 
 
@@ -98,48 +75,6 @@ public class ReadingOrderService {
         middle.sort(Comparator.comparing(BoundingBox::getY, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD))
                 .thenComparing(BoundingBox::getX, (o1, o2) -> DoubleUtils.compareDouble(o1, o2, THRESHOLD)));
 
-        List<Zone> leftNotIntersecting = new ArrayList<>();
-        for (Zone leftZone : leftOf) {
-            boolean intersects = false;
-            for (Zone rightZone : rightOf) {
-                if (leftZone.intersectsY(rightZone)) {
-                    intersects = true;
-                    break;
-                }
-                // early stopping
-                if (rightZone.getBBox().getMinY() > leftZone.getBBox().getMaxY()) {
-                    break;
-                }
-            }
-            if (!intersects) {
-                leftNotIntersecting.add(leftZone);
-            }
-        }
-
-        List<Zone> rightNotIntersecting = new ArrayList<>();
-        for (Zone rightZone : rightOf) {
-            boolean intersects = false;
-            for (Zone leftZone : leftOf) {
-                if (rightZone.intersectsY(leftZone)) {
-                    intersects = true;
-                    break;
-                }
-                // early stopping
-                if (leftZone.getBBox().getMinY() > rightZone.getBBox().getMaxY()) {
-                    break;
-                }
-            }
-            if (!intersects) {
-                rightNotIntersecting.add(rightZone);
-            }
-        }
-
-        leftOf.removeAll(leftNotIntersecting);
-        rightOf.removeAll(rightNotIntersecting);
-
-        middle.addAll(leftNotIntersecting);
-        middle.addAll(rightNotIntersecting);
-
         List<Zone> sortedZones = new ArrayList<>();
         sortedZones.addAll(leftOf);
         sortedZones.addAll(rightOf);

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

@@ -2,15 +2,14 @@ package com.knecon.fforesight.service.layoutparser.processor.services.docstrum.s
 
 import java.util.ArrayList;
 import java.util.Comparator;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
 import org.springframework.stereotype.Service;
 
 import com.knecon.fforesight.service.layoutparser.processor.services.docstrum.model.Character;
+import com.knecon.fforesight.service.layoutparser.processor.services.docstrum.model.DisjointSets;
 import com.knecon.fforesight.service.layoutparser.processor.services.docstrum.model.Line;
-import com.knecon.fforesight.service.layoutparser.processor.services.docstrum.model.UnionFind;
 import com.knecon.fforesight.service.layoutparser.processor.services.docstrum.model.Zone;
 
 @Service
@@ -41,7 +40,7 @@ public class ZoneBuilderService {
         double minHorizontalMergeDistance = characterSpacing * MIN_HORIZONTAL_MERGE_DISTANCE_MULTIPLIER;
         double maxVerticalMergeDistance = lineSpacing * MAX_VERTICAL_MERGE_DISTANCE_MULTIPLIER;
 
-        UnionFind<Line> unionFind = new UnionFind<>(new HashSet<>(lines));
+        DisjointSets<Line> sets = new DisjointSets<>(lines);
 
         double meanHeight = calculateMeanHeight(lines);
 
@@ -51,20 +50,20 @@ public class ZoneBuilderService {
                     double scale = Math.min(outerLine.getHeight(), innerLine.getHeight()) / meanHeight;
                     scale = Math.max(MIN_LINE_SIZE_SCALE, Math.min(scale, MAX_LINE_SIZE_SCALE));
 
-                    if (!unionFind.inSameSet(outerLine, innerLine) && outerLine.angularDifference(innerLine) <= ANGLE_TOLERANCE) {
+                    if (!sets.areTogether(outerLine, innerLine) && outerLine.angularDifference(innerLine) <= ANGLE_TOLERANCE) {
 
                         double horizontalDistance = outerLine.horizontalDistance(innerLine) / scale;
                         double verticalDistance = outerLine.verticalDistance(innerLine) / scale;
 
                         if (minHorizontalDistance <= horizontalDistance && verticalDistance <= maxVerticalDistance //
                                 || minHorizontalMergeDistance <= horizontalDistance && verticalDistance <= maxVerticalMergeDistance) {
-                            unionFind.union(outerLine, innerLine);
+                            sets.union(outerLine, innerLine);
                         }
                     }
                 }));
 
         List<Zone> zones = new ArrayList<>();
-        unionFind.getGroups().forEach(group -> {
+        sets.forEach(group -> {
             zones.add(new Zone(new ArrayList<>(group)));
         });
 
@@ -100,7 +99,7 @@ public class ZoneBuilderService {
         double minVerticalDistance = 0;
         double maxVerticalDistance = lineSpacing * MAX_VERTICAL_MERGE_DISTANCE;
 
-        UnionFind<Line> unionFind = new UnionFind<>(new HashSet<>(lines));
+        DisjointSets<Line> sets = new DisjointSets<>(lines);
 
         lines.forEach(outer -> {
 
@@ -111,7 +110,7 @@ public class ZoneBuilderService {
                     double verticalDistance = outer.verticalDistance(inner);
 
                     if (horizontalDistance <= maxHorizontalDistance && minVerticalDistance <= verticalDistance && verticalDistance <= maxVerticalDistance) {
-                        unionFind.union(outer, inner);
+                        sets.union(outer, inner);
                     } else if (minVerticalDistance <= verticalDistance && verticalDistance <= maxVerticalDistance && Math.abs(horizontalDistance - Math.min(outer.getLength(),
                             inner.getLength())) < 0.1) {
                         boolean characterOverlap = false;
@@ -128,7 +127,7 @@ public class ZoneBuilderService {
                             }
                         }
                         if (!characterOverlap && overlappingCount <= 2) {
-                            unionFind.union(outer, inner);
+                            sets.union(outer, inner);
                         }
                     }
                 }
@@ -136,16 +135,15 @@ public class ZoneBuilderService {
         });
 
         List<Line> outputZone = new ArrayList<>();
-        for (Set<Line> group : unionFind.getGroups()) {
-            List<Character> characters = new ArrayList<>();
+        for (Set<Line> group : sets) {
+            List<Character> components = new ArrayList<>();
             for (Line line : group) {
-                characters.addAll(line.getCharacters());
+                components.addAll(line.getCharacters());
             }
-            characters.sort(Comparator.comparingDouble(Character::getX));
+            components.sort(Comparator.comparingDouble(Character::getX));
 
-            outputZone.add(new Line(characters, characterSpacing));
+            outputZone.add(new Line(components, characterSpacing));
         }
-
         return new Zone(outputZone);
     }
 

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

@@ -16,7 +16,6 @@ import java.util.Set;
 import java.util.stream.Collectors;
 
 import com.knecon.fforesight.service.layoutparser.internal.api.data.redaction.LayoutEngine;
-import com.knecon.fforesight.service.layoutparser.internal.api.queue.LayoutParsingType;
 import com.knecon.fforesight.service.layoutparser.processor.model.AbstractPageBlock;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationDocument;
 import com.knecon.fforesight.service.layoutparser.processor.model.ClassificationFooter;
@@ -49,14 +48,14 @@ import lombok.experimental.UtilityClass;
 @UtilityClass
 public class DocumentGraphFactory {
 
-    public Document buildDocumentGraph(LayoutParsingType layoutParsingType, ClassificationDocument document) {
+    public Document buildDocumentGraph(ClassificationDocument document) {
 
         Document documentGraph = new Document();
         Context context = new Context(documentGraph);
 
         document.getPages().forEach(context::buildAndAddPageWithCounter);
         document.getSections().stream().flatMap(section -> section.getImages().stream()).forEach(image -> context.getImages().add(image));
-        addSections(layoutParsingType, document, context);
+        addSections(document, context);
         addHeaderAndFooterToEachPage(document, context);
 
         documentGraph.setNumberOfPages(context.pages.size());
@@ -67,9 +66,9 @@ public class DocumentGraphFactory {
     }
 
 
-    private void addSections(LayoutParsingType layoutParsingType, ClassificationDocument document, Context context) {
+    private void addSections(ClassificationDocument document, Context context) {
 
-        document.getSections().forEach(section -> SectionNodeFactory.addSection(layoutParsingType, null, section.getNonEmptyPageBlocks(), section.getImages(), context));
+        document.getSections().forEach(section -> SectionNodeFactory.addSection(null, section.getNonEmptyPageBlocks(), section.getImages(), context));
     }
 
 
@@ -91,7 +90,6 @@ public class DocumentGraphFactory {
         List<TextPageBlock> textBlocks = new ArrayList<>();
         textBlocks.add(originalTextBlock);
         textBlocks.addAll(textBlocksToMerge);
-
         AtomicTextBlock textBlock = context.textBlockFactory.buildAtomicTextBlock(TextPositionOperations.mergeAndSortTextPositionSequenceByYThenX(textBlocks), node, context, page);
 
         if (node instanceof DuplicatedParagraph duplicatedParagraph) {

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

@@ -4,14 +4,12 @@ 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.Set;
 
-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.graph.nodes.GenericSemanticNode;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.Page;
@@ -26,11 +24,7 @@ import lombok.experimental.UtilityClass;
 @UtilityClass
 public class SectionNodeFactory {
 
-    public void addSection(LayoutParsingType layoutParsingType,
-                           GenericSemanticNode parentNode,
-                           List<AbstractPageBlock> pageBlocks,
-                           List<ClassifiedImage> images,
-                           DocumentGraphFactory.Context context) {
+    public void addSection(GenericSemanticNode parentNode, List<AbstractPageBlock> pageBlocks, List<ClassifiedImage> images, DocumentGraphFactory.Context context) {
 
         if (pageBlocks.isEmpty()) {
             return;
@@ -43,11 +37,11 @@ public class SectionNodeFactory {
 
         section.setTreeId(getTreeId(parentNode, context, section));
 
-        addFirstHeadlineDirectlyToSection(layoutParsingType, pageBlocks, context, section);
+        addFirstHeadlineDirectlyToSection(pageBlocks, context, section);
         if (containsTablesAndTextBlocks(pageBlocks)) {
-            splitPageBlocksIntoSubSections(pageBlocks).forEach(subSectionPageBlocks -> addSection(layoutParsingType, section, subSectionPageBlocks, emptyList(), context));
+            splitPageBlocksIntoSubSections(pageBlocks).forEach(subSectionPageBlocks -> addSection(section, subSectionPageBlocks, emptyList(), context));
         } else {
-            addTablesAndParagraphsAndHeadlinesToSection(layoutParsingType, pageBlocks, context, section);
+            addTablesAndParagraphsAndHeadlinesToSection(pageBlocks, context, section);
         }
 
         images.stream().distinct().forEach(image -> DocumentGraphFactory.addImage(section, image, context));
@@ -64,19 +58,16 @@ public class SectionNodeFactory {
     }
 
 
-    private void addFirstHeadlineDirectlyToSection(LayoutParsingType layoutParsingType, List<AbstractPageBlock> pageBlocks, DocumentGraphFactory.Context context, Section section) {
+    private void addFirstHeadlineDirectlyToSection(List<AbstractPageBlock> pageBlocks, DocumentGraphFactory.Context context, Section section) {
 
         if (pageBlocks.get(0).isHeadline()) {
-            addTablesAndParagraphsAndHeadlinesToSection(layoutParsingType, List.of(pageBlocks.get(0)), context, section);
+            addTablesAndParagraphsAndHeadlinesToSection(List.of(pageBlocks.get(0)), context, section);
             pageBlocks.remove(0);
         }
     }
 
 
-    private void addTablesAndParagraphsAndHeadlinesToSection(LayoutParsingType layoutParsingType,
-                                                             List<AbstractPageBlock> pageBlocks,
-                                                             DocumentGraphFactory.Context context,
-                                                             Section section) {
+    private void addTablesAndParagraphsAndHeadlinesToSection(List<AbstractPageBlock> pageBlocks, DocumentGraphFactory.Context context, Section section) {
 
         Set<AbstractPageBlock> alreadyMerged = new HashSet<>();
         List<AbstractPageBlock> remainingBlocks = new LinkedList<>(pageBlocks);
@@ -89,23 +80,13 @@ public class SectionNodeFactory {
             remainingBlocks.removeAll(alreadyMerged);
 
             if (abstractPageBlock instanceof TextPageBlock) {
-
-                switch (layoutParsingType) {
-                    case CLARIFYND, CLARIFYND_PARAGRAPH_DEBUG -> {
-                        alreadyMerged.add(abstractPageBlock);
-                        remainingBlocks.remove(abstractPageBlock);
-                        DocumentGraphFactory.addParagraphOrHeadline(section, (TextPageBlock) abstractPageBlock, context, new ArrayList<>());
-                    }
-                    default -> {
-                        List<TextPageBlock> textBlocks = findTextBlocksWithSameClassificationAndAlignsY((TextPageBlock) abstractPageBlock, remainingBlocks);
-                        alreadyMerged.addAll(textBlocks);
-                        DocumentGraphFactory.addParagraphOrHeadline(section, (TextPageBlock) abstractPageBlock, context, textBlocks);
-                    }
-                }
+                List<TextPageBlock> textBlocks = findTextBlocksWithSameClassificationAndAlignsY((TextPageBlock) abstractPageBlock, remainingBlocks);
+                alreadyMerged.addAll(textBlocks);
+                DocumentGraphFactory.addParagraphOrHeadline(section, (TextPageBlock) abstractPageBlock, context, textBlocks);
             } else if (abstractPageBlock instanceof TablePageBlock tablePageBlock) {
                 List<TablePageBlock> tablesToMerge = TableMergingUtility.findConsecutiveTablesWithSameColCountAndSameHeaders(tablePageBlock, remainingBlocks);
                 alreadyMerged.addAll(tablesToMerge);
-                TableNodeFactory.addTable(layoutParsingType, section, tablesToMerge, context);
+                TableNodeFactory.addTable(section, tablesToMerge, context);
             } else {
                 throw new RuntimeException(format("Unhandled AbstractPageBlockType %s!", abstractPageBlock.getClass()));
             }

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

@@ -7,17 +7,16 @@ import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 
-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.table.Cell;
+import com.knecon.fforesight.service.layoutparser.processor.model.table.TablePageBlock;
+import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
 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;
-import com.knecon.fforesight.service.layoutparser.processor.model.table.Cell;
-import com.knecon.fforesight.service.layoutparser.processor.model.table.TablePageBlock;
-import com.knecon.fforesight.service.layoutparser.processor.model.text.TextPositionSequence;
 import com.knecon.fforesight.service.layoutparser.processor.utils.TextPositionOperations;
 
 import lombok.experimental.UtilityClass;
@@ -28,7 +27,7 @@ public class TableNodeFactory {
     public final double TABLE_CELL_MERGE_CONTENTS_SIZE_THRESHOLD = 0.05;
 
 
-    public void addTable(LayoutParsingType layoutParsingType, GenericSemanticNode parentNode, List<TablePageBlock> tablesToMerge, DocumentGraphFactory.Context context) {
+    public void addTable(GenericSemanticNode parentNode, List<TablePageBlock> tablesToMerge, DocumentGraphFactory.Context context) {
 
         setPageNumberInCells(tablesToMerge);
         Set<Page> pages = tablesToMerge.stream().map(AbstractPageBlock::getPage).map(context::getPage).collect(Collectors.toSet());
@@ -44,7 +43,7 @@ public class TableNodeFactory {
 
         List<Integer> treeId = context.getDocumentTree().createNewChildEntryAndReturnId(parentNode, table);
         table.setTreeId(treeId);
-        addTableCells(layoutParsingType, mergedRows, table, context);
+        addTableCells(mergedRows, table, context);
 
         ifTableHasNoHeadersSetFirstRowAsHeaders(table);
     }
@@ -89,18 +88,18 @@ public class TableNodeFactory {
     }
 
 
-    private void addTableCells(LayoutParsingType layoutParsingType, List<List<Cell>> rows, Table table, DocumentGraphFactory.Context context) {
+    private void addTableCells(List<List<Cell>> rows, Table table, DocumentGraphFactory.Context context) {
 
         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);
+                addTableCell(rows.get(rowIndex).get(colIndex), rowIndex, colIndex, table, context);
             }
         }
     }
 
 
     @SuppressWarnings("PMD.UnusedPrivateMethod") // PMD actually flags this wrong
-    private void addTableCell(LayoutParsingType layoutParsingType, Cell cell, int rowIndex, int colIndex, Table tableNode, DocumentGraphFactory.Context context) {
+    private void addTableCell(Cell cell, int rowIndex, int colIndex, Table tableNode, DocumentGraphFactory.Context context) {
 
         Page page = context.getPage(cell.getPageNumber());
 
@@ -117,7 +116,7 @@ public class TableNodeFactory {
             textBlock = context.getTextBlockFactory().buildAtomicTextBlock(cell.getTextBlocks().get(0).getSequences(), tableCell, context, page);
             tableCell.setLeafTextBlock(textBlock);
         } else if (firstTextBlockIsHeadline(cell)) {
-            SectionNodeFactory.addSection(layoutParsingType, tableCell, cell.getTextBlocks().stream().map(tb -> (AbstractPageBlock) tb).toList(), emptyList(), context);
+            SectionNodeFactory.addSection(tableCell, cell.getTextBlocks().stream().map(tb -> (AbstractPageBlock) tb).toList(), emptyList(), context);
         } else if (cellAreaIsSmallerThanPageAreaTimesThreshold(cell, page)) {
             List<TextPositionSequence> sequences = TextPositionOperations.mergeAndSortTextPositionSequenceByYThenX(cell.getTextBlocks());
             textBlock = context.getTextBlockFactory().buildAtomicTextBlock(sequences, tableCell, context, page);

layoutparser-service/layoutparser-service-server/src/main/java/com/knecon/fforesight/service/layoutparser/server/queue/MessageHandler.java

@@ -37,7 +37,7 @@ public class MessageHandler {
 
         LayoutParsingRequest layoutParsingRequest = objectMapper.readValue(message.getBody(), LayoutParsingRequest.class);
 
-        if (layoutParsingRequest.layoutParsingType().equals(LayoutParsingType.CLARIFYND) && layoutParsingRequest.researchDocumentStorageId() == null) {
+        if (layoutParsingRequest.layoutParsingType().equals(LayoutParsingType.TAAS) && layoutParsingRequest.researchDocumentStorageId() == null) {
             throw new IllegalArgumentException("ResearchDocumentDataStorageId is null!");
         }
         log.info("Layout parsing request received {}", layoutParsingRequest.identifier());

layoutparser-service/layoutparser-service-server/src/test/java/com/knecon/fforesight/service/layoutparser/server/BdrJsonBuildTest.java

@@ -48,13 +48,12 @@ public class BdrJsonBuildTest extends AbstractTest {
     @SneakyThrows
     protected Document buildGraph(File file) {
 
-        return DocumentGraphFactory.buildDocumentGraph(LayoutParsingType.CLARIFYND,
-                layoutParsingPipeline.parseLayout(LayoutParsingType.CLARIFYND,
-                        file,
-                        new ImageServiceResponse(),
-                        new TableServiceResponse(),
-                        new VisualLayoutParsingResponse(),
-                        file.toString()));
+        return DocumentGraphFactory.buildDocumentGraph(layoutParsingPipeline.parseLayout(LayoutParsingType.TAAS,
+                file,
+                new ImageServiceResponse(),
+                new TableServiceResponse(),
+                new VisualLayoutParsingResponse(),
+                file.toString()));
     }
 
 

layoutparser-service/layoutparser-service-server/src/test/java/com/knecon/fforesight/service/layoutparser/server/HeadlinesGoldStandardIntegrationTest.java

@@ -95,13 +95,12 @@ public class HeadlinesGoldStandardIntegrationTest {
         goldStandardLog.getRedactionLogEntry().removeIf(r -> !r.isRedacted() || r.getChanges().get(r.getChanges().size() - 1).getType().equals(ChangeType.REMOVED));
         goldStandardLog.getRedactionLogEntry().forEach(e -> goldStandardHeadlines.add(new Headline(e.getPositions().get(0).getPage(), e.getValue())));
 
-        Document documentGraph = DocumentGraphFactory.buildDocumentGraph(LayoutParsingType.REDACT_MANAGER_OLD,
-                layoutParsingPipeline.parseLayout(LayoutParsingType.REDACT_MANAGER_OLD,
-                        pdfFileResource.getFile(),
-                        new ImageServiceResponse(),
-                        new TableServiceResponse(),
-                        new VisualLayoutParsingResponse(),
-                        filePath));
+        Document documentGraph = DocumentGraphFactory.buildDocumentGraph(layoutParsingPipeline.parseLayout(LayoutParsingType.REDACT_MANAGER_OLD,
+                pdfFileResource.getFile(),
+                new ImageServiceResponse(),
+                new TableServiceResponse(),
+                new VisualLayoutParsingResponse(),
+                filePath));
 
         var foundHeadlines = documentGraph.streamAllSubNodes()
                 .map(SemanticNode::getHeadline)

layoutparser-service/layoutparser-service-server/src/test/java/com/knecon/fforesight/service/layoutparser/server/graph/DocumentGraphJsonWritingTest.java

@@ -55,13 +55,12 @@ public class DocumentGraphJsonWritingTest extends BuildDocumentTest {
     @SneakyThrows
     private void writeJsons(Path filename) {
 
-        Document documentGraph = DocumentGraphFactory.buildDocumentGraph(LayoutParsingType.REDACT_MANAGER_OLD,
-                layoutParsingPipeline.parseLayout(LayoutParsingType.REDACT_MANAGER_OLD,
-                        filename.toFile(),
-                        new ImageServiceResponse(),
-                        new TableServiceResponse(),
-                        new VisualLayoutParsingResponse(),
-                        filename.toFile().toString()));
+        Document documentGraph = DocumentGraphFactory.buildDocumentGraph(layoutParsingPipeline.parseLayout(LayoutParsingType.REDACT_MANAGER_OLD,
+                filename.toFile(),
+                new ImageServiceResponse(),
+                new TableServiceResponse(),
+                new VisualLayoutParsingResponse(),
+                filename.toFile().toString()));
 
         DocumentData documentData = DocumentDataMapper.toDocumentData(documentGraph);
         ObjectMapper mapper = ObjectMapperFactory.create();

layoutparser-service/layoutparser-service-server/src/test/java/com/knecon/fforesight/service/layoutparser/server/graph/ViewerDocumentTest.java

@@ -26,7 +26,7 @@ public class ViewerDocumentTest extends BuildDocumentTest {
     @SneakyThrows
     public void testViewerDocument() {
 
-        String fileName = "files/S-Metolachlor_RAR_01_Volume_1_2018-09-06.pdf";
+        String fileName = "files/new/270 rotated text on non rotated pages.pdf";
         String tmpFileName = "/tmp/" + Path.of(fileName).getFileName() + "_VIEWER.pdf";
 
         var documentFile = new ClassPathResource(fileName).getFile();
@@ -61,7 +61,7 @@ public class ViewerDocumentTest extends BuildDocumentTest {
                 Path.of(fileName).getFileName().toFile().toString());
         ViewerDocumentService viewerDocumentService = new ViewerDocumentService(null);
         LayoutGridService layoutGridService = new LayoutGridService(viewerDocumentService);
-        Document document = DocumentGraphFactory.buildDocumentGraph(LayoutParsingType.DOCUMINE, classificationDocument);
+        Document document = DocumentGraphFactory.buildDocumentGraph(classificationDocument);
 
         layoutGridService.addLayoutGrid(documentFile, document, new File(tmpFileName), true);
     }

layoutparser-service/layoutparser-service-server/src/test/java/com/knecon/fforesight/service/layoutparser/server/services/BodyTextFrameServiceTest.java

@@ -21,7 +21,7 @@ class BodyTextFrameServiceTest extends BuildDocumentTest {
 
         String filename = "files/211.pdf";
         String outputFilename = "/tmp/" + Path.of(filename).getFileName() + "_MAINBODY.pdf";
-        ClassificationDocument document = parseLayout(filename, LayoutParsingType.CLARIFYND);
+        ClassificationDocument document = parseLayout(filename, LayoutParsingType.TAAS);
         PdfDraw.drawRectanglesPerPage(filename,
                 document.getPages().stream().map(page -> List.of(RectangleTransformations.toRectangle2D(page.getBodyTextFrame()))).toList(),
                 outputFilename);

layoutparser-service/layoutparser-service-server/src/test/java/com/knecon/fforesight/service/layoutparser/server/services/RulingCleaningServiceTest.java

@@ -99,20 +99,18 @@ public class RulingCleaningServiceTest extends BuildDocumentTest {
     @SneakyThrows
     private void writeJsons(Path filename) {
 
-        Document documentGraphBefore = DocumentGraphFactory.buildDocumentGraph(LayoutParsingType.REDACT_MANAGER_OLD,
-                layoutParsingPipeline.parseLayout(LayoutParsingType.REDACT_MANAGER_OLD,
-                        filename.toFile(),
-                        new ImageServiceResponse(),
-                        new TableServiceResponse(),
-                        new VisualLayoutParsingResponse(),
-                        filename.toFile().toString()));
-        Document documentGraphAfter = DocumentGraphFactory.buildDocumentGraph(LayoutParsingType.REDACT_MANAGER_OLD,
-                layoutParsingPipeline.parseLayout(LayoutParsingType.REDACT_MANAGER_OLD,
-                        filename.toFile(),
-                        new ImageServiceResponse(),
-                        new TableServiceResponse(),
-                        new VisualLayoutParsingResponse(),
-                        filename.toFile().toString()));
+        Document documentGraphBefore = DocumentGraphFactory.buildDocumentGraph(layoutParsingPipeline.parseLayout(LayoutParsingType.REDACT_MANAGER_OLD,
+                filename.toFile(),
+                new ImageServiceResponse(),
+                new TableServiceResponse(),
+                new VisualLayoutParsingResponse(),
+                filename.toFile().toString()));
+        Document documentGraphAfter = DocumentGraphFactory.buildDocumentGraph(layoutParsingPipeline.parseLayout(LayoutParsingType.REDACT_MANAGER_OLD,
+                filename.toFile(),
+                new ImageServiceResponse(),
+                new TableServiceResponse(),
+                new VisualLayoutParsingResponse(),
+                filename.toFile().toString()));
         DocumentData documentDataBefore = DocumentDataMapper.toDocumentData(documentGraphBefore);
         DocumentData documentDataAfter = DocumentDataMapper.toDocumentData(documentGraphAfter);
         if (!compareStructures(documentDataBefore.getDocumentStructure(), documentDataAfter.getDocumentStructure())) {

layoutparser-service/layoutparser-service-server/src/test/java/com/knecon/fforesight/service/layoutparser/server/utils/BuildDocumentTest.java

@@ -51,7 +51,7 @@ public abstract class BuildDocumentTest extends AbstractTest {
             prepareStorage(filename);
         }
 
-        return DocumentGraphFactory.buildDocumentGraph(layoutParsingType, parseLayout(filename, layoutParsingType));
+        return DocumentGraphFactory.buildDocumentGraph(parseLayout(filename, layoutParsingType));
     }
 
 }

layoutparser-service/viewer-doc-processor/build.gradle

@@ -1,6 +1,6 @@
 plugins {
     id("com.knecon.fforesight.java-conventions")
-    id("io.freefair.lombok") version "8.4"
+    id("io.freefair.lombok") version "8.2.2"
 }
 
 description = "Library for adding/removing layers in the viewer document"