Clari-002: render document data as markdown

Merge branch 'RED-9496-shutdown-fp' into 'main'
2024-07-09 11:03:51 +02:00 · 2024-07-09 11:03:45 +02:00 · 2024-07-04 14:26:00 +02:00 · 2024-07-04 14:21:20 +03:00 · 2024-07-02 11:37:22 +02:00 · 2024-07-01 13:56:16 +02:00
36 changed files with 1410 additions and 254 deletions
@@ -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.")
@@ -148,6 +148,8 @@ public class LayoutParsingPipeline {
                                                                    visualLayoutParsingResponse,
                                                                    layoutParsingRequest.identifier());

+        log.info("Building document graph for {}", layoutParsingRequest.identifier());
+
        Document documentGraph = observeBuildDocumentGraph(settings.getLayoutParsingTypeOverride() == null //
                                                                   ? layoutParsingRequest.layoutParsingType() : settings.getLayoutParsingTypeOverride(), classificationDocument);

@@ -166,7 +168,7 @@ public class LayoutParsingPipeline {
        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);
@@ -257,7 +259,7 @@ public class LayoutParsingPipeline {
        OutlineObject lastProcessedOutlineObject = null;

        // parsing the structure elements could be useful as well
-        if(layoutParsingType != LayoutParsingType.REDACT_MANAGER_OLD && layoutParsingType != LayoutParsingType.DOCUMINE_OLD) {
+        if (layoutParsingType != LayoutParsingType.REDACT_MANAGER_OLD && layoutParsingType != LayoutParsingType.DOCUMINE_OLD) {
            classificationDocument.setOutlineObjectTree(outlineExtractorService.getOutlineObjectTree(originDocument));
        }

@@ -305,37 +307,23 @@ public class LayoutParsingPipeline {

            TextRulingsClassifier.classifyUnderlinedAndStrikethroughText(words, cleanRulings);

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

-                                                                              false);
+                                                                                    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());
                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.getVisualizations(), layoutParsingType);
+                case CLARIFYND, CLARIFYND_PARAGRAPH_DEBUG ->
+                        docstrumBlockificationService.blockify(words, cleanRulings, false, classificationDocument.getVisualizations(), layoutParsingType);
            };

            classificationPage.setCleanRulings(cleanRulings);
@@ -345,7 +333,7 @@ public class LayoutParsingPipeline {
            classificationPage.setPageWidth(cropbox.getWidth());
            classificationPage.setPageHeight(cropbox.getHeight());

-            if(layoutParsingType != LayoutParsingType.REDACT_MANAGER_OLD && layoutParsingType != LayoutParsingType.DOCUMINE_OLD) {
+            if (layoutParsingType != LayoutParsingType.REDACT_MANAGER_OLD && layoutParsingType != LayoutParsingType.DOCUMINE_OLD) {
                List<OutlineObject> outlineObjects = classificationDocument.getOutlineObjectTree().getOutlineObjectsPerPage().getOrDefault(pageNumber - 1, new ArrayList<>());

                OutlineObject notFoundOutlineObject = null;
@@ -394,8 +382,8 @@ public class LayoutParsingPipeline {
        }
        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);
        }
@@ -5,6 +5,9 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;

+import com.google.common.base.Strings;
+import com.knecon.fforesight.service.viewerdoc.service.IViewerDocumentService;
+import com.knecon.fforesight.service.viewerdoc.service.pdftron.PDFTronViewerDocumentService;
 import com.knecon.fforesight.service.viewerdoc.service.ViewerDocumentService;

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

-
    @Bean
    @Autowired
-    public ViewerDocumentService viewerDocumentService(ObservationRegistry registry) {
+    public IViewerDocumentService viewerDocumentService(ObservationRegistry registry, LayoutparserSettings settings) {
+
+        if (!Strings.isNullOrEmpty(settings.getPdftronLicense())) {
+            return new PDFTronViewerDocumentService(registry);
+        } else {
+            return new ViewerDocumentService(registry);
+        }

-        return new ViewerDocumentService(registry);
    }

 }
@@ -17,4 +17,5 @@ public class LayoutparserSettings {

    boolean debug;
    LayoutParsingType layoutParsingTypeOverride;
+    String pdftronLicense;
 }
@@ -0,0 +1,229 @@
+package com.knecon.fforesight.service.layoutparser.processor.markdown;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.stream.Stream;
+
+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.node.Document;
+import org.commonmark.node.Emphasis;
+import org.commonmark.node.Heading;
+import org.commonmark.node.Node;
+import org.commonmark.node.StrongEmphasis;
+import org.commonmark.node.Text;
+
+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.Paragraph;
+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 lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class DocumentDataParser {
+
+    public Document parse(Stream<SemanticNode> semanticNodes) {
+
+        Document document = new Document();
+        semanticNodes.map(DocumentDataParser::parseNode)
+                .filter(Objects::nonNull)
+                .forEach(document::appendChild);
+        return document;
+    }
+
+
+    private Node parseNode(SemanticNode semanticNode) {
+
+        return switch (semanticNode.getType()) {
+            case HEADLINE -> parseHeadline((Headline) semanticNode);
+            case PARAGRAPH -> parseParagraph((Paragraph) semanticNode);
+            case TABLE -> parseTable((Table) semanticNode);
+            default -> null;
+        };
+    }
+
+
+    private TableBlock parseTable(Table table) {
+
+        TableBlock tableNode = new TableBlock();
+        TableHead head = new TableHead();
+        TableRow tableRow = createTableRow(table, 0);
+        head.appendChild(tableRow);
+        int row = 1;
+        for (; row < table.getNumberOfRows() && table.streamRow(row)
+                .allMatch(com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.TableCell::isHeader); row++) {
+            head.appendChild(createTableRow(table, row));
+        }
+        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(DocumentDataParser::createTableCell)
+                .forEach(tableRow::appendChild);
+        return tableRow;
+    }
+
+
+    private Node createTableCell(com.knecon.fforesight.service.layoutparser.processor.model.graph.nodes.TableCell tc) {
+
+        var cell = new TableCell();
+        if (tc.isLeaf()) {
+            parseTextBlock(tc.getTextBlock()).forEach(cell::appendChild);
+        } else {
+            tc.streamChildren()
+                    .map(DocumentDataParser::parseNode)
+                    .filter(Objects::nonNull)
+                    .forEach(cell::appendChild);
+        }
+        return cell;
+    }
+
+
+    private org.commonmark.node.Paragraph parseParagraph(Paragraph paragraph) {
+
+        org.commonmark.node.Paragraph heading = new org.commonmark.node.Paragraph();
+        parseTextBlock(paragraph.getTextBlock()).forEach(heading::appendChild);
+        return heading;
+    }
+
+
+    private Heading parseHeadline(Headline headline) {
+
+        Heading heading = new Heading();
+        parseTextBlock(headline.getTextBlock()).forEach(heading::appendChild);
+        return heading;
+
+    }
+
+
+    private List<Node> parseTextBlock(TextBlock textBlock) {
+
+        List<Node> result = new ArrayList<>();
+        List<TextRangeWithTextType> textRanges = mergeTextStyles(textBlock);
+        for (TextRangeWithTextType textRange : textRanges) {
+            switch (textRange.fontStyle()) {
+                case REGULAR -> result.add(new Text(textBlock.subSequenceWithLineBreaks(textRange.textRange())));
+                case BOLD -> {
+                    StrongEmphasis boldBlock = new StrongEmphasis();
+                    boldBlock.appendChild(new Text(textBlock.subSequenceWithLineBreaks(textRange.textRange())));
+                    result.add(boldBlock);
+                }
+                case ITALIC -> {
+                    Emphasis italicBlock = new Emphasis();
+                    italicBlock.appendChild(new Text(textBlock.subSequenceWithLineBreaks(textRange.textRange())));
+                    result.add(italicBlock);
+                }
+                case BOLD_ITALIC -> {
+                    Emphasis italicBlock = new Emphasis();
+
+                    StrongEmphasis boldBlock = new StrongEmphasis();
+                    boldBlock.appendChild(new Text(textBlock.subSequenceWithLineBreaks(textRange.textRange())));
+
+                    italicBlock.appendChild(boldBlock);
+                    result.add(italicBlock);
+                }
+            }
+        }
+        return result;
+    }
+
+
+    private List<TextRangeWithTextType> mergeTextStyles(TextBlock textBlock) {
+
+        List<TextRangeWithTextType> result = new ArrayList<>();
+
+        TreeMap<Integer, Set<FontStyle>> styleChanges = new TreeMap<>();
+
+        for (TextRange bold : textBlock.getBoldTextBoundaries()) {
+            styleChanges.computeIfAbsent(bold.start(), k -> new HashSet<>()).add(FontStyle.BOLD);
+            styleChanges.computeIfAbsent(bold.end(), k -> new HashSet<>()).add(FontStyle.REGULAR);
+        }
+
+        for (TextRange italic : textBlock.getItalicTextBoundaries()) {
+            styleChanges.computeIfAbsent(italic.start(), k -> new HashSet<>()).add(FontStyle.ITALIC);
+            styleChanges.computeIfAbsent(italic.end(), k -> new HashSet<>()).add(FontStyle.REGULAR);
+        }
+
+        if (styleChanges.isEmpty()) {
+            result.add(new TextRangeWithTextType(new TextRange(0, textBlock.length()), FontStyle.REGULAR));
+            return result;
+        }
+
+        int start = 0;
+        Set<FontStyle> currentStyles = new HashSet<>();
+        currentStyles.add(FontStyle.REGULAR);
+
+        for (Map.Entry<Integer, Set<FontStyle>> entry : styleChanges.entrySet()) {
+            int point = entry.getKey();
+            Set<FontStyle> changes = entry.getValue();
+
+            if (point > start) {
+                FontStyle style = determineFontStyle(currentStyles);
+                result.add(new TextRangeWithTextType(new TextRange(start, point), style));
+            }
+
+            currentStyles.removeAll(changes);
+            currentStyles.addAll(changes);
+            if (currentStyles.isEmpty()) {
+                currentStyles.add(FontStyle.REGULAR);
+            }
+
+            start = point;
+        }
+
+        if (start < textBlock.length()) {
+            FontStyle style = determineFontStyle(currentStyles);
+            result.add(new TextRangeWithTextType(new TextRange(start, textBlock.length()), 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;
+        }
+    }
+
+
+    enum FontStyle {
+        REGULAR,
+        BOLD,
+        ITALIC,
+        BOLD_ITALIC;
+    }
+
+    record TextRangeWithTextType(TextRange textRange, FontStyle fontStyle) {
+
+    }
+
+}
@@ -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);
    }


@@ -83,18 +83,18 @@ public class Boundary implements Comparable<Boundary> {
    }


-    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));
        }
