Recreating texts in a new pdf with the same font and size

[ayusonkj]

Hi,
its me again, this time, I am working with fonts this time.
So here is the idea, I have a pdf file filled with texts that I will be converting per line to an svg file.
I want to re-create the whole texts exactly how it was originally written.

I have the following code snippet to do this:

def text_to_svg() :

    doc = fitz.open('JP_sample.pdf')
    for pdx, page in enumerate(doc):
         <code to get text information>

            x0, y0, x1, y1 = tuple(span.get('bbox'))
            rect = fitz.Rect(x0, y0, x1, y1)
            text=span.get('text').strip()
            font=span.get('font')
            font_size=span.get('size'),
            rect=rect.round()
            print(f"{SvgOut}: Textblock{rect, text, font_size, font}")
        
           ### temporary work around in case the given font is not available.
            if font in font_dic:
                print(f"Installing {font} from {font_dic.get(font)}")
                page.insert_font(fontname=font, fontfile=font_dic.get(font))
                page.insert_textbox(rect, text, fontsize=font_size[0],fontname=font)
            else:
                print(f"font: {font} is NA. using default times-roman")
                page.insert_textbox(rect, text, fontsize=font_size[0],fontname='times-roman')
          <code here to convert pdf to svg>


def export_font(doc, page):

    xref_visited = []
    font_dic = {}
    pprint(doc.get_page_fonts(0))
    for f in page.get_fonts():
        xref = f[0]

        if xref in xref_visited:
            continue

        xref_visited.append(xref)
        base_name, ext, _, buffer = doc.extract_font(xref)
        print(base_name, ext)
        if ext != 'n/a':
            font_name = f'fonts/{base_name}.{ext}'
            with open(font_name, 'wb') as file:
                file.write(buffer)
            base_font_name = base_name.split('+',1)[1]
            font_dic.update({base_font_name: font_name})

    return font_dic

the list of returned fonts are as follows:

[(5, 'ttf', 'Type0', 'BCDEEE+MS-Gothic', 'F1', 'Identity-H'),
 (12, 'ttf', 'TrueType', 'BCDFEE+MS-Gothic', 'F2', 'WinAnsiEncoding'),
 (14, 'ttf', 'TrueType', 'BCDGEE+Calibri', 'F3', 'WinAnsiEncoding'),
 (16, 'n/a', 'TrueType', 'TimesNewRomanPSMT', 'F4', 'WinAnsiEncoding')]

The question is:

1. seeing that the "TimesNewRomanPSMT" is "n/a" is there any way that I can use this font given that it is "n/a"
2. if the font is already system-built/ available in the system, is there anyway I can use the font using the extracted "base_name" information?
3. I tried to refrence the fontnames that I extracted in "page.getFontList()" so, I have references such as "F1", "F2" and so on.
   it just gives me RuntimeError: FT_New_Memory_Face((null)): unknown file format

Here is the pdf file used as reference:
jp_sample.pdf

thanks for the help as always

[JorjMcKie]

The "n/a" fonts refer to fonts which are expected to be supported by all PDF viewers natively, i.e they all must have this support built in. This usually applies to the Base-14 and some CJK fonts.
At least for the Base-14 fonts, there exist embeddable / file-based alternatives that look exactly alike. MuPDF installation material contains them as CFF files in their folder mupdf/resources/fonts/urw. You can install those in your OS.
PyMuPDF supports them too, when you use the TextWriter class. Because of their appearance equality, I have called the font "code" that refers to them with the same names ("helv", "tiro", "cour", etc.).
For SVG, I guess you must use a fontname that enables SVG document consumers to find the correspondingly installed font of the local machine. For example to support the identical-looking file-based Times Roman alternative, look for file NimbusRoman-Regular.cff.
I am not sure what happens on each OS when installing this fontfile, and which name must be used in SVG to refer to it: Times-Roman or NimbusRoman-Regular.
With PyMuPDF, upon outputting TextWriter text, in PDF you will find both names ("Times-Roman" and "NimbusRoman-Regular") in the various objects created in response to using the font file:

5 0 obj
<<
  /Type /Font
  /Subtype /Type0
  /BaseFont /Times-Roman  % <===
  /Encoding /Identity-H
  /ToUnicode 6 0 R
  /DescendantFonts [ 10 0 R ]
>>
endobj
...
8 0 obj
<<
  /Type /FontDescriptor
  /FontName /Times-Roman  % <===
  /FontBBox [ -168 -281 1000 1053 ]
  /ItalicAngle 0
  /Ascent 1053
  /Descent -281
  /StemV 80
  /Flags 32
  /FontFile3 7 0 R
