tiffTools.py

#!/usr/bin/env python3

# TIFF tools utilizing paps, gs, convert, tiffset, Pillow (PIL) and more
#
# by Magnetic-Fox, 19.04.2025 - 07.09.2026
#
# (C)2025-2026 Bartłomiej "Magnetic-Fox" Węgrzyn

import os
import io
import math
import shutil
import tempfile
import subprocess
import PIL.Image


# Get image size function
def getImageSize(imageData):
	img = PIL.Image.open(io.BytesIO(imageData))
	width = img.width
	height = img.height
	img.close()
	return width, height

# Function for gathering image count in one file
def getImageCount(filename):
	img = PIL.Image.open(filename)
	imgCount = img.n_frames
	img.close()
	return imgCount

# Image data to non-G3 TIFF data converter
def imageDataToTIFF(imageData, pageWidth = 1728, marginLeft = 32, marginRight = 32):
	# Get image size to test if image has to be rotated
	width, height = getImageSize(imageData)

	# Prepare command
	convertCommand = ["convert", "-"]

	# Set to rotate if needed
	if width > height:
		convertCommand += ["-rotate", "90"]

	# Below should give such result for resize (on default values): 1664x
	convertCommand += ["-resize", str(pageWidth - marginLeft - marginRight) + "x"]
	convertCommand += ["-background", "white", "-alpha", "remove", "-gravity", "northwest", "-splice", str(marginLeft) + "x0"]
	convertCommand += ["-background", "white", "-alpha", "remove", "-gravity", "northeast", "-splice", str(marginRight) + "x0"]
	convertCommand += ["tiff:-"]

	# Convert images to TIFFs with auto-size and auto-margin
	convert = subprocess.Popen(convertCommand, stdin = subprocess.PIPE, stdout = subprocess.PIPE)

	return convert.communicate(imageData)[0]

# Image file to non-G3 TIFF file converter (wrapper)
def imageToTIFF(imageFileName, tiffFileName, pageWidth = 1728, marginLeft = 32, marginRight = 32):
	imageFile = open(imageFileName, "rb")
	imageData = imageFile.read()
	imageFile.close()

	tiffData = imageDataToTIFF(imageData, pageWidth, marginLeft, marginRight)

	tiffFile = open(tiffFileName, "wb")
	tiffFile.write(tiffData)
	tiffFile.close()

	return

# Text to TIFF renderer (0 - standard resolution, 1 - fine resolution, 2 - super fine resolution)
#
# Default bottom margin value explanation:
# 141 PS points of bottom margin were chosen to achieve 2000 px height for image after cutting
# using cutter procedure (which has its default bottom margin set to 94 pixels).
#
# Why?
# 196 pixels per inch is the base document vertical resolution for G3 fax produced by GhostScript.
# 1 PostScript point is 1/72 inch, which means that 72 PostScript points gives us 196 pixels.
# Default page height for 196 DPI is 2289 pixels, which gives us 289 too much (we want 2000).
# Cutter utility needs additional 94 pixels to provide default bottom margin, so we need to add this too.
# Now: 289 + 94 (default from cutter) gives us 383 pixels we want out.
# This gives us such formula: bottomMargin = (72 * 383) / 196, which we have to ceil (to not exceed 2000 pixels!)
#
# Why 2000 pixels?
# That's because mgetty-fax will automatically scale images that exceeds such height.
# I just wanted to avoid it. ;)
def textToTIFF(tiffFileName, textData, resolution = 1, fontNameAndSize = "Monospace 10", topMargin = 6, bottomMargin = 141):
	# Prepare paps and gs commands
	papsCommand = ["paps", "--font=" + fontNameAndSize, "--top-margin=" + str(topMargin), "--bottom-margin=" + str(bottomMargin)]
	ghscCommand = ["gs", "-sDEVICE=tiffg3"]

	# Super fine resolution
	if resolution == 2:
		ghscCommand += ["-r204x391"]

	# Fine resolution ("normal"); use also for standard (98 dpi) resolution
	else:
		ghscCommand += ["-r204x196"]

	ghscCommand += ["-sOutputFile=" + tiffFileName, "-dBATCH", "-dNOPAUSE", "-dSAFER", "-dQUIET", "-"]

	# Create processes
	paps = subprocess.Popen(papsCommand, stdin = subprocess.PIPE, stdout = subprocess.PIPE)
	ghsc = subprocess.Popen(ghscCommand, stdin = subprocess.PIPE)

	# Pass text (encoded to the bytes type) to paps command and pass got postscript to gs command
	postScript = paps.communicate(textData.encode())[0]
	ghsc.communicate(postScript)

	# Standard resolution resize (196 dpi -> 98 dpi)
	if resolution == 0:
		resizeAndApplyResolution(tiffFileName, resolution)

	return