-        List<Boundary> splitBoundaries = new LinkedList<>();
+        List<TextRange> splitBoundaries = new LinkedList<>();
        int previousIndex = start;
        for (int splitIndex : splitIndices) {

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

@@ -114,11 +114,11 @@ public class Boundary implements Comparable<Boundary> {
        return IntStream.range(start, end);
    }

-    public static Boundary merge(Collection<Boundary> boundaries) {
+    public static TextRange merge(Collection<TextRange> 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);
+        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 +130,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;
@@ -32,7 +32,7 @@ public class RedactionEntity {

    // initial values
    @EqualsAndHashCode.Include
-    final Boundary boundary;
+    final TextRange textRange;
    @EqualsAndHashCode.Include
    final String type;
    @EqualsAndHashCode.Include
@@ -66,9 +66,9 @@ public class RedactionEntity {
    SemanticNode deepestFullyContainingNode;


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

-        return RedactionEntity.builder().type(type).entityType(entityType).boundary(boundary).engines(new HashSet<>()).references(new HashSet<>()).build();
+        return RedactionEntity.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()
@@ -157,19 +157,19 @@ public class RedactionEntity {

    public boolean containedBy(RedactionEntity redactionEntity) {

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


    public boolean contains(RedactionEntity redactionEntity) {

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


    public boolean intersects(RedactionEntity redactionEntity) {

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


@@ -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());
@@ -14,7 +14,7 @@ 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.TextRange;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.DocumentTree;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.entity.EntityType;
 import com.knecon.fforesight.service.layoutparser.processor.model.graph.entity.RedactionEntity;
@@ -77,12 +77,12 @@ 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);
    }


@@ -328,13 +328,13 @@ public interface SemanticNode {
    default void addThisToEntityIfIntersects(RedactionEntity redactionEntity) {

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

            redactionEntity.addIntersectingNode(this);
-            streamChildren().filter(semanticNode -> semanticNode.getBoundary().intersects(redactionEntity.getBoundary()))
+            streamChildren().filter(semanticNode -> semanticNode.getBoundary().intersects(redactionEntity.getTextRange()))
                    .forEach(node -> node.addThisToEntityIfIntersects(redactionEntity));
        }
    }
@@ -406,9 +406,9 @@ public interface SemanticNode {
     *
     * @return Boundary of this Node's TextBlock
     */
-    default Boundary getBoundary() {
+    default TextRange getBoundary() {

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


@@ -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 + stringTextRange.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)
@@ -118,7 +154,7 @@ public class AtomicTextBlock implements TextBlock {
                .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())
@@ -140,11 +176,11 @@ 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());
+            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 +195,9 @@ public class AtomicTextBlock implements TextBlock {
    public int getNextLinebreak(int fromIndex) {

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


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

        return lineBreaks.stream()//
-                .filter(linebreak -> linebreak <= fromIndex - boundary.start())//
+                .filter(linebreak -> linebreak <= fromIndex - textRange.start())//
                .reduce((a, b) -> b)//
-                .orElse(0) + boundary.start();
+                .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 +253,9 @@ public class AtomicTextBlock implements TextBlock {
    }


-    private List<Integer> getAllLineBreaksInBoundary(Boundary boundary) {
+    private 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().contains(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().contains(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());
    }

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


@@ -9,7 +9,7 @@ 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;
@@ -118,23 +118,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;
    }
@@ -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();
    }
@@ -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())
@@ -35,7 +35,7 @@ import com.knecon.fforesight.service.viewerdoc.model.LayoutGrid;
 import com.knecon.fforesight.service.viewerdoc.model.PlacedText;
 import com.knecon.fforesight.service.viewerdoc.model.Standard14EmbeddableFont;
 import com.knecon.fforesight.service.viewerdoc.model.Visualizations;
-import com.knecon.fforesight.service.viewerdoc.service.ViewerDocumentService;
+import com.knecon.fforesight.service.viewerdoc.service.IViewerDocumentService;

 import io.micrometer.observation.annotation.Observed;
 import lombok.AccessLevel;
@@ -48,7 +48,7 @@ import lombok.experimental.FieldDefaults;
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
 public class LayoutGridService {

-    ViewerDocumentService viewerDocumentService;
+    IViewerDocumentService viewerDocumentService;

    static float FONT_SIZE = 10f;
    static float LINE_WIDTH = 1f;
@@ -32,11 +32,13 @@ dependencies {
    implementation("com.iqser.red.commons:storage-commons:2.45.0")
    implementation("com.knecon.fforesight:tenant-commons:0.21.0")
    implementation("com.knecon.fforesight:tracing-commons:0.5.0")
+    implementation("com.knecon.fforesight:lifecycle-commons:0.6.0")
    implementation("org.springframework.boot:spring-boot-starter-actuator:${springBootStarterVersion}")
    implementation("org.springframework.boot:spring-boot-starter-amqp:${springBootStarterVersion}")
    implementation("com.amazonaws:aws-java-sdk-s3:1.12.536")
    implementation("org.springframework.cloud:spring-cloud-starter-openfeign:4.0.4")
    implementation("net.logstash.logback:logstash-logback-encoder:7.4")
+    implementation("com.pdftron:PDFNet:10.5.0")

    // for integration testing only
    testImplementation(project(":viewer-doc-processor"))
@@ -6,19 +6,22 @@ import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
 import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.context.annotation.Import;

 import com.amazonaws.services.s3.model.metrics.MetricsConfiguration;
 import com.iqser.red.storage.commons.StorageAutoConfiguration;
+import com.knecon.fforesight.lifecyclecommons.LifecycleAutoconfiguration;
 import com.knecon.fforesight.service.layoutparser.processor.LayoutParsingServiceProcessorConfiguration;
 import com.knecon.fforesight.tenantcommons.MultiTenancyAutoConfiguration;

 import io.micrometer.observation.ObservationRegistry;
 import io.micrometer.observation.aop.ObservedAspect;

-@ImportAutoConfiguration({MultiTenancyAutoConfiguration.class})
+@ImportAutoConfiguration({MultiTenancyAutoConfiguration.class, LifecycleAutoconfiguration.class})
@Import({MetricsConfiguration.class, StorageAutoConfiguration.class, LayoutParsingServiceProcessorConfiguration.class})
@SpringBootApplication(exclude = {SecurityAutoConfiguration.class, ManagementWebSecurityAutoConfiguration.class})
+@EnableAspectJAutoProxy
 public class Application {

    public static void main(String[] args) {
@@ -0,0 +1,45 @@
+package com.knecon.fforesight.service.layoutparser.server;
+
+import org.springframework.stereotype.Component;
+
+import com.google.common.base.Strings;
+import com.knecon.fforesight.service.layoutparser.processor.LayoutparserSettings;
+import com.pdftron.pdf.PDFNet;
+
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.PreDestroy;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class PDFNetInitializer {
+
+    private final LayoutparserSettings settings;
+
+
+    @SneakyThrows
+    @PostConstruct
+    // Do not change back to application runner, if it is application runner it takes messages from the queue before PDFNet is initialized, that leads to UnsatisfiedLinkError.
+    public void init() {
+
+        if (Strings.isNullOrEmpty(settings.getPdftronLicense())) {
+            return;
+        }
+        log.info("Initializing Native Libraries");
+        log.info("Setting pdftron license: {}", settings.getPdftronLicense());
+        PDFNet.setTempPath("/tmp/pdftron");
+        PDFNet.initialize(settings.getPdftronLicense());
+
+    }
+
+
+    @PreDestroy
+    public void terminate() {
+
+        PDFNet.terminate();
+    }
+
+}
@@ -15,6 +15,9 @@ project.version: 1.0-SNAPSHOT
 server:
  port: 8080

+lifecycle:
+  base-package: com.knecon.fforesight.service.layoutparser
+
 spring:
  application:
    name: layoutparser-service
@@ -1,71 +0,0 @@
-package com.knecon.fforesight.service.layoutparser.server.graph;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import java.util.Collections;
-import java.util.List;
-
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import com.knecon.fforesight.service.layoutparser.processor.model.graph.Boundary;
-
-class BoundaryTest {
-
-    Boundary startBoundary;
-
-
-    @BeforeEach
-    void setUp() {
-
-        startBoundary = new Boundary(10, 100);
-    }
-
-
-    @Test
-    void testContains() {
-
-        assertTrue(startBoundary.contains(11));
-        assertTrue(startBoundary.contains(50));
-        assertFalse(startBoundary.contains(9));
-        assertFalse(startBoundary.contains(100));
-        assertFalse(startBoundary.contains(150));
-        assertFalse(startBoundary.contains(-123));
-        assertTrue(startBoundary.contains(new Boundary(11, 99)));
-        assertTrue(startBoundary.contains(new Boundary(10, 100)));
-        assertTrue(startBoundary.contains(new Boundary(11, 11)));
-        assertFalse(startBoundary.contains(9, 100));
-        assertTrue(startBoundary.contains(100, 100));
-        assertFalse(startBoundary.contains(100, 101));
-        assertFalse(startBoundary.contains(150, 151));
-    }
-
-
-    @Test
-    void testIntersects() {
-
-        assertTrue(startBoundary.intersects(new Boundary(1, 11)));
-        assertTrue(startBoundary.intersects(new Boundary(11, 12)));
-        assertTrue(startBoundary.intersects(new Boundary(11, 100)));
-        assertFalse(startBoundary.intersects(new Boundary(100, 101)));
-        assertTrue(startBoundary.intersects(new Boundary(99, 101)));
-    }
-
-
-    @Test
-    void testSplit() {
-
-        assertEquals(4, startBoundary.split(List.of(12, 40, 90)).size());
-        assertEquals(List.of(new Boundary(10, 12), new Boundary(12, 40), new Boundary(40, 90), new Boundary(90, 100)), startBoundary.split(List.of(12, 40, 90)));
-        assertEquals(List.of(new Boundary(10, 40), new Boundary(40, 100)), startBoundary.split(List.of(40)));
-        assertEquals(1, startBoundary.split(Collections.emptyList()).size());
-        assertEquals(1, startBoundary.split(List.of(startBoundary.start())).size());
-        assertThrows(IndexOutOfBoundsException.class, () -> startBoundary.split(Collections.singletonList(0)));
-        assertThrows(IndexOutOfBoundsException.class, () -> startBoundary.split(Collections.singletonList(100)));
-        assertThrows(IndexOutOfBoundsException.class, () -> startBoundary.split(List.of(12, 40, 100)));
-    }
-
-}
@@ -0,0 +1,71 @@
+package com.knecon.fforesight.service.layoutparser.server.graph;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import com.knecon.fforesight.service.layoutparser.processor.model.graph.TextRange;
+
+class TextRangeTest {
+
+    TextRange startTextRange;
+
+
+    @BeforeEach
+    void setUp() {
+
+        startTextRange = new TextRange(10, 100);
+    }
+
+
+    @Test
+    void testContains() {
+
+        assertTrue(startTextRange.contains(11));
+        assertTrue(startTextRange.contains(50));
+        assertFalse(startTextRange.contains(9));
+        assertFalse(startTextRange.contains(100));
+        assertFalse(startTextRange.contains(150));
+        assertFalse(startTextRange.contains(-123));
+        assertTrue(startTextRange.contains(new TextRange(11, 99)));
+        assertTrue(startTextRange.contains(new TextRange(10, 100)));
+        assertTrue(startTextRange.contains(new TextRange(11, 11)));
+        assertFalse(startTextRange.contains(9, 100));
+        assertTrue(startTextRange.contains(100, 100));
+        assertFalse(startTextRange.contains(100, 101));
+        assertFalse(startTextRange.contains(150, 151));
+    }
+
+
+    @Test
+    void testIntersects() {
+
+        assertTrue(startTextRange.intersects(new TextRange(1, 11)));
+        assertTrue(startTextRange.intersects(new TextRange(11, 12)));
+        assertTrue(startTextRange.intersects(new TextRange(11, 100)));
+        assertFalse(startTextRange.intersects(new TextRange(100, 101)));
+        assertTrue(startTextRange.intersects(new TextRange(99, 101)));
+    }
+
+
+    @Test
+    void testSplit() {
+
+        assertEquals(4, startTextRange.split(List.of(12, 40, 90)).size());
+        assertEquals(List.of(new TextRange(10, 12), new TextRange(12, 40), new TextRange(40, 90), new TextRange(90, 100)), startTextRange.split(List.of(12, 40, 90)));
+        assertEquals(List.of(new TextRange(10, 40), new TextRange(40, 100)), startTextRange.split(List.of(40)));
+        assertEquals(1, startTextRange.split(Collections.emptyList()).size());
+        assertEquals(1, startTextRange.split(List.of(startTextRange.start())).size());
+        assertThrows(IndexOutOfBoundsException.class, () -> startTextRange.split(Collections.singletonList(0)));
+        assertThrows(IndexOutOfBoundsException.class, () -> startTextRange.split(Collections.singletonList(100)));
+        assertThrows(IndexOutOfBoundsException.class, () -> startTextRange.split(List.of(12, 40, 100)));
+    }
+
+}
@@ -190,7 +190,8 @@ public class PdfSegmentationServiceTest extends AbstractTest {
                                                                        imageMetadata.getGeometry().getHeight()),
                                                 ImageType.valueOf(imageMetadata.getClassification().getLabel().toUpperCase(Locale.ROOT)),
                                                 imageMetadata.isAlpha(),
-                                                 imageMetadata.getPosition().getPageNumber(), "")));
+                                                 imageMetadata.getPosition().getPageNumber(),
+                                                 "")));

        System.out.println("object");
    }
@@ -105,7 +105,7 @@ public abstract class AbstractTest {
    }


-    protected LayoutParsingRequest buildDefaultLayoutParsingRequest(String fileName, LayoutParsingType layoutParsingType, boolean debug) {
+    public static LayoutParsingRequest buildDefaultLayoutParsingRequest(String fileName, LayoutParsingType layoutParsingType, boolean debug) {

        var identifier = debug ? Map.of("fileId", fileName, "debug", "true") : Map.of("fileId", fileName);
        return LayoutParsingRequest.builder()
@@ -12,6 +12,7 @@ dependencies {
    implementation("org.apache.pdfbox:pdfbox-tools:${pdfBoxVersion}")
    implementation("org.slf4j:slf4j-api:1.7.25")
    implementation("com.knecon.fforesight:tracing-commons:0.5.0")
+    implementation("com.pdftron:PDFNet:10.5.0")

    testImplementation("org.apache.logging.log4j:log4j-slf4j-impl:2.22.1")
    testImplementation("org.junit.jupiter:junit-jupiter")
@@ -3,8 +3,13 @@ package com.knecon.fforesight.service.viewerdoc.model;
 import org.apache.pdfbox.pdmodel.PDDocument;
 import org.apache.pdfbox.pdmodel.font.PDFont;

+import com.pdftron.pdf.Font;
+import com.pdftron.pdf.PDFDoc;
+
 public interface EmbeddableFont {

    PDFont embed(PDDocument document);

+    Font embed(PDFDoc doc);
+
 }
@@ -1,10 +1,15 @@
 package com.knecon.fforesight.service.viewerdoc.model;

+import java.util.Objects;
+
 import org.apache.pdfbox.pdmodel.PDDocument;
 import org.apache.pdfbox.pdmodel.font.PDFont;
 import org.apache.pdfbox.pdmodel.font.PDType1Font;
 import org.apache.pdfbox.pdmodel.font.Standard14Fonts;

+import com.pdftron.pdf.Font;
+import com.pdftron.pdf.PDFDoc;
+
 import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;

@@ -13,10 +18,11 @@ public class Standard14EmbeddableFont implements EmbeddableFont {

    private final PDType1Font font;

+    private final int pdfTronIdentifier;

    public static Standard14EmbeddableFont helvetica() {

-        return new Standard14EmbeddableFont(new PDType1Font(Standard14Fonts.FontName.HELVETICA));
+        return new Standard14EmbeddableFont(new PDType1Font(Standard14Fonts.FontName.HELVETICA), Font.e_helvetica);
    }


@@ -34,4 +40,12 @@ public class Standard14EmbeddableFont implements EmbeddableFont {
        return font;
    }

+
+    @Override
+    @SneakyThrows
+    public Font embed(PDFDoc document) {
+
+        return Font.create(document, pdfTronIdentifier);
+    }
+
 }
@@ -23,4 +23,10 @@ public class VisualizationsOnPage {
    @Builder.Default
    List<FilledRectangle> filledRectangles = new LinkedList<>();

+
+    public boolean isEmpty() {
+
+        return placedTexts.isEmpty() && coloredLines.isEmpty() && coloredRectangles.isEmpty() && filledRectangles.isEmpty();
+    }
+
 }
@@ -0,0 +1,27 @@
+package com.knecon.fforesight.service.viewerdoc.service;
+
+import java.io.File;
+import java.util.List;
+
+import com.knecon.fforesight.service.viewerdoc.ContentStreams;
+import com.knecon.fforesight.service.viewerdoc.model.Visualizations;
+
+import io.micrometer.observation.ObservationRegistry;
+
+public interface IViewerDocumentService {
+
+    void addVisualizationsOnPage(File originFile, File destinationFile, List<Visualizations> visualizations);
+
+    default void enrichObservation(ObservationRegistry registry, int numberOfPages, List<ContentStreams.Identifier> layers) {
+
+        if (registry == null || registry.getCurrentObservation() == null || registry.isNoop()) {
+            return;
+        }
+        registry.getCurrentObservation().highCardinalityKeyValue("numberOfPages", String.valueOf(numberOfPages));
+        for (int i = 0; i < layers.size(); i++) {
+            ContentStreams.Identifier layer = layers.get(i);
+
+            registry.getCurrentObservation().highCardinalityKeyValue("layer_" + i, String.valueOf(layer.name()));
+        }
+    }
+}
@@ -48,7 +48,7 @@ import lombok.extern.slf4j.Slf4j;

@Slf4j
@RequiredArgsConstructor
-public class ViewerDocumentService {
+public class ViewerDocumentService implements IViewerDocumentService {

    private final ObservationRegistry registry;

@@ -64,7 +64,8 @@ public class ViewerDocumentService {

        PDDocument pdDocument = openPDDocument(tmpFile.toFile());

-        enrichObservation(pdDocument,
+        enrichObservation(registry,
+                          pdDocument.getNumberOfPages(),
                          visualizations.stream()
                                  .map(Visualizations::getLayer)
                                  .toList());
@@ -106,7 +107,11 @@ public class ViewerDocumentService {

                    contentStream.saveGraphicsState();

-                    drawVisualizationsToContentStream(pdDocument, visualization.getVisualizationsOnPages().get(pageNumber), contentStream, textDeRotationMatrix);
+                    drawVisualizationsToContentStream(pdDocument,
+                                                      visualization.getVisualizationsOnPages()
+                                                              .get(pageNumber),
+                                                      contentStream,
+                                                      textDeRotationMatrix);

                    contentStream.restoreGraphicsState();

@@ -185,8 +190,10 @@ public class ViewerDocumentService {
            contentStream.setFont(font, placedText.fontSize());
            contentStream.beginText();
            contentStream.setNonStrokingColor(placedText.color());
-            if (placedText.renderingMode().isPresent()) {
-                contentStream.setRenderingMode(placedText.renderingMode().get());
+            if (placedText.renderingMode()
+                    .isPresent()) {
+                contentStream.setRenderingMode(placedText.renderingMode()
+                                                       .get());
            } else {
                contentStream.setRenderingMode(RenderingMode.FILL);
            }
@@ -198,12 +205,12 @@ public class ViewerDocumentService {
    }


-    private void enrichObservation(PDDocument pdDocument, List<ContentStreams.Identifier> layers) {
+    private void enrichObservation(int numberOfPages, List<ContentStreams.Identifier> layers) {

        if (registry == null || registry.getCurrentObservation() == null || registry.isNoop()) {
            return;
        }
-        registry.getCurrentObservation().highCardinalityKeyValue("numberOfPages", String.valueOf(pdDocument.getNumberOfPages()));
+        registry.getCurrentObservation().highCardinalityKeyValue("numberOfPages", String.valueOf(numberOfPages));
        for (int i = 0; i < layers.size(); i++) {
            ContentStreams.Identifier layer = layers.get(i);

@@ -234,7 +241,8 @@ public class ViewerDocumentService {
                                    (float) placedText.lineStart().getX(),
                                    (float) placedText.lineStart().getY());
        } else {
-            textMatrix = placedText.textMatrix().get();
+            textMatrix = placedText.textMatrix()
+                    .get();
        }
        return textMatrix;
    }
@@ -0,0 +1,73 @@
+package com.knecon.fforesight.service.viewerdoc.service.pdftron;
+
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Set;
+
+public class MarkedContentStack {
+
+    private final Deque<MarkedContent> stack = new LinkedList<>();
+
+
+    public void enterMarkedContent(String name) {
+
+        stack.push(new MarkedContent(name));
+    }
+
+
+    public void leaveMarkedContent() {
+
+        stack.pop();
+    }
+
+
+    public String currentMarkedContent() {
+
+        if (stack.isEmpty()) {
+            return "";
+        }
+        return stack.peek().name();
+    }
+
+
+    public boolean currentMarkedContentContains(String name) {
+
+        Iterator<MarkedContent> markedContentIterator = stack.descendingIterator();
+        while (markedContentIterator.hasNext()) {
+            var markedContent = markedContentIterator.next();
+            if (markedContent.name().equals(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+    public boolean currentMarkedContentContainsAny(Set<String> names) {
+
+        if (stack.isEmpty()) {
+            return false;
+        }
+        Iterator<MarkedContent> markedContentIterator = stack.descendingIterator();
+        while (markedContentIterator.hasNext()) {
+            var markedContent = markedContentIterator.next();
+            if (names.contains(markedContent.name())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+    public void clear() {
+
+        stack.clear();
+    }
+
+
+    private record MarkedContent(String name) {
+
+    }
+
+}
@@ -0,0 +1,149 @@
+package com.knecon.fforesight.service.viewerdoc.service.pdftron;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.apache.pdfbox.cos.COSName;
+
+import com.knecon.fforesight.service.viewerdoc.ContentStreams;
+import com.knecon.fforesight.service.viewerdoc.model.EmbeddableFont;
+import com.knecon.fforesight.service.viewerdoc.model.PlacedText;
+import com.knecon.fforesight.service.viewerdoc.model.Visualizations;
+import com.knecon.fforesight.service.viewerdoc.model.VisualizationsOnPage;
+import com.knecon.fforesight.service.viewerdoc.service.IViewerDocumentService;
+import com.pdftron.pdf.ElementBuilder;
+import com.pdftron.pdf.ElementReader;
+import com.pdftron.pdf.ElementWriter;
+import com.pdftron.pdf.Font;
+import com.pdftron.pdf.PDFDoc;
+import com.pdftron.pdf.Page;
+import com.pdftron.pdf.PageIterator;
+import com.pdftron.pdf.ocg.Group;
+import com.pdftron.sdf.SDFDoc;
+
+import io.micrometer.observation.ObservationRegistry;
+import io.micrometer.observation.annotation.Observed;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@RequiredArgsConstructor
+public class PDFTronViewerDocumentService implements IViewerDocumentService {
+
+    private final ObservationRegistry registry;
+
+
+    @Override
+    @Observed(name = "PDFTronViewerDocumentService", contextualName = "add-visualizations")
+    @SneakyThrows
+    public synchronized void addVisualizationsOnPage(File originFile, File destinationFile, List<Visualizations> visualizations) {
+
+
+        // originFile and destinationFile might be the same, so we use a temp file.
+        // Otherwise, saving the document might corrupt the file
+        Path tmpFile = Files.createTempFile("tmpViewerDocument", ".pdf");
+        Files.copy(originFile.toPath(), tmpFile, StandardCopyOption.REPLACE_EXISTING);
+
+        try (PDFDoc pdfDoc = loadPdfDoc(tmpFile);//
+             ElementWriter pageWriter = new ElementWriter();//
+             ElementReader reader = new ElementReader();//
+             ElementBuilder builder = new ElementBuilder()//
+        ) {
+            enrichObservation(registry,
+                              pdfDoc.getPageCount(),
+                              visualizations.stream()
+                                      .map(Visualizations::getLayer)
+                                      .toList());
+
+            Map<ContentStreams.Identifier, Group> groupMap = PdftronLayerUtility.addLayersToDocument(visualizations, pdfDoc);
+
+            Map<EmbeddableFont, Font> fontMap = buildFontMap(visualizations, pdfDoc);
+
+            Set<String> markedContentToDraw = extractMarkedContentNames(visualizations.stream()
+                                                                                .map(Visualizations::getLayer));
+
+            Set<String> kneconMarkedContents = extractMarkedContentNames(ContentStreams.allContentStreams.stream());
+
+            PageContentCleaner pageContentCleaner = PageContentCleaner.builder()
+                    .writer(pageWriter)
+                    .reader(reader)
+                    .elementBuilder(builder)
+                    .markedContentToDraw(markedContentToDraw)
+                    .kneconMarkedContents(kneconMarkedContents)
+                    .build();
+
+            VisualizationWriter visualizationWriter = VisualizationWriter.builder()
+                    .writer(pageWriter)
+                    .builder(builder)
+                    .groupMap(groupMap)
+                    .visualizations(visualizations)
+                    .fontMap(fontMap)
+                    .build();
+
+            int pageNumber = 0;
+            for (PageIterator iterator = pdfDoc.getPageIterator(); iterator.hasNext(); pageNumber++) {
+
+                Page page = iterator.next();
+
+                pageContentCleaner.cleanPage(page);
+
+                visualizationWriter.drawVisualizationsOnPage(pageNumber, page);
+
+            }
+
+            saveDocument(pdfDoc, destinationFile);
+        }
+
+    }
+
+
+    private static Set<String> extractMarkedContentNames(Stream<ContentStreams.Identifier> visualizations) {
+
+        return visualizations.map(ContentStreams.Identifier::cosName)
+                .map(COSName::getName)
+                .collect(Collectors.toSet());
+    }
+
+
+    private static Map<EmbeddableFont, Font> buildFontMap(List<Visualizations> visualizations, PDFDoc pdfDoc) {
+
+        return visualizations.stream()
+                .map(Visualizations::getVisualizationsOnPages)
+                .map(Map::values)
+                .flatMap(Collection::stream)
+                .map(VisualizationsOnPage::getPlacedTexts)
+                .flatMap(Collection::stream)
+                .map(PlacedText::font)
+                .distinct()
+                .collect(Collectors.toMap(Function.identity(), font -> font.embed(pdfDoc)));
+
+    }
+
+
+    @SneakyThrows
+    private void saveDocument(PDFDoc doc, File target) {
+
+        doc.save(target.toString(), SDFDoc.SaveMode.REMOVE_UNUSED, null);
+    }
+
+
+    @SneakyThrows
+    private static PDFDoc loadPdfDoc(Path tmpFile) {
+
+        try (var in = new FileInputStream(tmpFile.toFile())) {
+            return new PDFDoc(in);
+        }
+    }
+
+}
@@ -0,0 +1,120 @@
+package com.knecon.fforesight.service.viewerdoc.service.pdftron;
+
+import java.util.Set;
+
+import com.pdftron.pdf.Element;
+import com.pdftron.pdf.ElementBuilder;
+import com.pdftron.pdf.ElementReader;
+import com.pdftron.pdf.ElementWriter;
+import com.pdftron.pdf.Page;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.SneakyThrows;
+import lombok.experimental.FieldDefaults;
+
+@Builder
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+public class PageContentCleaner {
+
+    ElementWriter writer;
+    ElementReader reader;
+    ElementBuilder elementBuilder;
+    Set<String> markedContentToDraw;
+    Set<String> kneconMarkedContents;
+
+    @Builder.Default
+    MarkedContentStack markedContentStack = new MarkedContentStack();
+
+
+    @SneakyThrows
+    public void cleanPage(Page page) {
+
+        begin(page);
+        boolean escaped = reader.next().getType() == Element.e_group_begin;
+
+        if (!escaped) {
+            writer.writeElement(elementBuilder.createGroupBegin());
+        }
+
+        copyElementsUntilFirstKneconMarkedContent();
+
+        if (!escaped) {
+            writer.writeElement(elementBuilder.createGroupEnd());
+        }
+
+        copyElementsExceptMarkedContentToDraw();
+        end();
+    }
+
+
+    @SneakyThrows
+    private void begin(Page page) {
+
+        writer.begin(page, ElementWriter.e_replacement, false, true, page.getResourceDict());
+        reader.begin(page);
+    }
+
+
+    @SneakyThrows
+    private void end() {
+
+        writer.end();
+        reader.end();
+    }
+
+
+    @SneakyThrows
+    private void copyElementsUntilFirstKneconMarkedContent() {
+
+        for (Element element = reader.current(); element != null; element = reader.next()) {
+
+            switch (element.getType()) {
+                case Element.e_marked_content_begin -> {
+                    markedContentStack.enterMarkedContent(element.getMCTag().getName());
+                    if (markedContentStack.currentMarkedContentContainsAny(kneconMarkedContents)) {
+                        break;
+                    }
+                    writer.writeElement(element);
+                }
+                case Element.e_marked_content_end -> {
+                    markedContentStack.leaveMarkedContent();
+                    writer.writeElement(element);
+                }
+                default -> writer.writeElement(element);
+            }
+        }
+    }
+
+
+    @SneakyThrows
+    private void copyElementsExceptMarkedContentToDraw() {
+
+        for (Element element = reader.current(); element != null; element = reader.next()) {
+
+            switch (element.getType()) {
+                case Element.e_marked_content_begin -> {
+                    markedContentStack.enterMarkedContent(element.getMCTag().getName());
+                    if (!markedContentStack.currentMarkedContentContainsAny(markedContentToDraw)) {
+                        writer.writeElement(element);
+                    }
+                }
+                case Element.e_marked_content_end -> {
+                    if (!markedContentStack.currentMarkedContentContainsAny(markedContentToDraw)) {
+                        writer.writeElement(element);
+                    }
+                    markedContentStack.leaveMarkedContent();
+                }
+                default -> {
+                    if (!markedContentStack.currentMarkedContentContainsAny(markedContentToDraw)) {
+                        writer.writeElement(element);
+                    }
+                }
+            }
+
+        }
+
+    }
+
+}
@@ -0,0 +1,96 @@
+package com.knecon.fforesight.service.viewerdoc.service.pdftron;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import com.knecon.fforesight.service.viewerdoc.ContentStreams;
+import com.knecon.fforesight.service.viewerdoc.model.Visualizations;
+import com.pdftron.common.PDFNetException;
+import com.pdftron.pdf.PDFDoc;
+import com.pdftron.pdf.ocg.Config;
+import com.pdftron.pdf.ocg.Group;
+import com.pdftron.sdf.Obj;
+
+import lombok.SneakyThrows;
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class PdftronLayerUtility {
+
+    public Map<ContentStreams.Identifier, Group> addLayersToDocument(List<Visualizations> visualizations, PDFDoc pdfDoc) {
+
+        Map<ContentStreams.Identifier, Group> optionalContentGroupMap = new HashMap<>();
+        for (Visualizations visualization : visualizations) {
+            addLayerToDocument(visualization.getLayer(), pdfDoc, visualization.isLayerVisibilityDefaultValue())//
+                    .ifPresent(ocg -> optionalContentGroupMap.put(visualization.getLayer(), ocg));
+        }
+        return optionalContentGroupMap;
+    }
+
+
+    private Optional<Group> addLayerToDocument(ContentStreams.Identifier layer, PDFDoc pdfDoc, boolean layerVisibilityDefaultValue) {
+
+        if (layer.optionalContent()) {
+            return Optional.of(addLayerToDocument(pdfDoc, layer.name(), layerVisibilityDefaultValue));
+
+        }
+        return Optional.empty();
+
+    }
+
+
+    @SneakyThrows
+    private Group addLayerToDocument(PDFDoc doc, String layerName, boolean layerVisibilityDefaultValue) {
+
+        Optional<Group> existingGroup = findGroupInDoc(doc, layerName);
+
+        if (existingGroup.isPresent()) {
+            return existingGroup.get();
+        }
+
+        return addNewLayer(doc, layerName, layerVisibilityDefaultValue);
+    }
+
+
+    private Group addNewLayer(PDFDoc doc, String layerName, boolean layerVisibilityDefaultValue) throws PDFNetException {
+
+        Config cfg = doc.getOCGConfig();
+        if (cfg == null) {
+            cfg = Config.create(doc, true);
+            cfg.setName("Default");
+        }
+        Group grp = Group.create(doc, layerName);
+        grp.setInitialState(cfg, layerVisibilityDefaultValue);
+
+        // Add the new OCG to the list of layers that should appear in PDF viewer GUI.
+        Obj layerOrderArray = cfg.getOrder();
+        if (layerOrderArray == null) {
+            layerOrderArray = doc.createIndirectArray();
+            cfg.setOrder(layerOrderArray);
+        }
+        layerOrderArray.pushBack(grp.getSDFObj());
+
+        return grp;
+    }
+
+
+    @SneakyThrows
+    private Optional<Group> findGroupInDoc(PDFDoc doc, String layerName) {
+
+        Obj ocgs = doc.getOCGs();
+        if (ocgs != null) {
+            int i;
+            int sz = (int) ocgs.size();
+            for (i = 0; i < sz; ++i) {
+                Group ocg = new Group(ocgs.getAt(i));
+                if (ocg.getName().equals(layerName)) {
+                    return Optional.of(ocg);
+                }
+            }
+        }
+        return Optional.empty();
+    }
+
+}
@@ -0,0 +1,249 @@
+package com.knecon.fforesight.service.viewerdoc.service.pdftron;
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Line2D;
+import java.awt.geom.Rectangle2D;
+import java.util.List;
+import java.util.Map;
+
+import com.knecon.fforesight.service.viewerdoc.ContentStreams;
+import com.knecon.fforesight.service.viewerdoc.model.ColoredLine;
+import com.knecon.fforesight.service.viewerdoc.model.ColoredRectangle;
+import com.knecon.fforesight.service.viewerdoc.model.EmbeddableFont;
+import com.knecon.fforesight.service.viewerdoc.model.FilledRectangle;
+import com.knecon.fforesight.service.viewerdoc.model.PlacedText;
+import com.knecon.fforesight.service.viewerdoc.model.Visualizations;
+import com.knecon.fforesight.service.viewerdoc.model.VisualizationsOnPage;
+import com.pdftron.common.Matrix2D;
+import com.pdftron.common.PDFNetException;
+import com.pdftron.pdf.ColorPt;
+import com.pdftron.pdf.ColorSpace;
+import com.pdftron.pdf.Element;
+import com.pdftron.pdf.ElementBuilder;
+import com.pdftron.pdf.ElementWriter;
+import com.pdftron.pdf.Font;
+import com.pdftron.pdf.GState;
+import com.pdftron.pdf.Page;
+import com.pdftron.pdf.ocg.Group;
+
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.SneakyThrows;
+import lombok.experimental.FieldDefaults;
+
+@Builder
+@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
+public class VisualizationWriter {
+
+    ElementWriter writer;
+    ElementBuilder builder;
+    List<Visualizations> visualizations;
+    Map<ContentStreams.Identifier, Group> groupMap;
+    Map<EmbeddableFont, Font> fontMap;
+
+
+    @SneakyThrows
+    public void drawVisualizationsOnPage(int pageNumber, Page page) {
+
+        begin(page);
+
+        AffineTransform textDeRotationMatrix = getTextDeRotationTransform(page);
+
+        for (Visualizations visualization : visualizations) {
+
+            VisualizationsOnPage visualizationsOnPage = visualization.getVisualizationsOnPages()
+                    .get(pageNumber);
+
+            if (visualizationsOnPage == null || visualizationsOnPage.isEmpty()) {
+                continue;
+            }
+
+            Element markedContentStart = builder.createMarkedContentBeginInlineProperties(visualization.getLayer().cosName().getName());
+            writer.writeElement(markedContentStart);
+
+            if (visualization.getLayer().optionalContent()) {
+                Element ocgStart = builder.createMarkedContentBegin("OC", groupMap.get(visualization.getLayer()).getSDFObj());
+                writer.writeElement(ocgStart);
+            }
+
+            writeVisualization(visualizationsOnPage, textDeRotationMatrix);
+
+            if (visualization.getLayer().optionalContent()) {
+                Element ocgEnd = builder.createMarkedContentEnd();
+                writer.writeElement(ocgEnd);
+            }
+
+            Element markedContentEnd = builder.createMarkedContentEnd();
+            writer.writeElement(markedContentEnd);
+
+        }
+
+        end();
+
+    }
+
+
+    private void end() throws PDFNetException {
+
+        writer.end();
+    }
+
+
+    private void begin(Page page) throws PDFNetException {
+
+        writer.begin(page, ElementWriter.e_overlay, false, true, page.getResourceDict());
+    }
+
+
+    @SneakyThrows
+    private void writeVisualization(VisualizationsOnPage visualizationsOnPage, AffineTransform textDeRotationMatrix) {
+
+        if (visualizationsOnPage.isMakePathsInvisible()) {
+            Element rect = builder.createRect(0, 0, 0, 0);
+            rect.setPathClip(true);
+            writer.writeElement(rect);
+        }
+
+        for (ColoredLine coloredLine : visualizationsOnPage.getColoredLines()) {
+
+            drawColoredLine(coloredLine);
+        }
+
+        for (ColoredRectangle coloredRectangle : visualizationsOnPage.getColoredRectangles()) {
+
+            drawColoredRectangle(coloredRectangle);
+        }
+
+        for (FilledRectangle filledRectangle : visualizationsOnPage.getFilledRectangles()) {
+
+            drawFilledRectangle(filledRectangle);
+        }
+
+        for (PlacedText placedText : visualizationsOnPage.getPlacedTexts()) {
+
+            writePlacedText(textDeRotationMatrix, placedText);
+        }
+    }
+
+
+    private void writePlacedText(AffineTransform textDeRotationMatrix, PlacedText placedText) throws PDFNetException {
+
+        float[] rgbComponents = placedText.color().getRGBColorComponents(null);
+        Font font = fontMap.get(placedText.font());
+
+        Element text = builder.createTextRun(placedText.text(), font, placedText.fontSize());
+
+        if (placedText.renderingMode()
+                .isPresent()) {
+            text.getGState()
+                    .setRenderingIntent(placedText.renderingMode()
+                                                .get().intValue());
+        } else {
+            try (ColorPt color = new ColorPt(rgbComponents[0], rgbComponents[1], rgbComponents[2])) {
+                text.getGState().setFillColor(color);
+            }
+            text.getGState().setRenderingIntent(GState.e_fill_text);
+        }
+
+        try (Matrix2D textMatrix = getTextMatrix(placedText, textDeRotationMatrix)) {
+            text.setTextMatrix(textMatrix);
+        }
+
+        writer.writeElement(text);
+    }
+
+
+    private void drawFilledRectangle(FilledRectangle filledRectangle) throws PDFNetException {
+
+        float[] rgbComponents = filledRectangle.color().getRGBColorComponents(null);
+        Rectangle2D r = filledRectangle.rectangle2D();
+
+        Element rect = builder.createRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+
+        rect.setPathFill(true);
+        rect.setPathStroke(false);
+        rect.getGState().setFillColorSpace(ColorSpace.createDeviceRGB());
+        rect.getGState().setFillOpacity(filledRectangle.alpha());
+
+        try (ColorPt color = new ColorPt(rgbComponents[0], rgbComponents[1], rgbComponents[2])) {
+            rect.getGState().setFillColor(color);
+        }
+
+        writer.writeElement(rect);
+    }
+
+
+    private void drawColoredRectangle(ColoredRectangle coloredRectangle) throws PDFNetException {
+
+        float[] rgbComponents = coloredRectangle.color().getRGBColorComponents(null);
+        Rectangle2D r = coloredRectangle.rectangle2D();
+
+        Element rect = builder.createRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
+
+        rect.setPathStroke(true);
+        rect.setPathFill(false);
+        rect.getGState().setStrokeColorSpace(ColorSpace.createDeviceRGB());
+        rect.getGState().setLineWidth(coloredRectangle.lineWidth());
+
+        try (ColorPt color = new ColorPt(rgbComponents[0], rgbComponents[1], rgbComponents[2])) {
+            rect.getGState().setStrokeColor(color);
+        }
+
+        writer.writeElement(rect);
+    }
+
+
+    private void drawColoredLine(ColoredLine coloredLine) throws PDFNetException {
+
+        float[] rgbComponents = coloredLine.color().getRGBColorComponents(null);
+        Line2D l = coloredLine.line();
+
+        builder.pathBegin();
+        builder.moveTo(l.getX1(), l.getY1());
+        builder.lineTo(l.getX2(), l.getY2());
+        Element line = builder.pathEnd();
+
+        line.setPathStroke(true);
+        line.setPathFill(false);
+        line.getGState().setLineWidth(coloredLine.lineWidth());
+        line.getGState().setStrokeColorSpace(ColorSpace.createDeviceRGB());
+
+        try (ColorPt color = new ColorPt(rgbComponents[0], rgbComponents[1], rgbComponents[2])) {
+            line.getGState().setStrokeColor(color);
+        }
+        writer.writeElement(line);
+    }
+
+
+    @SneakyThrows
+    private static Matrix2D getTextMatrix(PlacedText placedText, AffineTransform textDeRotationMatrix) {
+
+        Matrix2D textMatrix;
+        if (placedText.textMatrix().isEmpty()) {
+            textMatrix = new Matrix2D(textDeRotationMatrix.getScaleX(),
+                                      textDeRotationMatrix.getShearX(),
+                                      textDeRotationMatrix.getShearY(),
+                                      textDeRotationMatrix.getScaleY(),
+                                      placedText.lineStart().getX(),
+                                      placedText.lineStart().getY());
+        } else {
+            var matrix = placedText.textMatrix()
+                    .get();
+            textMatrix = new Matrix2D(matrix.getScaleX(), matrix.getShearX(), matrix.getShearY(), matrix.getScaleY(), matrix.getTranslateX(), matrix.getTranslateY());
+        }
+        return textMatrix;
+    }
+
+
+    @SneakyThrows
+    private static AffineTransform getTextDeRotationTransform(Page page) {
+
+        return AffineTransform.getQuadrantRotateInstance(switch (page.getRotation()) {
+            case 90 -> 3;
+            case 180 -> 2;
+            case 270 -> 1;
+            default -> 0;
+        });
+    }
+
+}
@@ -1,5 +1,7 @@
 #!/bin/bash
-dir=${PWD##*/}
+
+set -e
+
 gradle assemble

 # Get the current Git branch
@@ -11,5 +13,31 @@ commit_hash=$(git rev-parse --short=5 HEAD)
 # Combine branch and commit hash
 buildName="${USER}-${branch}-${commit_hash}"

-gradle bootBuildImage --publishImage -PbuildbootDockerHostNetwork=true -Pversion=$buildName --no-build-cache
-echo "nexus.knecon.com:5001/ff/layoutparser-service-server:$buildName"
+gradle bootBuildImage --publishImage -PbuildbootDockerHostNetwork=true -Pversion=${buildName}
+
+newImageName="nexus.knecon.com:5001/ff/layoutparser-service-server:${buildName}"
+
+echo "full image name:"
+echo ${newImageName}
+echo ""
+
+if [ -z "$1" ]; then
+    exit 0
+fi
+
+namespace=${1}
+deployment_name="layoutparser-service"
+
+echo "deploying to ${namespace}"
+
+oldImageName=$(rancher kubectl -n ${namespace} get deployment ${deployment_name} -o=jsonpath='{.spec.template.spec.containers[*].image}')
+
+if [ "${newImageName}" = "${oldImageName}" ]; then
+    echo "Image tag did not change, redeploying..."
+    rancher kubectl rollout restart deployment ${deployment_name} -n ${namespace}
+else
+    echo "upgrading the image tag..."
+    rancher kubectl set image deployment/${deployment_name} ${deployment_name}=${newImageName} -n ${namespace}
+fi
+rancher kubectl rollout status deployment ${deployment_name} -n ${namespace}
+echo "Built ${deployment_name}:${buildName} and deployed to ${namespace}"
Author	SHA1	Message	Date
Kilian Schuettler	9864d81d9d	Clari-002: render document data as markdown	2024-07-09 11:03:51 +02:00
Kilian Schuettler	251c84f884	Clari-002: render document data as markdown	2024-07-09 11:03:45 +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