Printhead Calculations

Pixel Pitch

$pixel_{Pitch} = \frac{25400\frac{\mu m}{inch}}{{Resolution}}$

$sub\_pixel_{Pitch} = \frac{25400\frac{\mu m}{inch}}{{Resolution*NbrOfSubpixels}}$


In [1]:
import numpy as np
resolutions    = [150, 360, 600, 1200, 2400, 4800] # dpi
inch2cm        = 2.54 # cm/inch
nbrOfSubpixels = 32

# Calulation Pixel Pinch
pixel_pitch = np.empty(shape=[len(resolutions)], dtype=np.float64) # um
for i in range(len(resolutions)):
  pixel_pitch[i] = (inch2cm/resolutions[i])*10000

# Calculation Subpixel Pinch
sub_pixel_pitch = np.empty(shape=[len(resolutions)], dtype=np.float64) # um
for i in range(len(resolutions)):
  sub_pixel_pitch[i] = pixel_pitch[i]/nbrOfSubpixels
  
for i in range(len(resolutions)):
  print("Resolution: {:4} dpi   Pixel Pitch: {} um   Sub Pixel Pitch: {} um".format(resolutions[i], pixel_pitch[i], sub_pixel_pitch[i]))


Resolution:  150 dpi   Pixel Pitch: 169.33333333333334 um   Sub Pixel Pitch: 5.291666666666667 um
Resolution:  360 dpi   Pixel Pitch: 70.55555555555556 um   Sub Pixel Pitch: 2.204861111111111 um
Resolution:  600 dpi   Pixel Pitch: 42.333333333333336 um   Sub Pixel Pitch: 1.3229166666666667 um
Resolution: 1200 dpi   Pixel Pitch: 21.166666666666668 um   Sub Pixel Pitch: 0.6614583333333334 um
Resolution: 2400 dpi   Pixel Pitch: 10.583333333333334 um   Sub Pixel Pitch: 0.3307291666666667 um
Resolution: 4800 dpi   Pixel Pitch: 5.291666666666667 um   Sub Pixel Pitch: 0.16536458333333334 um

Error in Pixel Pitch $\Delta x_{Pitch}$because of substrate speed and clock frequency $\Delta x_{Pitch} = v_{Substrate}∙\Delta t$

Error is the modulus of the achieved and the ideal pixel pitch. $e = Rest(\frac{pixel_{Pitch}}{\Delta x_{Raster}})$


In [2]:
import numpy as np
import pylab as pl
pl.clf()
frequencies = [50e6, 100e6, 150e6, 200e6] # MHz
speed = np.linspace(0,10,50) # 50 x points from 0m/s to 10m/s

for freq in frequencies:
  delta_x_pitch = (speed*100000) * 1/freq # um/s / s
  #error = numpy.mod(pixel_pitch[1],delta_x_pitch)
  # Plot graph  
  pl.plot(speed,delta_x_pitch,label=str(int(freq/1000000))+" MHz")

# Place legend, Axis and Title
pl.legend(loc='best')
pl.xlabel("Speed [m/s]")
pl.ylabel("$\Delta$ x_pitch or Error [um]")
pl.title("Pixel Pitch Errors @ {}dpi".format(resolutions[1]))


Out[2]:
Text(0.5,1,'Pixel Pitch Errors @ 360dpi')

Resolution


In [3]:
pixel_pitch = 0.1692 # mm
inch2cm = 2.54 # cm/inch
resolution = (inch2cm/pixel_pitch)*10
print("Resolution: {:4} dpi   Pixel Pitch: {} um".format(resolution, pixel_pitch))


Resolution: 150.1182033096927 dpi   Pixel Pitch: 0.1692 um

Stitching

For Steinemann machine (KonicaMinolta KM1024i)

$pixel_{overlap} = \frac{ph_{resolution}}{2.54\frac{cm}{inch}* ph_{overlapping}}$


In [4]:
ph_resolution  = 360   # dpi
inch2cm        = 2.54  # cm/inch
ph_overlapping = 0.196 # cm

pixel_overlap = ph_resolution / inch2cm * ph_overlapping

print("{} dots".format(pixel_overlap))


27.77952755905512 dots

Pixel distance

KonicaMinolta KM1024i & KM1024

$ pixel_{pitch} = \frac{25.4\frac{mm}{inch}}{ph_{resolution}} $

Printing Speed

$pixel_{pitch} = \frac{25.4\frac{mm}{inch}}{resolution_{ph}} = [mm]$

$freq_{adjusted} = \frac{freq_{ph}*percent_{speed}}{100} = [Hz]$

