def test_write_document(self):
# create output directory if it does not exist yet
if not self.output_dir.exists():
self.output_dir.mkdir()
# create document
pdf = Document()
# add page
page = Page()
pdf.append_page(page)
Paragraph(
"Once upon a midnight dreary, while I pondered weak and weary, over many a quaint and curious volume of forgotten lore",
font_size=Decimal(20),
horizontal_alignment=Alignment.RIGHT,
).layout(
page,
Rectangle(Decimal(20), Decimal(600), Decimal(500), Decimal(124)),
)
# add rectangle annotation
page.append_square_annotation(
stroke_color=X11Color("Red"),
rectangle=Rectangle(Decimal(20), Decimal(600), Decimal(500),
Decimal(124)),
)
# determine output location
out_file = self.output_dir / "output.pdf"
# attempt to store PDF
with open(out_file, "wb") as in_file_handle:
PDF.dumps(in_file_handle, pdf)
def _calculate_layout_box(self, page: Page,
bounding_box: Rectangle) -> Rectangle:
# modify bounding box (to take into account padding)
modified_bounding_box = Rectangle(
bounding_box.x + self.padding_left,
bounding_box.y + self.padding_bottom,
max(bounding_box.width - self.padding_right - self.padding_left,
Decimal(0)),
max(bounding_box.height - self.padding_top - self.padding_bottom,
Decimal(0)),
)
# delegate
layout_rect = self._calculate_layout_box_without_padding(
page, modified_bounding_box)
# modify rectangle (to take into account padding)
modified_layout_rect = Rectangle(
layout_rect.x - self.padding_left,
layout_rect.y - self.padding_bottom,
layout_rect.width + self.padding_left + self.padding_right,
layout_rect.height + self.padding_top + self.padding_bottom,
)
# return
return modified_layout_rect
def _do_layout(self, page: Page, layout_box: Rectangle) -> Rectangle:
# modify bounding box (to take into account padding)
modified_bounding_box = Rectangle(
layout_box.x + self.padding_left,
layout_box.y + self.padding_bottom,
max(layout_box.width - self.padding_right - self.padding_left,
Decimal(0)),
max(layout_box.height - self.padding_top - self.padding_bottom,
Decimal(0)),
)
# delegate
output_box = self._do_layout_without_padding(page,
modified_bounding_box)
# modify rectangle (to take into account padding)
modified_layout_rect = Rectangle(
output_box.x - self.padding_left,
output_box.y - self.padding_bottom,
output_box.width + self.padding_left + self.padding_right,
output_box.height + self.padding_top + self.padding_bottom,
)
# draw border
self._draw_border(page, modified_layout_rect)
# return
return modified_layout_rect
def split_on_glyphs(self) -> typing.List["ChunkOfTextRenderEvent"]:
"""
This function splits this ChunkOfTextRenderEvent on every Glyph
"""
chunks_of_text: typing.List[ChunkOfTextRenderEvent] = []
x: Decimal = Decimal(0)
y: Decimal = self._graphics_state.text_rise
font: typing.Optional[Font] = self._graphics_state.font
assert font is not None
for g in self._glyph_line.split():
e = ChunkOfTextRenderEvent(self._graphics_state, String(" "))
e.font_size = self.font_size
e.font_color = self.font_color
e.font = self.font
e.text = g.get_text()
e._space_character_width_estimate = self._space_character_width_estimate
e._graphics_state = self._graphics_state
e._glyph_line = g
# set baseline bounding box
m = self._graphics_state.text_matrix.mul(self._graphics_state.ctm)
p0 = m.cross(x, y, Decimal(1))
p1 = m.cross(
x + g.get_width_in_text_space(),
y + font.get_ascent() * Decimal(0.001),
Decimal(1),
)
e.baseline_bounding_box = Rectangle(
p0[0], p0[1], p1[0] - p0[0], p1[1] - p0[1]
)
e.bounding_box = e.baseline_bounding_box
# change bounding box (descent)
if g.uses_descent():
p0 = m.cross(
x,
y + font.get_descent() * Decimal(0.001),
Decimal(1),
)
p1 = m.cross(
x + g.get_width_in_text_space(),
y + font.get_ascent() * Decimal(0.001),
Decimal(1),
)
e.bounding_box = Rectangle(
min(p0[0], p1[0]),
min(p0[1], p1[1]),
abs(p1[0] - p0[0]),
abs(p1[1] - p0[1]),
)
# update x
x += g.get_width_in_text_space()
# append
chunks_of_text.append(e)
return chunks_of_text
def _test_document(self, file):
# create output directory if it does not exist yet
if not self.output_dir.exists():
self.output_dir.mkdir()
# determine output location
out_file = self.output_dir / (file.stem + "_out.pdf")
# attempt to read PDF
doc = None
with open(file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle)
# determine free space
space_finder = FreeSpaceFinder(doc.get_page(0))
# debug purposes
if self.in_debug:
for i in range(0, len(space_finder.grid)):
for j in range(0, len(space_finder.grid[i])):
if space_finder.grid[i][j]:
continue
w = Decimal(space_finder.grid_resolution)
x = Decimal(i) * w
y = Decimal(j) * w
doc.get_page(0).append_square_annotation(
Rectangle(x, y, w, w), stroke_color=X11Color("Salmon"))
# add annotation
w, h = doc.get_page(0).get_page_info().get_size()
free_rect = space_finder.find_free_space(
Rectangle(
Decimal(w / Decimal(2)),
Decimal(h * Decimal(2)),
Decimal(64),
Decimal(64),
))
if free_rect is not None:
doc.get_page(0).append_square_annotation(
rectangle=free_rect,
stroke_color=HexColor("#F75C03"),
fill_color=HexColor("#04A777"),
)
# attempt to store PDF
with open(out_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(out_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
return True
def _do_layout_without_padding(self, page: Page, bounding_box: Rectangle):
# easy case
if len(self.text) == 0:
return Rectangle(bounding_box.x, bounding_box.y, Decimal(0), Decimal(0))
# other easy cases
lines_of_text = self._split_text(bounding_box)
if len(lines_of_text) == 0:
return Rectangle(bounding_box.x, bounding_box.y, Decimal(0), Decimal(0))
# separate method for the harder case of Alignment.JUSTIFIED
if self.text_alignment == Alignment.JUSTIFIED:
return self._do_layout_without_padding_text_alignment_justified(
lines_of_text, page, bounding_box
)
# delegate
min_x: Decimal = Decimal(2048)
min_y: Decimal = Decimal(2048)
max_x: Decimal = Decimal(0)
max_y: Decimal = Decimal(0)
leading: Decimal = self.font_size * Decimal(1.3)
for i, l in enumerate(lines_of_text):
r = LineOfText(
l,
font=self.font,
font_size=self.font_size,
font_color=self.font_color,
horizontal_alignment=self.text_alignment,
parent=self,
).layout(
page,
bounding_box=Rectangle(
bounding_box.x,
bounding_box.y + bounding_box.height - leading * i - self.font_size,
bounding_box.width,
self.font_size,
),
)
min_x = min(r.x, min_x)
min_y = min(r.y, min_y)
max_x = max(r.x + r.width, max_x)
max_y = max(r.y + r.height, max_y)
layout_rect = Rectangle(min_x, min_y, max_x - min_x, max_y - min_y)
# set bounding box
self.set_bounding_box(layout_rect)
# return
return layout_rect
def test_write_document(self):
# create output directory if it does not exist yet
if not self.output_dir.exists():
self.output_dir.mkdir()
# create document
pdf = Document()
# add page
page = Page()
pdf.append_page(page)
rs = []
for i, s in enumerate(
[
"Once upon a midnight dreary,",
"while I pondered weak and weary,",
"over many a quaint and curious",
"volume of forgotten lore",
]
):
r = LineOfText(
s,
font_size=Decimal(20),
horizontal_alignment=Alignment.CENTERED,
).layout(
page,
Rectangle(
Decimal(20), Decimal(724 - 24 * i), Decimal(500), Decimal(24)
),
)
rs.append(r)
# add rectangle annotation
page.append_square_annotation(
stroke_color=X11Color("Salmon"),
rectangle=Rectangle(
Decimal(20), Decimal(724 - 24 * 3), Decimal(500), Decimal(24 * 4)
),
)
# determine output location
out_file = self.output_dir / "output.pdf"
# attempt to store PDF
with open(out_file, "wb") as in_file_handle:
PDF.dumps(in_file_handle, pdf)
def test_document(self, file):
# create output directory if it does not exist yet
if not self.output_dir.exists():
self.output_dir.mkdir()
# determine output location
out_file = self.output_dir / (file.stem + "_out.pdf")
# attempt to read PDF
doc = None
with open(file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle)
# add annotation
doc.get_page(0).append_watermark_annotation(
contents="pText",
rectangle=Rectangle(Decimal(128), Decimal(128), Decimal(64),
Decimal(64)),
)
# attempt to store PDF
with open(out_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(out_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
def test_document(self, file):
# create output directory if it does not exist yet
if not self.output_dir.exists():
self.output_dir.mkdir()
# determine output location
out_file = self.output_dir / (file.stem + "_out.pdf")
# attempt to read PDF
doc = None
with open(file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle)
# add annotation
doc.get_page(0).append_polygon_annotation(
points=LineArtFactory.sticky_note(
Rectangle(Decimal(128), Decimal(128), Decimal(64),
Decimal(64))),
stroke_color=X11Color("PowderBlue"),
)
# attempt to store PDF
with open(out_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(out_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
return True
def test_add_polyline_annotation_using_lineart_factory(self):
# create output directory if it does not exist yet
if not self.output_file.parent.exists():
self.output_file.parent.mkdir()
# attempt to read PDF
doc = None
with open(self.input_file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle)
# add annotation
doc.get_page(0).append_polyline_annotation(
points=LineArtFactory.droplet(
Rectangle(Decimal(100), Decimal(100), Decimal(100),
Decimal(100))),
stroke_color=X11Color("Crimson"),
)
# attempt to store PDF
with open(self.output_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(self.output_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
return True
def test_add_circle_annotation(self):
# create output directory if it does not exist yet
if not self.output_file.parent.exists():
self.output_file.parent.mkdir()
# attempt to read PDF
doc = None
with open(self.input_file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle)
# add annotation
doc.get_page(0).append_circle_annotation(
rectangle=Rectangle(Decimal(128), Decimal(128), Decimal(64), Decimal(64)),
stroke_color=X11Color("Plum"),
fill_color=X11Color("Crimson"),
)
# attempt to store PDF
with open(self.output_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(self.output_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
return True
def test_write_document(self):
# create output directory if it does not exist yet
if not self.output_dir.exists():
self.output_dir.mkdir()
# create document
pdf = Document()
# add page
page = Page()
pdf.append_page(page)
ChunkOfText(
"é",
font_size=Decimal(24),
).layout(
page,
Rectangle(Decimal(100), Decimal(600), Decimal(100), Decimal(100)))
# determine output location
out_file = self.output_dir / "output.pdf"
# attempt to store PDF
with open(out_file, "wb") as in_file_handle:
PDF.dumps(in_file_handle, pdf)
# attempt to re-open PDF
with open(out_file, "rb") as in_file_handle:
PDF.loads(in_file_handle)
def test_document(self, file):
# create output directory if it does not exist yet
if not self.output_dir.exists():
self.output_dir.mkdir()
# determine output location
out_file = self.output_dir / (file.stem + "_out.pdf")
# attempt to read PDF
doc = None
with open(file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle)
# add annotation
doc.get_page(0).append_stamp_annotation(
name="Confidential",
contents="Approved by Joris Schellekens",
color=X11Color("White"),
rectangle=Rectangle(Decimal(128), Decimal(128), Decimal(64),
Decimal(32)),
)
# attempt to store PDF
with open(out_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(out_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
return True
def test_add_rubber_stamp_annotation(self):
# create output directory if it does not exist yet
if not self.output_file.parent.exists():
self.output_file.parent.mkdir()
# attempt to read PDF
doc = None
with open(self.input_file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle)
# add annotation
doc.get_page(0).append_stamp_annotation(
name=RubberStampAnnotationIconType.CONFIDENTIAL,
contents="Approved by Joris Schellekens",
color=X11Color("Red"),
rectangle=Rectangle(Decimal(128), Decimal(56), Decimal(132),
Decimal(58)),
)
# attempt to store PDF
with open(self.output_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(self.output_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
return True
def test_document(self, file):
# create output directory if it does not exist yet
if not self.output_dir.exists():
self.output_dir.mkdir()
# determine output location
out_file = self.output_dir / (file.stem + "_out.pdf")
# attempt to read PDF
doc = None
with open(file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle)
# add annotation
doc.get_page(0).append_square_annotation(
rectangle=Rectangle(Decimal(128), Decimal(128), Decimal(64), Decimal(64)),
stroke_color=HexColor("#F75C03"),
fill_color=HexColor("#04A777"),
)
# attempt to store PDF
with open(out_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(out_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
return True
def test_document(self, file):
# create output directory if it does not exist yet
if not self.output_dir.exists():
self.output_dir.mkdir()
# determine output location
out_file = self.output_dir / (file.stem + "_out.pdf")
# attempt to read PDF
doc = None
with open(file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle)
# add annotation
doc.get_page(0).append_redact_annotation(
overlay_text="Lorem Ipsum",
repeat_overlay_text=True,
fill_color=X11Color("AliceBlue"),
rectangle=Rectangle(Decimal(72.86), Decimal(486.82), Decimal(129),
Decimal(13)),
)
# attempt to store PDF
with open(out_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(out_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
return True
def get_bounding_box(self) -> Rectangle:
ls = self.get_baseline()
max_ascent = max([
x.get_font_ascent() * Decimal(0.001) * x.get_font_size()
for x in self.contained_events
])
return Rectangle(ls.x0, ls.y0, abs(ls.x1 - ls.x0), max_ascent)
def test_add_underline_annotation(self):
# create output directory if it does not exist yet
if not self.output_file.parent.exists():
self.output_file.parent.mkdir()
# attempt to read PDF
doc = None
with open(self.input_file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle)
# add annotation
doc.get_page(0).append_underline_annotation(
stroke_color=HexColor("CBEF43"),
rectangle=Rectangle(Decimal(72.86), Decimal(486.82), Decimal(129),
Decimal(13)),
)
# attempt to store PDF
with open(self.output_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(self.output_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
return True
def test_document(self, file):
# create output directory if it does not exist yet
if not self.output_dir.exists():
self.output_dir.mkdir()
# determine output location
out_file = self.output_dir / (file.stem + "_out.pdf")
# attempt to read PDF
doc = None
with open(file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle)
# add annotation
doc.get_page(0).append_text_annotation(
contents="The quick brown fox ate the lazy mouse",
rectangle=Rectangle(Decimal(128), Decimal(128), Decimal(64), Decimal(64)),
name_of_icon="Key",
open=True,
color=X11Color("Orange"),
)
# attempt to store PDF
with open(out_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(out_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
return True
def test_add_link_annotation(self):
# create output directory if it does not exist yet
if not self.output_file.parent.exists():
self.output_file.parent.mkdir()
# attempt to read PDF
doc = None
with open(self.input_file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle)
# add annotation
doc.get_page(0).append_link_annotation(
page=Decimal(0),
destination_type=DestinationType.FIT,
color=X11Color("Red"),
rectangle=Rectangle(Decimal(128), Decimal(128), Decimal(64), Decimal(64)),
)
# attempt to store PDF
with open(self.output_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(self.output_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
return True
def _do_layout_without_padding(self, page: Page,
bounding_box: Rectangle) -> Rectangle:
last_item_bottom: Decimal = bounding_box.y + bounding_box.height
bullet_margin: Decimal = Decimal(20)
for i in self.items:
# bullet character
ChunkOfText(
text=[
"l", "m", "n"
][self._determine_level(i) %
3], # this is 006C in MacRoman encoding, which maps to ● in Zapf Dingbats
font_size=Decimal(8),
font_color=X11Color("Black"),
font="Zapfdingbats",
).layout(
page=page,
bounding_box=Rectangle(
bounding_box.x,
bounding_box.y,
bullet_margin,
last_item_bottom - bounding_box.y,
),
)
# content
item_rect = i.layout(
page,
bounding_box=Rectangle(
bounding_box.x + bullet_margin,
bounding_box.y,
bounding_box.width - bullet_margin,
last_item_bottom - bounding_box.y,
),
)
# set new last_item_bottom
last_item_bottom = item_rect.y
layout_rect = Rectangle(
bounding_box.x,
last_item_bottom,
bounding_box.width,
bounding_box.y + bounding_box.height - last_item_bottom,
)
# set bounding box
self.set_bounding_box(layout_rect)
# return
return layout_rect
def _do_layout_without_padding(self, page: Page,
bounding_box: Rectangle) -> Rectangle:
last_item_bottom: Decimal = bounding_box.y + bounding_box.height
bullet_margin: Decimal = Decimal(20)
for index, i in enumerate(self.items):
# bullet character
ChunkOfText(
text=str(index + 1 + self.index_offset) + ".",
font_size=Decimal(12),
font_color=X11Color("Black"),
).layout(
page=page,
bounding_box=Rectangle(
bounding_box.x,
bounding_box.y,
bullet_margin,
last_item_bottom - bounding_box.y,
),
)
# content
item_rect = i.layout(
page,
bounding_box=Rectangle(
bounding_box.x + bullet_margin,
bounding_box.y,
bounding_box.width - bullet_margin,
last_item_bottom - bounding_box.y,
),
)
# set new last_item_bottom
last_item_bottom = item_rect.y
layout_rect = Rectangle(
bounding_box.x,
last_item_bottom,
bounding_box.width,
bounding_box.y + bounding_box.height - last_item_bottom,
)
# set bounding box
self.set_bounding_box(layout_rect)
# return
return layout_rect
def test_write_document(self):
# create output directory if it does not exist yet
if not self.output_dir.exists():
self.output_dir.mkdir()
# create document
pdf = Document()
# add page
page = Page()
pdf.append_page(page)
layout = SingleColumnLayout(page)
# title
layout.add(
Paragraph(
"Lissajours Line Art",
font_size=Decimal(20),
font_color=X11Color("Blue"),
))
# table
N = 7
fill_colors = [
HSVColor(Decimal(x / N), Decimal(1), Decimal(1))
for x in range(0, N)
]
stroke_colors = [HSVColor.darker(x) for x in fill_colors]
fixed_bb = Rectangle(Decimal(0), Decimal(0), Decimal(100),
Decimal(100))
t = Table(number_of_rows=N, number_of_columns=N)
for i in range(0, N):
for j in range(0, N):
t.add(
Shape(
LineArtFactory.lissajours(fixed_bb, i + 1, j + 1),
fill_color=fill_colors[(i + j) % N],
stroke_color=stroke_colors[(i + j) % N],
line_width=Decimal(2),
))
t.set_padding_on_all_cells(Decimal(10), Decimal(10), Decimal(10),
Decimal(10))
layout.add(t)
# determine output location
out_file = self.output_dir / ("output.pdf")
# attempt to store PDF
with open(out_file, "wb") as in_file_handle:
PDF.dumps(in_file_handle, pdf)
# attempt to re-open PDF
with open(out_file, "rb") as in_file_handle:
PDF.loads(in_file_handle)
def test_document(self, file):
# create output directory if it does not exist yet
if not self.output_dir.exists():
self.output_dir.mkdir()
# get text
txt_ground_truth_file = self.input_dir / (file.stem + ".txt")
txt_ground_truth = ""
with open(txt_ground_truth_file, "r") as txt_ground_truth_file_handle:
txt_ground_truth = txt_ground_truth_file_handle.read()
words = [x for x in re.split("[^a-zA-Z]+", txt_ground_truth) if len(x) > 5]
w = words[5] if len(words) > 5 else None
if w is None:
return True
# determine output location
out_file = self.output_dir / (file.stem + "_" + w + "_out.pdf")
# attempt to read PDF
doc = None
l = RegularExpressionTextExtraction(w)
with open(file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle, [l])
# add annotation
print(
"\tAdding %d annotations"
% len(l.get_matched_text_render_info_events_per_page(0))
)
for e in l.get_matched_text_render_info_events_per_page(0):
baseline = e.get_baseline()
doc.get_page(0).append_square_annotation(
rectangle=Rectangle(
Decimal(baseline.x0),
Decimal(baseline.y0 - 2),
Decimal(baseline.x1 - baseline.x0),
Decimal(12),
),
stroke_color=X11Color("Firebrick"),
)
# attempt to store PDF
with open(out_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(out_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
return True
def event_occurred(self, event: Event) -> None:
if isinstance(event, TextRenderEvent):
assert isinstance(event, TextRenderEvent)
space = Rectangle(
event.get_baseline().x0,
event.get_baseline().y0,
event.get_baseline().x1,
Decimal(12),
) # TODO: height
self._mark_as_unavailable(space)
def _do_layout_without_padding(
self, page: Page, bounding_box: Rectangle
) -> Rectangle:
# scale to fit
self.scale_down(bounding_box.width, bounding_box.height)
# translate points to fit in box
self.translate_to_align(
bounding_box.x, bounding_box.y + bounding_box.height - self.get_height()
)
# write content
stroke_rgb = (self.stroke_color or X11Color("Black")).to_rgb()
fill_rgb = (self.fill_color or X11Color("White")).to_rgb()
COLOR_MAX = Decimal(255.0)
content = "q %f %f %f RG %f %f %f rg %f w " % (
Decimal(stroke_rgb.red / COLOR_MAX),
Decimal(stroke_rgb.green / COLOR_MAX),
Decimal(stroke_rgb.blue / COLOR_MAX),
Decimal(fill_rgb.red / COLOR_MAX),
Decimal(fill_rgb.green / COLOR_MAX),
Decimal(fill_rgb.blue / COLOR_MAX),
self.line_width,
)
content += "%f %f m " % (self.points[0][0], self.points[0][1])
for p in self.points:
content += " %f %f l " % (p[0], p[1])
operator: str = "B"
if self.stroke_color is None:
operator = "F"
if self.fill_color is None:
operator = "S"
content += " %s " % operator
content += " Q"
# append to page
self._append_to_content_stream(page, content)
# calculate bounding box
layout_rect = Rectangle(
bounding_box.x,
bounding_box.y + bounding_box.height - self.get_height(),
self.get_width(),
self.get_height(),
)
# set bounding box
self.set_bounding_box(layout_rect)
# return
return layout_rect
def bounding_box(self, rectangles: typing.List[Rectangle]) -> Rectangle:
min_x: Decimal = rectangles[0].get_x()
min_y: Decimal = rectangles[1].get_y()
max_x: Decimal = rectangles[0].get_x() + rectangles[0].get_width()
max_y: Decimal = rectangles[1].get_y() + rectangles[0].get_height()
for r in rectangles:
min_x = min(min_x, r.get_x())
min_y = min(min_y, r.get_y())
max_x = max(max_x, r.get_x() + r.get_width())
max_y = max(max_y, r.get_y() + r.get_height())
w: Decimal = max_x - min_x
h: Decimal = max_y - min_y
return Rectangle(min_x, min_y, w, h)
def test_document(self, file):
# create output directory if it does not exist yet
if not self.output_dir.exists():
self.output_dir.mkdir()
# determine output location
out_file = self.output_dir / (file.stem + "_out.pdf")
# attempt to read PDF
doc = None
with open(file, "rb") as in_file_handle:
print("\treading (1) ..")
doc = PDF.loads(in_file_handle)
# add annotation
for index, name in enumerate([
"Approved",
"Experimental",
"NotApproved",
"Asis",
"Expired",
"NotForPublicRelease",
"Confidential",
"Final",
"Sold",
"Departmental",
"ForComment",
"TopSecret",
"Draft",
"ForPublicRelease",
]):
doc.get_page(0).append_stamp_annotation(
name=name,
contents="Approved by Joris Schellekens",
color=X11Color("White"),
rectangle=Rectangle(Decimal(128), Decimal(128 + index * 34),
Decimal(64), Decimal(32)),
)
# attempt to store PDF
with open(out_file, "wb") as out_file_handle:
print("\twriting ..")
PDF.dumps(out_file_handle, doc)
# attempt to re-open PDF
with open(out_file, "rb") as in_file_handle:
print("\treading (2) ..")
doc = PDF.loads(in_file_handle)
return True
def get_bounding_box(self) -> Rectangle:
assert isinstance(self.contained_events[0], LineRenderEvent)
assert isinstance(self.contained_events[-1], LineRenderEvent)
top = (self.contained_events[0].get_bounding_box().y +
self.contained_events[0].get_bounding_box().height)
btm = self.contained_events[-1].get_bounding_box().y
left = self.contained_events[0].get_bounding_box().x
right = self.contained_events[0].get_bounding_box().x
for e in self.contained_events:
assert isinstance(e, LineRenderEvent)
left = min(e.get_bounding_box().x, left)
right = min(e.get_bounding_box().x + e.get_bounding_box().width,
left)
return Rectangle(left, btm, (right - left), (top - btm))
def get_bounding_box(self) -> Rectangle:
top = (
self.contained_events[0].get_bounding_box().y
+ self.contained_events[0].get_bounding_box().height
)
btm = self.contained_events[-1].get_bounding_box().y
left = min([x.get_bounding_box().x for x in self.contained_events])
right = max(
[
x.get_bounding_box().x + x.get_bounding_box().width
for x in self.contained_events
]
)
return Rectangle(left, btm, (right - left), (top - btm))