Examples with WordType eu.transkribus.core.model.beans.pagecontent.WordType used on opensource projects

Example 1 with WordType

use of eu.transkribus.core.model.beans.pagecontent.WordType in project TranskribusCore by Transkribus.

the class FinereaderUtils method replaceBadChars.

/**
 * Method for replacing certain systematic errors in OCR Text.
 * Replacements are done with regexes from private static regexReglMap (see above in this class).
 *
 * TODO add parameters to pass custom maps from a search/replace dialog!?
 * @param pc
 * @return
 */
public static PcGtsType replaceBadChars(PcGtsType pc) {
    List<TrpRegionType> regs = pc.getPage().getTextRegionOrImageRegionOrLineDrawingRegion();
    boolean success = true;
    for (RegionType r : regs) {
        if (!isTextRegion(r)) {
            continue;
        }
        TextRegionType tr = (TextRegionType) r;
        if (tr.getTextEquiv() == null && tr.getTextEquiv().getUnicode() == null) {
            // no text at all
            continue;
        }
        final String textblockBefore = tr.getTextEquiv().getUnicode();
        final String textblockAfter = replaceChars(textblockBefore, regexRepl);
        // iterate lines
        List<TextLineType> lines = tr.getTextLine();
        if (lines == null || lines.isEmpty()) {
            // textblockAfter = replaceChars(textblockBefore, regexRepl);
            continue;
        }
        // setRegionText
        tr.getTextEquiv().setUnicode(textblockAfter);
        StringBuffer linesBefore = new StringBuffer();
        StringBuffer linesAfter = new StringBuffer();
        // DEBUG END
        boolean isFirstLine = true;
        for (TextLineType l : lines) {
            if (l.getTextEquiv() == null && l.getTextEquiv().getUnicode() == null) {
                // empty line
                continue;
            }
            // Build the textRegion for later use
            final String textlineBefore = l.getTextEquiv().getUnicode();
            final String textlineAfter = replaceChars(textlineBefore, regexRepl);
            linesBefore.append(isFirstLine ? textlineBefore : "\n" + textlineBefore);
            linesAfter.append(isFirstLine ? textlineAfter : "\n" + textlineAfter);
            if (isFirstLine)
                isFirstLine = false;
            l.getTextEquiv().setUnicode(textlineAfter);
            // iterate words
            List<WordType> words = l.getWord();
            if (words == null || words.isEmpty()) {
                // with next line
                continue;
            }
            boolean isFirstWord = true;
            StringBuffer wordsBefore = new StringBuffer();
            StringBuffer wordsAfter = new StringBuffer();
            for (int i = 0; i < words.size(); i++) {
                WordType w = words.get(i);
                if (w.getTextEquiv() == null || w.getTextEquiv().getUnicode() == null) {
                    continue;
                }
                final String wordText = w.getTextEquiv().getUnicode();
                final String wordTextAfter;
                if (i < words.size() - 1) {
                    // use general replacement map for all words
                    wordTextAfter = replaceChars(wordText, repl);
                } else {
                    // use regex map for EOL words
                    wordTextAfter = replaceChars(wordText, regexRepl);
                }
                // DEBUG
                wordsBefore.append(isFirstWord ? wordText : " " + wordText);
                wordsAfter.append(isFirstWord ? wordTextAfter : " " + wordTextAfter);
                if (isFirstWord)
                    isFirstWord = false;
                // DEBUG END
                w.getTextEquiv().setUnicode(wordTextAfter);
            }
            boolean lineSuccess = textlineBefore.toString().replace(" ", "").equals(wordsBefore.toString().replace(" ", ""));
            lineSuccess &= textlineAfter.toString().replace(" ", "").equals(wordsAfter.toString().replace(" ", ""));
            if (!lineSuccess) {
                logger.debug("Line before: " + textlineBefore.toString());
                logger.debug("Words before : " + wordsBefore.toString());
                logger.debug("Line after: " + textlineAfter.toString());
                logger.debug("Words after : " + wordsAfter.toString());
            }
            success &= lineSuccess;
        // TODO propagate words -> lines -> regions
        }
        boolean regionSuccess = textblockBefore.replace(" ", "").equals(linesBefore.toString().replace(" ", ""));
        regionSuccess &= textblockAfter.replace(" ", "").equals(linesAfter.toString().replace(" ", ""));
        if (!regionSuccess) {
            logger.debug("\nblock:\n");
            logger.debug(textblockAfter);
            logger.debug("\nblock from lines:\n");
            logger.debug(linesAfter.toString());
        }
        success &= regionSuccess;
    }
    logger.info("Bad character replacement: " + (success ? "SUCCESS" : "FAILURE"));
    // if(!success) throw new IllegalArgumentException();
    return pc;
}