$speed = pixel_{pitch} * freq_{adjusted} * \frac{resolution_{ph}}{resolution_{job}} = [\frac{mm}{s}]$


In [5]:
resolution_job = 720  # dpi
resolution_ph  = 360  # dpi
f_ph           = 30e3 # Hz
speed_percent  = 100  # %
#-------------------------------------
inch2mm     = 25.4 # mm/inch
#-------------------------------------
pixel_pinch = inch2mm/resolution_ph          # (inch/mm)/(dot/inch) = mm/dot
adjusted_frequency = f_ph / 100 * speed_percent # Hz

speed = pixel_pinch * adjusted_frequency * resolution_ph/resolution_job # (mm/dot) * 1/s * (dot/inch)/(dot/inch) = mm/s

print("Pixel Pinch = {} mm".format(pixel_pinch))
print("Adjusted Frequency = {}% of {} Hz = {} Hz".format(speed_percent, f_ph, adjusted_frequency))

print("Speed = {} mm/s".format(speed))
print("Speed = {} m/s".format(speed/1000))


Pixel Pinch = 0.07055555555555555 mm
Adjusted Frequency = 100% of 30000.0 Hz = 30000.0 Hz
Speed = 1058.3333333333333 mm/s
Speed = 1.0583333333333333 m/s

Printing Dimensions

For calculating the Printing dimensions in x and y axis. The following values are needed.

  • section_witdh = Number of bytes of a section. Can be found in CoE Memory Organization 8040:1
  • section_depth = Number of bytes of a section. Can be found in CoE Memory Organization 8040:2
  • Number of sections = Number of bytes of a section. Can be found in CoE Memory Organization 8040:3
  • Number_of_channels = Equals number of colors per board
  • Resolution of the Printhead

$print_{width} = section_{width} * 2\frac{pixel}{byte} * \frac{0.0254\frac{m}{inch}}{ph_{dpi}} = [m]$

$print_{length} = section_{depth} * section_{numbers} * 2\frac{pixel}{byte} * \frac{0.0254\frac{m}{inch}}{ph_{dpi}} = [m]$


In [6]:
import math
def printing_dimensions(section_width, section_depth, section_numbers, number_of_channels, ph_dpi):
  """
  printing_dimensions calculates the printing width and length of a printhead with the available memory
  :param section_width      : (bytes^=pixel/channel) Can be found in CoE Memory Organization 8040:1
  :param section_depth      : (bytes => 1 byte=2 px) Can be found in CoE Memory Organization 8040:2
  :param section_numbers    : Can be found in CoE Memory Organization 8040:3
  :param number_of_channels : Equals number of colors per board
  :param ph_dpi             : Dpi of the printheads
  :return print_width       : height (cross print axis) in mm of the printable width per printhead
  :return print_length      : length (print axis) in mm of the printable job
  """
  # Constants
  inch2m     = 0.0254 # m/inch
  pixel_byte = 2      # pixel/byte
  
  # Calc Pixel Pitch
  pixel_pitch = inch2m/ph_dpi # in m
  
  # Calc Print width = Y Axis = Crossprint Axis
  section_width_pixel = section_width # this is already in bytes (1 byte = 1 px)
  print_width = section_width_pixel*pixel_pitch
  
  # Calc Print length = X Axis = Print Axis
  section_depth_pixel = section_depth * pixel_byte
  print_length = section_depth_pixel*section_numbers*pixel_pitch
  
  # Calc memory size
  memory_size_byte  = section_width*section_depth*section_numbers*number_of_channels
  memory_size_pixel = memory_size_byte * pixel_byte
  
  # Print
  print("Memory Size              : {} MBytes = {} MPixels".format((memory_size_byte/1000/1000), (memory_size_pixel/1000/1000)))
  print("PixelPitch @ {:3}dpi     : {} um".format(ph_dpi,pixel_pitch*1000*1000))
  print("Image width              : {} mm".format(print_width*1000))
  print("Print length             : {} m".format(print_length))
  
  # m_number_of_sections=MEMORY_SIZE/(Memory_Section::get_width()*Memory_Section::get_depth()*anheads);
  # m_memory_depth=m_number_of_sections*Memory_Section::get_depth();
  
  return print_width, print_length

def biggest_multipage_job(print_length, max_image_size):
  """
  calculates the max number of multipages in job with a given substratesize (max_image_size).
  :param print_length       : max length of the job according to printing_dimensions() return value
  :param max_image_size     : max size of one image
  :return nbr_of_multipages : max number of multipage in the entire job
  """
  nbr_of_multipages = print_length*1000/max_image_size
  print("Max Number of Multipages : {} pages = {} pages".format(nbr_of_multipages, int(math.floor(nbr_of_multipages))))
  return nbr_of_multipages