>>
endobj
...
10 0 obj
<<
  /Type /Font
  /Subtype /CIDFontType0
  /CIDSystemInfo <<
    /Registry (Adobe)
    /Ordering (Identity)
    /Supplement 0
  >>
  /BaseFont /NimbusRoman-Regular  % <===
  /FontDescriptor 8 0 R
  /W 9 0 R
>>
endobj
...

[ayusonkj]

Okay, thanks for the clarification for n/a so it means that the file is 'non-embedded'. if this is the case, How can I use the information from the output of page.get_font():

(16, 'n/a', 'TrueType', 'TimesNewRomanPSMT', 'F4', 'WinAnsiEncoding', 0)

and write a text in a new page with the same font?
I tried referencing it to something like #page.insert_textbox(rect, text, fontsize=font_size[0],fontname="F4") bit it just gives me a unknown file format error

[JorjMcKie]

If you use the "old" text output methods page.insert_text / page.insert_textbox, you must include some logic that translates "TimesNewRomanPSMT" into "tiro" and then use page.insert_textbox(rect, text, fontsize=font_size[0],fontname="tiro").
This will then again produce the (almost) same font definition on output as the original.

If using TextWriter, you also must use your wits to come up with "tiro" to define tiro=fitz.Font("tiro"). This then leads to the embedded fontfile as explained above. Outputting textboxes in this case would look like tw.fill_textbox(rect, text, pos=None, font=tiro, fontsize=...).

[ayusonkj]

so there is no direct way to do this? where I can just reference the output of the page.get_font and use that immeidately to `page.insert_text()?

if that was the case, I was just thinking that, the best way I could do this is just create a default dictionary for all not embedded fonts where:
{"TimesNewRomanPSMT": "tiro"}

[JorjMcKie]

Probably, yes.
But there is no way to backport this to PyMuPDF, because (1) there is a large variety for how these names could be built (and I don't like the idea to hunting them all down), and (2) we must not forget that Type 3 fonts also are "n/a" and there is no recognizable BaseName.
Type 3 fonts cannot be reproduced at all ...

[JorjMcKie]

BTW any specific reason why you use JSON as the text extraction format?
It is just a json.dumps() of the get_text("dict") variant. So if you dont intend to output JSON to some text file, it would be nothing than a performance hog.

[JorjMcKie]

The requirement for PDF viewers to reproduce the appearance of Base-14 fonts in exactly the same way is in reality an illusion. There are differences.
Especially when it comes to supporting Symbol and ZapfDingbats. Also your example font is - strictly speaking - incorrectly specified: "TrueType" fonts should be built based on font programs that are embedded in the PDF, so should not be "n/a".
There exist a plethora of synonyms for each of the Times, Helvetica and Courier Base-14 fonts, including Arial, Times-Roman, Book Antiqua, Times-New-Roman, with all sorts of suffixes, with and without dashes or spaces, etc.
Additional complications arise from the italic and bold variants of each of them: these indicators can be present within the basename, separated by spaces or dashes or as suffixes separated by a comma, ...

[ayusonkj]

Thanks for the insight @JorjMcKie , as for your question on json.dumps, yeah, I am using this approach because I am storing the extracted text somewhere.

The end goal of the approach that I am going for is just to write the text with the same font and size in a new page, so that I could run the program to convert that page into an svg file. and voila! i have a text that is in svg format.

looks like, with embedded and Type3, this is gonna be more complicated than Just simply extracting and installing the required fonts.

[ayusonkj]

Just another follow up question, Is it possible to copy the page information/font references to a new page so that I could reference it the new page that I am working on?
Something like:

1. get font information
2. extract font information
3. copy font information to new page
4. insert text and reference the font in the new page.
5. save changes in new page.

so the output will be an almost identical new page without the vector drawings/images while maintaining the font, font size of the texts.

[JorjMcKie]

I think all your motivation/intent is covered here: #1527.

[ayusonkj]

Hi @JorjMcKie, Apologies as I was not able to follow up last week, I was on vacation :D
Anyways, The link that you have sent me was not exactly what I want but it was able to point me to the righ direction.
Using the link as reference, I got the idea that instead of re-writing the text in a new document, I Just need to access the pdf document and update the content stream by removing things that I don't need suchs as vector and Image related operands using the adobe reference Document.

I proceeded with something like this:

                    (
                            b"f*",
                            b"S",
                            b"s",
                            b"f",
                            b"F",
                            b"B",
                            b"b",
                            b"b*",
                            b"Do",
                            b"m",
                            b"l"
                    )

and change those instructions to something like lines[i] = b""

cheers! 👍