Example 2 with WordType

use of eu.transkribus.core.model.beans.pagecontent.WordType in project TranskribusCore by Transkribus.

the class TrpPdfDocument method addUniformTextFromTextRegion.

private void addUniformTextFromTextRegion(final TextRegionType tr, final PdfContentByte cb, int cutoffLeft, int cutoffTop, BaseFont bf, float lineStartX, ExportCache cache) throws IOException, DocumentException {
    List<TextLineType> lines = tr.getTextLine();
    if (lines != null && !lines.isEmpty()) {
        int i = 0;
        float lineStartY = 0;
        // sort according to reading order
        Collections.sort(lines, new TrpElementReadingOrderComparator<TextLineType>(true));
        double minY = 0;
        double maxY = 0;
        // get min and max values of region y direction for later calculation of textline height
        // java.awt.Rectangle regionRect = PageXmlUtils.buildPolygon(tr.getCoords().getPoints()).getBounds();
        int maxIdx = lines.size() - 1;
        // java.awt.Rectangle firstLineRectOld = PageXmlUtils.buildPolygon(lines.get(0).getCoords().getPoints()).getBounds();
        // logger.debug("OLDDDDD: firstLineRectOld minX = " + firstLineRectOld.getMinX());
        java.awt.Rectangle firstLineRect = ((TrpTextLineType) lines.get(0)).getBoundingBox();
        // logger.debug("NEWWWWW: firstLineRect minX = " + firstLineRect.getMinX());
        // java.awt.Rectangle lastLineRect = PageXmlUtils.buildPolygon(lines.get(maxIdx).getCoords().getPoints()).getBounds();
        java.awt.Rectangle lastLineRect = ((TrpTextLineType) lines.get(maxIdx)).getBoundingBox();
        double firstLineRotation = computeRotation((TrpBaselineType) lines.get(0).getBaseline());
        double lastLineRotation = computeRotation((TrpBaselineType) lines.get(maxIdx).getBaseline());
        boolean isVerticalRegion = false;
        // use X coords to compute the total line gap
        if (firstLineRotation == 90 && lastLineRotation == 90) {
            // since the reading order is not clear if the text is vertically -> could be right to left or vice versa
            double tmpMinX1 = firstLineRect.getMinX();
            double tmpMinX2 = lastLineRect.getMinX();
            double tmpMaxX1 = firstLineRect.getMaxX();
            double tmpMaxX2 = lastLineRect.getMaxX();
            minY = Math.min(tmpMinX1, tmpMinX2);
            maxY = Math.max(tmpMaxX1, tmpMaxX2);
            isVerticalRegion = true;
        } else {
            minY = firstLineRect.getMinY();
            maxY = lastLineRect.getMaxY();
        }
        /*
			 * if start of line is too tight on the upper bound - set to the first 1/12 of t page from above
			 * BUT: Is not good since page number and other informations are often in this section
			 */
        // if (minY < twelfthPoints[1][1]){
        // minY = twelfthPoints[1][1];
        // }
        // for(TextLineType lt : lines){
        // 
        // TrpTextLineType l = (TrpTextLineType)lt;
        // java.awt.Rectangle lineRect = PageXmlUtils.buildPolygon(l.getCoords().getPoints()).getBounds();
        // 
        // 
        // 
        // if (lines.size() == 1){
        // minY = lineRect.getMinY();
        // maxY = lineRect.getMaxY();
        // 
        // }
        // else if (l.getIndex() == 0){
        // minY = lineRect.getMinY();
        // }
        // else if (l.getIndex() == lines.size()-1){
        // maxY = lineRect.getMaxY();
        // }
        // 
        // }
        double lineGap = (maxY - minY) / lines.size();
        // use default values if only one line  and no previous line mean height computed
        if (lines.size() == 1) {
            lineMeanHeight = (prevLineMeanHeight != 0 ? prevLineMeanHeight : lineMeanHeight);
        } else if (lines.size() > 1) {
            lineMeanHeight = (float) (2 * (lineGap / 3));
            leading = (int) (lineGap / 3);
            prevLineMeanHeight = lineMeanHeight;
        // logger.debug("Line Mean Height for Export " + lineMeanHeight);
        // overallLineMeanHeight = ( (overallLineMeanHeight != 0) ? overallLineMeanHeight+lineMeanHeight/2 : lineMeanHeight);
        }
        for (TextLineType lt : lines) {
            wordOffset = 0;
            TrpTextLineType l = (TrpTextLineType) lt;
            TrpBaselineType baseline = (TrpBaselineType) l.getBaseline();
            // PageXmlUtils.buildPolygon(l.getCoords().getPoints()).getBounds();
            java.awt.Rectangle lineRect = l.getBoundingBox();
            // PageXmlUtils.buildPolygon(baseline.getPoints()).getBounds();
            java.awt.Rectangle baseLineRect = baseline == null ? null : baseline.getBoundingBox();
            if (baseLineRect == null) {
                logger.debug("Baseline is null - ignore this line");
                continue;
            }
            float tmpLineStartX = lineStartX;
            // PageXmlUtils.buildPolygon(tr.getCoords().getPoints()).getBounds().getMinX();
            float regionStartMinX = (float) tr.getBoundingBox().getMinX();
            double regionWidth = tr.getBoundingBox().getWidth();
            // first line
            if (i == 0) {
                lineStartY = (float) (minY + lineMeanHeight);
                /*
					 * if first line of a text region is indented then take this into account in printed text
					 */
                if (lineRect.getMinX() > regionStartMinX) {
                    if (lineRect.getMinX() - regionStartMinX > regionWidth / 4) {
                        // tmpLineStartX = (float) lineStartX + twelfthPoints[1][0];
                        tmpLineStartX = (float) baseLineRect.getMinX();
                    }
                }
            } else // for subsequent lines
            {
                if (lineRect.getMinX() > regionStartMinX) {
                    if (lineRect.getMinX() - regionStartMinX > regionWidth / 4) {
                        // tmpLineStartX = (float) lineStartX + twelfthPoints[1][0];
                        tmpLineStartX = (float) baseLineRect.getMinX();
                    }
                }
                // tmpLineStartX = getLinePositionInTextregionGrid(twelfthRegion, lineRect.getMinX());
                lineStartY = lineStartY + lineMeanHeight + leading;
            // for (TrpTextRegionType region : tr.getPage().getTextRegions(true)){
            // 
            // double regionMinX = PageXmlUtils.buildPolygon(region.getCoords().getPoints()).getBounds().getMinX();
            // double regionMaxX = PageXmlUtils.buildPolygon(region.getCoords().getPoints()).getBounds().getMaxX();
            // Rectangle rec = PageXmlUtils.buildPolygon(region.getCoords().getPoints()).getBounds();
            // 
            // if (rec.contains(tmpLineStartX, lineStartY) && !tr.getId().equals(region.getId()) && tmpLineStartX < regionMaxX){
            // logger.debug("region contains point " + tr.getId() + " region ID " + region.getId());
            // tmpLineStartX = (float) regionMaxX;
            // break;
            // }
            // 
            // 
            // }
            // if (lineRect.getMinX() > lineStartX){
            // if (lineRect.getMinX() - lineStartX > twelfthPoints[1][0]){
            // tmpLineStartX = (float) lineRect.getMinX();
            // }
            // }
            }
            if (baseLineRect != null && regionStartMinX < baseLineRect.getMinX() && (baseLineRect.getMinX() - regionStartMinX) > twelfthPoints[1][0]) {
                // logger.debug("try to find smaller region for baseline !!!!!!! " );
                for (TrpTextRegionType region : tr.getPage().getTextRegions(false)) {
                    if (!region.getId().equals(tr.getId())) {
                        // PageXmlUtils.buildPolygon(region.getCoords().getPoints()).getBounds().getMinX();
                        double regionMinX = region.getBoundingBox().getMinX();
                        double regionMaxX = region.getBoundingBox().getMaxX();
                        double regionMinY = region.getBoundingBox().getMinY();
                        double regionMaxY = region.getBoundingBox().getMaxY();
                        double meanX = regionMinX + (regionMaxX - regionMinX) / 2;
                        // another region before the lines
                        if (meanX > regionStartMinX && meanX < baseLineRect.getMinX() && baseLineRect.getMinY() < regionMaxY && baseLineRect.getMinY() > regionMinY) {
                            tmpLineStartX = (float) regionMaxX + lineMeanHeight;
                            logger.debug("region " + region.getId() + " overlaps this other region " + tr.getId());
                            // logger.debug("new tmplineStartX is " + regionMaxX);
                            break;
                        }
                    }
                }
            // tmpLineStartX = (float) baseLineRect.getMinX();
            }
            i++;
            /*
				 * word level bei uniform output nicht sinnvoll?
				 * besser nur ganze lines ausgeben
				 */
            // if(useWordLevel && !l.getWord().isEmpty()){
            // List<WordType> words = l.getWord();
            // for(WordType wt : words){
            // TrpWordType w = (TrpWordType)wt;
            // if(!w.getUnicodeText().isEmpty()){
            // java.awt.Rectangle boundRect = PageXmlUtils.buildPolygon(w.getCoords()).getBounds();
            // 
            // addUniformString(boundRect, lineMeanHeight, lineStartX, lineStartY, w.getUnicodeText(), cb, cutoffLeft, cutoffTop, bf);
            // } else {
            // logger.info("No text content in word: " + w.getId());
            // }
            // }
            // } else if(!l.getUnicodeText().isEmpty()){
            /*
				 * make chunks out of the lineText
				 * so it is possible to have differnt fonts, underlines and other text styles in one line
				 * 
				 * possible text styles are:
				 * 		new CustomTagAttribute("fontFamily", true, "Font family", "Font family"),
						new CustomTagAttribute("serif", true, "Serif", "Is this a serif font?"),
						new CustomTagAttribute("monospace",true, "Monospace", "Is this a monospace (i.e. equals width characters) font?"),
						new CustomTagAttribute("fontSize", true, "Font size", "The size of the font in points"),
						new CustomTagAttribute("kerning", true, "Kerning", "The kerning of the font, see: http://en.wikipedia.org/wiki/Kerning"),
						new CustomTagAttribute("textColour", true, "Text colour", "The foreground colour of the text"),
						new CustomTagAttribute("bgColour", true, "Background colour", "The background colour of the text"),
						new CustomTagAttribute("reverseVideo", true, "Reverse video", "http://en.wikipedia.org/wiki/Reverse_video"),
						new CustomTagAttribute("bold", true, "Bold", "Bold font"),
						new CustomTagAttribute("italic", true, "Italic", "Italic font"),
						new CustomTagAttribute("underlined", true, "Underlined", "Underlined"),
						new CustomTagAttribute("subscript", true, "Subscript", "Subscript"),
						new CustomTagAttribute("superscript", true, "Superscript", "Superscript"),
						new CustomTagAttribute("strikethrough", true, "Strikethrough", "Strikethrough"),
						new CustomTagAttribute("smallCaps", true, "Small caps", "Small capital letters at the height as lowercase letters, see: http://en.wikipedia.org/wiki/Small_caps"),
						new CustomTagAttribute("letterSpaced", true, "Letter spaced", "Equals distance between characters, see: http://en.wikipedia.org/wiki/Letter-spacing"),
				 */
            List<Chunk> chunkList = new ArrayList<Chunk>();
            /*
				 * if line is empty -> use the words of this line as line text
				 * otherwise take the text in the line
				 */
            List<TextStyleTag> styleTags = new ArrayList<TextStyleTag>();
            String shapeText = "";
            if (l.getUnicodeText().isEmpty() || useWordLevel) {
                // logger.debug("in word based path " + useWordLevel);
                List<WordType> words = l.getWord();
                int chunkIndex = 0;
                for (WordType wt : words) {
                    TrpWordType w = (TrpWordType) wt;
                    String wordText = "";
                    // add empty space after each word
                    if (chunkIndex > 0) {
                        chunkList.add(chunkIndex, new Chunk(" "));
                        chunkIndex++;
                    }
                    if (!w.getUnicodeText().isEmpty()) {
                        // remember all style tags for text formatting later on
                        styleTags.addAll(w.getTextStyleTags());
                        if (!shapeText.equals("")) {
                            shapeText = shapeText.concat(" ");
                        }
                        wordText = wordText.concat(w.getUnicodeText());
                        shapeText = shapeText.concat(w.getUnicodeText());
                        for (int j = 0; j < wordText.length(); ++j) {
                            String currentCharacter = wordText.substring(j, j + 1);
                            chunkList.add(chunkIndex, formatText(currentCharacter, styleTags, j, w, cache));
                            chunkIndex++;
                        }
                        styleTags.clear();
                    }
                }
            } else if (!l.getUnicodeText().isEmpty()) {
                String lineText = l.getUnicodeText();
                shapeText = lineText;
                // logger.debug("line Text is " + lineText);
                styleTags.addAll(l.getTextStyleTags());
                for (int j = 0; j < lineText.length(); ++j) {
                    String currentCharacter = lineText.substring(j, j + 1);
                    chunkList.add(j, formatText(currentCharacter, styleTags, j, l, cache));
                }
            } else // empty shape
            {
                logger.debug("empty shape ");
                continue;
            }
            Phrase phrase = new Phrase();
            // trim is important to get the 'real' first char for rtl definition
            boolean rtl = textIsRTL(shapeText.trim());
            if (rtl) {
                logger.debug("&&&&&&&& STRING IS RTL : ");
            }
            for (int j = chunkList.size() - 1; j >= 0; j--) {
                if (rtl) {
                    phrase.add(chunkList.get(j));
                } else {
                    phrase.addAll(chunkList);
                    break;
                }
            }
            // phrase.addAll(chunkList);
            // logger.debug("curr phrase is: " + phrase.getContent());
            // compute rotation of text, if rotation higher PI/16 than rotate otherwise even text
            /*
				 * No rotation for single lines in a overall horizontal text region 
				 * Reason: Vertical line uses too much space - calculated for horizontal
				 */
            double rotation = 0;
            if (isVerticalRegion) {
                rotation = (baseline != null ? computeRotation(baseline) : 0);
                if (rotation != 0) {
                    /*
						 * if we rotate e.g. 90° than we should use the actual x location of the line
						 * so vertical text must be treated different than horizontal text 
						 */
                    if (baseLineRect != null) {
                        if (rtl) {
                            tmpLineStartX = (float) baseLineRect.getMaxX();
                        } else {
                            tmpLineStartX = (float) baseLineRect.getMinX();
                        }
                        lineStartY = (float) baseLineRect.getMaxY();
                    } else if (lineRect != null) {
                        tmpLineStartX = lineRect.x;
                        lineStartY = (float) lineRect.getMaxY();
                    }
                }
            }
            // blacken Strings if wanted
            // Set<Entry<CustomTag, String>> blackSet = CustomTagUtils.getAllTagsOfThisTypeForShapeElement(l, RegionTypeUtil.BLACKENING_REGION.toLowerCase()).entrySet();
            // 
            // if (!lineText.equals("") && doBlackening && blackSet.size() > 0){
            // 
            // //for all blackening regions replace text with ****
            // for (Map.Entry<CustomTag, String> currEntry : blackSet){
            // 
            // if (!currEntry.getKey().isIndexed()){
            // //logger.debug("line not indexed : " + lineText);
            // lineText = lineText.replaceAll(".", "*");
            // }
            // else{
            // lineText = blackenString(currEntry, lineText);
            // //logger.debug("lineText after blackened : " + lineText);
            // }
            // }
            // }
            // for rtl export
            float lineEndX = 0;
            float width = 0;
            if (baseLineRect != null) {
                lineEndX = (float) baseLineRect.getMaxX();
                width = (float) baseLineRect.getWidth();
            // this leads to an extra start for each line instead of having a combined start for all lines in a region
            // tmpLineStartX = (float) (lineEndX - baseLineRect.getWidth());
            } else if (lineRect != null) {
                lineEndX = lineRect.x + lineRect.width;
                width = (float) lineRect.getWidth();
            }
            // mainly for very small regions at the very left of a page
            if (tmpLineStartX > lineEndX) {
                lineEndX = tmpLineStartX + width;
            }
            // logger.debug("width " + width);
            // logger.debug("lineEndX " + lineEndX);
            // first add uniform String (=line), ,after that eventaully highlight the tags in this line using the current line information like x/y position,
            // addUniformString(lineMeanHeight, tmpLineStartX, lineStartY, lineText, cb, cutoffLeft, cutoffTop, bf, twelfthPoints[1][0], false, null, rotation);
            addUniformString(tr.getBoundingBox(), lineMeanHeight, tmpLineStartX, lineStartY, lineEndX, phrase, cb, cutoffLeft, cutoffTop, bf, twelfthPoints[1][0], false, null, rotation, rtl);
        /*
				 * old:
				 * highlight all tags of this text line if property is set
				 * no highlighting is done during chunk formatting and not in an extra step
				 */
        // if (highlightTags){
        // 
        // 
        // Set<Entry<CustomTag, String>> entrySet = CustomTagUtils.getAllTagsForShapeElement(l).entrySet();
        // 
        // highlightUniformString(entrySet, tmpLineStartX, lineStartY, l, cb, cutoffLeft, cutoffTop, bf);
        // 
        // List<WordType> words = l.getWord();
        // for(WordType wt : words){
        // TrpWordType w = (TrpWordType)wt;
        // 
        // Set<Entry<CustomTag, String>> entrySet2 = CustomTagUtils.getAllTagsForShapeElement(w).entrySet();
        // 
        // highlightUniformString(entrySet2, tmpLineStartX, lineStartY, l, cb, cutoffLeft, cutoffTop, bf);
        // }
        // 
        // }
        }
    }
}