# Text file to TIFF renderer (wrapper)
def textFileToTIFF(tiffFileName, textFileName, resolution = 1, fontNameAndSize = "Monospace 10", topMargin = 6, bottomMargin = 141):
	textFile = open(textFileName, "r")
	textToTIFF(tiffFileName, textFile.read(), resolution, fontNameAndSize, topMargin, bottomMargin)
	textFile.close()
	return

# Resizer and DPI information applier (0 - standard resolution, 1 - fine resolution, 2 - super fine resolution)
def resizeAndApplyResolution(tiffFileName, resolution):
	# Prepare main convert and tiffset commands
	convertCommand = ["convert", tiffFileName]
	tiffSetCommand = ["tiffset", "-s", "283"]

	# Standard resolution - shrink image vertically (0.5x) and set vertical DPI to 98
	if resolution == 0:
		convertCommand += ["-resize", "100%x50%"]
		tiffSetCommand += ["98.0"]

	# Super fine resolution - enlarge image vertically (2x) and set vertival DPI to 391
	elif resolution == 2:
		convertCommand += ["-resize", "100%x200%"]
		tiffSetCommand += ["391.0"]

	# Fine resolution - no resize, but set vertical DPI to 196
	else:
		# Resizing not needed, so no convert command
		tiffSetCommand += ["196.0"]

	# Add TIFF file name to the both commands
	convertCommand += [tiffFileName]
	tiffSetCommand += [tiffFileName]

	# Additional tiffsets before the main part (make space for DPI information and set horizontal DPI to 204)
	subprocess.run(["tiffset", "-s", "296", "2", tiffFileName])
	subprocess.run(["tiffset", "-s", "282", "204.0", tiffFileName])

	# Resize TIFF
	if resolution != 1:
		subprocess.run(convertCommand)

	# Apply vertical DPI information
	subprocess.run(tiffSetCommand)

	return

# Function for applying DPI information to the TIFF file (0 - standard, 1 - fine, 2 - super fine)
def applyDPIInformation(tiffFileName, resolution = 1):
	# Prepare main tiffset command
	tiffSetCommand = ["tiffset", "-s", "283"]

	# Standard resolution
	if resolution == 0:
		tiffSetCommand += ["98.0"]

	# Super fine resolution
	elif resolution == 2:
		tiffSetCommand += ["391.0"]

	# Fine resolution
	else:
		tiffSetCommand += ["196.0"]

	# Add file name
	tiffSetCommand += [tiffFileName]

	# Additional tiffsets before the main part (make space for DPI information and set horizontal DPI to 204)
	subprocess.run(["tiffset", "-s", "296", "2", tiffFileName])
	subprocess.run(["tiffset", "-s", "282", "204.0", tiffFileName])

	# Main tiffset
	subprocess.run(tiffSetCommand)

	return

# Geometry recalculation function
def recalculateGeometry(geometryData, resolution = 1):
	# Unpack geometry data
	geometryData = geometryData.split("+")[1:]

	geometryData[0] = int(geometryData[0])
	geometryData[1] = int(geometryData[1])

	# Recalculate
	if resolution == 0:
		geometryData[1] = math.ceil(geometryData[1] / 2)

	elif resolution == 2:
		geometryData[1] *= 2

	# Combine and return geometry information
	return "+" + str(geometryData[0]) + "+" + str(geometryData[1])

# Scale (non-interpolated resize) fine image data to chosen resolution
def scaleToResolution(inputData, resolution):
	# To standard resolution
	if resolution == 0:
		return subprocess.Popen(["convert", "-", "-scale", "100%x50%", "-"], stdin = subprocess.PIPE, stdout = subprocess.PIPE).communicate(inputData)[0]

	# To super fine resolution
	elif resolution == 2:
		return subprocess.Popen(["convert", "-", "-scale", "100%x200%", "-"], stdin = subprocess.PIPE, stdout = subprocess.PIPE).communicate(inputData)[0]

	# To fine resolution
	else:
		# No conversion at all
		return inputData

# Picture place function
def placePicture(inputFileName, outputFileName, pictureToPlaceData, pictureToPlacePosition, pictureToPlaceGeometry):
	convertCommand = [	"convert", inputFileName,
				"-", "-gravity", pictureToPlacePosition, "-geometry", pictureToPlaceGeometry, "-composite",
				outputFileName	]

	convert = subprocess.Popen(convertCommand, stdin = subprocess.PIPE)
	convert.communicate(pictureToPlaceData)

	return

# Picture place function (file-only version)
def placePictureFile(inputFileName, outputFileName, pictureToPlaceFile, pictureToPlacePosition, pictureToPlaceGeometry):
	convertCommand = [	"convert", inputFileName,
				pictureToPlaceFile, "-gravity", pictureToPlacePosition, "-geometry", pictureToPlaceGeometry, "-composite",
				outputFileName	]

	subprocess.run(convertCommand)

	return