Techma 4


In [7]:
section_width      = 3072  # bytes = pixel
section_depth      = 16384 # bytes (1 bytes = 1 px)
section_numbers    = 21    # Nbr per Channel (Color)
number_of_channels = 1     # Number of printheads per board
ph_dpi             = 600   # dpi
print_width, print_length = printing_dimensions(section_width, section_depth, section_numbers, number_of_channels, ph_dpi)

# For 4 GB of RAM
print_length = print_length *4
print("Print length (4GB)       : {} m".format(print_length))


Memory Size              : 1056.964608 MBytes = 2113.929216 MPixels
PixelPitch @ 600dpi     : 42.33333333333333 um
Image width              : 130.048 mm
Print length             : 29.130751999999998 m
Print length (4GB)       : 116.52300799999999 m

Digiround


In [8]:
section_width      = 1536  # bytes ^= pixel per channel
section_depth      = 8192  # bytes => 1bytes = 2 pixel (by 4bpp)
section_numbers    = 21    # Nbr per Channel (Color)
number_of_channels = 4     # Number of printheads per board
ph_dpi             = 360   # dpi
subrate_length     = (281.94, 125.56) # (x, y) in mm (DART_24PX_SHORT_CMYK)
print_width, print_length = printing_dimensions(section_width, section_depth, section_numbers, number_of_channels, ph_dpi)
nbr_of_multipages = biggest_multipage_job(print_length,subrate_length[0] )


Memory Size              : 1056.964608 MBytes = 2113.929216 MPixels
PixelPitch @ 360dpi     : 70.55555555555556 um
Image width              : 108.37333333333333 mm
Print length             : 24.275626666666668 m
Max Number of Multipages : 86.10210210210211 pages = 86 pages

RDA Multihead


In [9]:
section_width      = 1536  # bytes ^= pixel per channel
section_depth      = 8192  # bytes => 1bytes = 2 pixel (by 4bpp)
section_numbers    = 21    # Nbr per Channel (Color)
number_of_channels = 4     # Number of printheads per board
ph_dpi             = 360   # dpi
subrate_length     = (115.5822, 80) # (x, y) in mm
print_width, print_length = printing_dimensions(section_width, section_depth, section_numbers, number_of_channels, ph_dpi)
nbr_of_multipages = biggest_multipage_job(print_length,subrate_length[0] )


Memory Size              : 1056.964608 MBytes = 2113.929216 MPixels
PixelPitch @ 360dpi     : 70.55555555555556 um
Image width              : 108.37333333333333 mm
Print length             : 24.275626666666668 m
Max Number of Multipages : 210.0291105954608 pages = 210 pages

Fire Time


In [10]:
def calc_fire_time(speed=10, dpi=1200): # speed = [m/min] dpi = [dpi]
  inch2m      = 0.0254
  pixel_pitch = inch2m/dpi # m
  fire_time = float(pixel_pitch) / (float(speed)/float(60))
  print("Speed       = {} m/min".format(speed))
  print("Resolution  = {} dpi".format(dpi))
  print("Fire Time   = {} s = {} kHz".format(fire_time, 1/fire_time/1000))
  fire_time_act = 0.000131
  dif = fire_time_act - fire_time
  dist = float(speed)/float(60)*dif
  print("Distance    = {} ".format(dist))
  print("")

calc_fire_time(speed=10,dpi=1200)
calc_fire_time(speed=10,dpi=600)
calc_fire_time(speed=10,dpi=150)
calc_fire_time(speed=50,dpi=600)
calc_fire_time(speed=50,dpi=150)


Speed       = 10 m/min
Resolution  = 1200 dpi
Fire Time   = 0.000127 s = 7.874015748031496 kHz
Distance    = 6.666666666666692e-07 

Speed       = 10 m/min
Resolution  = 600 dpi
Fire Time   = 0.000254 s = 3.937007874015748 kHz
Distance    = -2.0499999999999997e-05 

Speed       = 10 m/min
Resolution  = 150 dpi
Fire Time   = 0.001016 s = 0.984251968503937 kHz
Distance    = -0.00014749999999999998 

Speed       = 50 m/min
Resolution  = 600 dpi
Fire Time   = 5.0799999999999995e-05 s = 19.685039370078744 kHz
Distance    = 6.683333333333336e-05 

Speed       = 50 m/min
Resolution  = 150 dpi
Fire Time   = 0.00020319999999999998 s = 4.921259842519686 kHz
Distance    = -6.016666666666664e-05