Example 3 with WordType

use of eu.transkribus.core.model.beans.pagecontent.WordType in project TranskribusCore by Transkribus.

the class TrpPdfDocument method addTextFromTextRegion.

private void addTextFromTextRegion(final TextRegionType tr, final PdfContentByte cb, int cutoffLeft, int cutoffTop, BaseFont bf, ExportCache cache) throws IOException {
    List<TextLineType> lines = tr.getTextLine();
    boolean firstLine;
    if (lines != null && !lines.isEmpty()) {
        // sort according to reading order
        Collections.sort(lines, new TrpElementReadingOrderComparator<TextLineType>(true));
        double baseLineMeanY = 0;
        double baseLineMeanYPrev = 0;
        double baseLineMeanGap = 0;
        // logger.debug("Processing " + lines.size() + " lines in TextRegion " + tr.getId());
        for (TextLineType lt : lines) {
            TrpTextLineType l = (TrpTextLineType) lt;
            // java.awt.Rectangle lineRect = PageXmlUtils.buildPolygon(l.getCoords().getPoints()).getBounds();
            // compute rotation of text, if rotation higher PI/16 than rotate otherwise even text
            TrpBaselineType baseline = (TrpBaselineType) l.getBaseline();
            double rotation = (baseline != null ? computeRotation(baseline) : 0);
            // if (lineRect.height > 0){
            // float lineHeight = lineRect.height /3;
            // 
            // logger.debug("line height: "+ lineHeight);
            // 
            // //ignore actual lineHeigth if three times the size of the actual line mean heigth
            // if (!(lineHeight > lineMeanHeight*4) || lineMeanHeight == 0){
            // //calculate line mean Height
            // lineMeanHeight = (lineMeanHeight == 0 ? lineHeight : (lineMeanHeight + lineHeight)/2);
            // logger.debug("lineMeanHeight: "+ lineMeanHeight);
            // }
            // }
            // get the mean baseline y-value
            baseLineMeanYPrev = baseLineMeanY;
            if (baseline != null) {
                // use lowest point in baseline and move up one half of the distance to the topmost point
                java.awt.Rectangle baseLineRect = l.getBoundingBox();
                baseLineMeanY = baseLineRect.getMaxY() - ((baseLineRect.getMaxY() - baseLineRect.getMinY()) / 2);
                if (baseLineMeanYPrev != 0) {
                    baseLineMeanGap = baseLineMeanY - baseLineMeanYPrev;
                }
            }
            boolean rtl = false;
            if ((l.getUnicodeText().isEmpty() || useWordLevel) && !l.getWord().isEmpty()) {
                List<WordType> words = l.getWord();
                for (WordType wt : words) {
                    TrpWordType w = (TrpWordType) wt;
                    if (!w.getUnicodeText().isEmpty()) {
                        // java.awt.Rectangle boundRect = PageXmlUtils.buildPolygon(w.getCoords()).getBounds();
                        java.awt.Rectangle boundRect = w.getBoundingBox();
                        String text = w.getUnicodeText();
                        rtl = textIsRTL(text.trim());
                        addString(boundRect, baseLineMeanY, text, cb, cutoffLeft, cutoffTop, bf, rotation, rtl);
                    } else {
                    // logger.info("No text content in word: " + w.getId());
                    }
                }
            } else if (!l.getUnicodeText().isEmpty()) {
                String lineTextTmp = l.getUnicodeText();
                // get surrounding rectangle coords of this line
                java.awt.Rectangle boundRect = l.getBoundingBox();
                Set<Entry<CustomTag, String>> blackSet = ExportUtils.getAllTagsOfThisTypeForShapeElement(l, RegionTypeUtil.BLACKENING_REGION.toLowerCase()).entrySet();
                if (doBlackening && blackSet.size() > 0) {
                    // for all blackening regions replace text with ****
                    for (Map.Entry<CustomTag, String> currEntry : blackSet) {
                        if (!currEntry.getKey().isIndexed()) {
                            // logger.debug("line not indexed : " + lineTextTmp);
                            lineTextTmp = lineTextTmp.replaceAll(".", "*");
                        } else {
                            // logger.debug("lineText before blackened : " + lineTextTmp);
                            lineTextTmp = blackenString(currEntry, lineTextTmp);
                        // logger.debug("lineText after blackened : " + lineTextTmp);
                        }
                    }
                }
                rtl = textIsRTL(lineTextTmp.trim());
                addString(boundRect, baseLineMeanY, lineTextTmp, cb, cutoffLeft, cutoffTop, bf, rotation, rtl);
            /*
					 * highlight all tags of this text line if property is set
					 */
            // if (highlightTags){
            // highlightTagsForShape(l);
            // 
            // }
            } else {
            // logger.info("No text content in line: " + l.getId());
            }
            if (highlightTags) {
                if ((l.getUnicodeText().isEmpty() || useWordLevel) && !l.getWord().isEmpty()) {
                    List<WordType> words = l.getWord();
                    for (WordType wt : words) {
                        TrpWordType w = (TrpWordType) wt;
                        highlightTagsForShape(w, rtl, cache);
                    }
                } else {
                    highlightTagsForShape(l, rtl, cache);
                }
            }
        }
    }
}