# TIFF to G3 converter
def TIFFtoG3(tiffFile, G3File):
	g3file = open(G3File, "wb")

	tifftopnm = subprocess.Popen(["tifftopnm", tiffFile], stdout = subprocess.PIPE)
	pgmtopbm = subprocess.Popen(["pgmtopbm"], stdin = tifftopnm.stdout, stdout = subprocess.PIPE)
	pbm2g3 = subprocess.run(["pbm2g3"], stdin = pgmtopbm.stdout, stdout = g3file)

	g3file.close()

	return

# Note for imageToG3TIFF - why default page height is 2000 pixels?
# It's because of MGetty's internal height value. If the image is less or equal 2000 pixels,
# then it won't be scaled, which of course means best possible quality while sending fax.

# Image data to G3 TIFF file converter (resolution data to apply: 0 - standard, 1 - fine, 2 - super fine)
def imageToG3TIFF(imageData, tiffFileName, resolution = 1, pageWidth = 1728, pageHeight = 2000, marginLeft = 32, marginRight = 32):
	# Initial convert (with rotation)
	nonG3TIFFData = imageDataToTIFF(imageData, pageWidth, marginLeft, marginRight)

	# Get converted image size
	width, height = getImageSize(nonG3TIFFData)

	# If image height is greater than chosen page height, then resize it and center (keep page width)
	if height > pageHeight:
		convertCommand = [	"convert", "-",
					"-background", "white",
					"-alpha", "remove",
					"-resize", "x" + str(pageHeight),
					"-gravity", "center",
					"-extent", str(pageWidth) + "x",
					"pnm:-"	]

		convert = subprocess.Popen(convertCommand, stdin = subprocess.PIPE, stdout = subprocess.PIPE)
		pnmData = convert.communicate(nonG3TIFFData)[0]

	# If image height is less or equal chosen page height, just convert it to the PNM format
	else:
		convertCommand = [	"convert", "-",
					"-background", "white",
					"-alpha", "remove",
					"pnm:-"	]
		convert = subprocess.Popen(convertCommand, stdin = subprocess.PIPE, stdout = subprocess.PIPE)
		pnmData = convert.communicate(nonG3TIFFData)[0]

	# Convert PNM data to PBM
	ppmtopgmCommand = ["ppmtopgm"]
	pgmtopbmCommand = ["pgmtopbm"]

	ppmtopgm = subprocess.Popen(ppmtopgmCommand, stdin = subprocess.PIPE, stdout = subprocess.PIPE)
	pgmtopbm = subprocess.Popen(pgmtopbmCommand, stdin = subprocess.PIPE, stdout = subprocess.PIPE)

	pgmData = ppmtopgm.communicate(pnmData)[0]
	pbmData = pgmtopbm.communicate(pgmData)[0]

	# Open file to save G3 TIFF data
	tiffFile = open(tiffFileName, "wb")

	# Convert PBM to G3 TIFF
	pnmtotiffCommand = ["pnmtotiff", "-g3"]
	pnmtotiff = subprocess.Popen(pnmtotiffCommand, stdin = subprocess.PIPE, stdout = tiffFile)
	pnmtotiff.communicate(pbmData)

	# Close file
	tiffFile.close()

	# Apply DPI information to the TIFF file
	applyDPIInformation(tiffFileName, resolution)

	return

# Image file to G3 TIFF file converter (wrapper)
def imageFileToG3TIFF(imageFileName, tiffFileName, resolution = 1, pageWidth = 1728, pageHeight = 2000, marginLeft = 32, marginRight = 32):
	imageFile = open(imageFileName, "rb")
	imageData = imageFile.read()
	imageFile.close()
	imageToG3TIFF(imageData, tiffFileName, resolution, pageWidth, pageHeight, marginLeft, marginRight)
	return

# Function for unpacking multipage TIFF files and place them in the current working directory
def unpackMultipageTIFF(filename, toFile = False, counter = 1):
	newFileList = []
	tiffList = []

	try:
		# Prepare another temporary directory and change directory to it
		oldDir = os.getcwd()
		dir = tempfile.TemporaryDirectory()
		os.chdir(dir.name)

		# Split TIFF image
		tiffSplitCommand = ["tiffsplit", filename]
		subprocess.run(tiffSplitCommand)

		# Get and sort single TIFF files
		fileList = os.listdir(".")
		fileList.sort()

		# If chosen to export to files, then move unpacked TIFFs to to current working directory
		if toFile:
			# Rename files according to the counter and move to the main temporary directory
			for file in fileList:
				shutil.move(file, oldDir + "/" + str(counter) + ".tiff")
				newFileList += [str(counter) + ".tiff"]
				counter += 1

		# Otherwise
		else:
			# Read all files to the memory (do not move)
			for file in fileList:
				tiffFile = open(file, "rb")
				tiffList += [tiffFile.read()]
				tiffFile.close()

	finally:
		# Change back directory and clean up temporary directory
		os.chdir(oldDir)
		dir.cleanup()

	# If chosen to export to files
	if toFile:
		# Return list of additional files
		return newFileList

	# Otherwise
	else:
		# Return list of TIFF files data
		return tiffList