Example 4 with WordType

use of eu.transkribus.core.model.beans.pagecontent.WordType in project TranskribusCore by Transkribus.

the class DocxBuilder method getFormattedTextForLineElement.

/*
 * was version before we esported tables too
 */
// private static void writeDocxForTranscript(MainDocumentPart mdp, TrpPageType trpPage,
// boolean wordBased, boolean preserveLineBreaks) {
// boolean rtl = false;
// 
// List<TrpTextRegionType> textRegions = trpPage.getTextRegions(true);
// 
// for (int j=0; j<textRegions.size(); ++j) {
// TrpTextRegionType r = textRegions.get(j);
// 
// 
// //			if (exportTags){
// //				getTagsForShapeElement(r);
// //			}
// 
// /*
// * create one paragraph for each text region
// * but only if there is some text in it
// */
// String helper = r.getUnicodeText().replaceAll("\n", "");
// 
// //logger.debug("region unicode text " + helper);
// 
// if (!helper.equals("")){
// 
// org.docx4j.wml.P  p = factory.createP();
// mdp.addObject(p);
// 
// List<TextLineType> lines = r.getTextLine();
// for (int i=0; i<lines.size(); ++i) {
// TrpTextLineType trpL = (TrpTextLineType) lines.get(i);
// 
// try {
// if (wordBased && trpL.getWord().size()>0){
// getFormattedTextForLineElement(trpL.getWord(), p, mdp);
// }
// else {
// getFormattedTextForShapeElement(trpL, p, mdp);
// 
// }
// 
// } catch (Exception e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// 
// /*add line break after each text line
// * or omit this if explicitely wished to have dense lines
// * No line break at end of paragraph
// */
// if (preserveLineBreaks && !(i+1==lines.size()) ){
// Br br = factory.createBr(); // this Br element is used break the current and go for next line
// p.getContent().add(br);
// }
// 
// 
// }
// //
// //				linesTexts[i] = ((trpL.getUnicodeText().equals("") || wordBased) && trpL.getWord().size()>0) ? getRtfTextForLineFromWords(trpL) : getRtfTextForShapeElement(trpL);
// //				linesTexts[i] = RtfText.text(linesTexts[i], "\n");
// }
// 
// }
// 
// }
private static void getFormattedTextForLineElement(List<WordType> words, P p, MainDocumentPart mdp) throws Exception {
    int wordCount = 0;
    int nrWords = words.size();
    for (WordType word : words) {
        getFormattedTextForShapeElement((ITrpShapeType) word, p, mdp);
        // add empty space after each word
        if (wordCount < nrWords - 1) {
            org.docx4j.wml.Text t = factory.createText();
            t.setValue(" ");
            t.setSpace("preserve");
            org.docx4j.wml.R run = factory.createR();
            p.getContent().add(run);
            run.getContent().add(t);
        }
        wordCount++;
    }
}

Example 5 with WordType

use of eu.transkribus.core.model.beans.pagecontent.WordType in project TranskribusCore by Transkribus.

the class TrpTextLineType method clearTextForAllWords.

public void clearTextForAllWords(Object who) {
    for (WordType w : getWord()) {
        TrpWordType tw = (TrpWordType) w;
        tw.setUnicodeText("", who);
    }
// applyTextFromWords();
}