#openttdcoop

import math
import time
import datetime
import os
from os import remove
from PIL import Image
from multiprocessing import Pool
import multiprocessing
from copy import deepcopy
import argparse

def print_start(bool, string):
  if bool == True:
    print(str(string))
def print_lvl_0(debug_level, string):
  print(str(string))
def print_lvl_1(debug_level, string):
  if debug_level > 0:
    print(str(string))
def print_lvl_2(debug_level, string):
  if debug_level > 1:
    print(str(string))
def print_lvl_3(debug_level, string):
  if debug_level > 2:
    print(str(string))
def print_lvl_4(debug_level, string):
  if debug_level > 3:
    print(str(string))
def print_lvl_5(debug_level, string):
  if debug_level > 4:
    print(str(string))
def print_lvl_6(debug_level, string):
  if debug_level > 5:
    print(str(string))
def print_lvl_7(debug_level, string):
  if debug_level > 6:
    print(str(string))

show_starting_messages = False
#starting message
print_start(show_starting_messages, '-'*79)
print_start(show_starting_messages, 'Starting...')

#path definition
diskPath = ''#'C:/Users/Pavel/Downloads/scripts/' #'D:/OpenTTD_repositories/BRIX/scripts/'
inputFolder = diskPath + 'input/'
outputFolder = diskPath + 'output/'
tempFolder = outputFolder + 'temp/'

os.makedirs(outputFolder, exist_ok = True)
os.makedirs(tempFolder, exist_ok = True)

#printing path just to check
print_start(show_starting_messages, 'inputFolder is ' + inputFolder)
print_start(show_starting_messages, 'outputFolder is ' + outputFolder)

#started time
tt = time.time()
startedTime = datetime.datetime.fromtimestamp(tt).strftime('%H:%M:%S')

#open palette image
palette_img = Image.open(inputFolder + 'openttd-palette-dos-RGBA.png')
#palette_img_indexed = Image.open(inputFolder + 'openttd-palette-dos-index.png')
palette_img_indexed = Image.open(inputFolder + 'palette_key.png')
palette_data = deepcopy(palette_img_indexed.palette)
print_start(show_starting_messages, 'Opening and loading palette: ' + 'openttd-palette-dos-RGBA.png')

p=[]

for b in range(0,palette_img.height):
  for a in range(0, palette_img.width):
    p.append(palette_img.getpixel((a,b)))
    
print_start(show_starting_messages, 'Palette loaded.')

# ----------------------------------------------------------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------

def rgb2palette(args):
  #print('rgb2palette args: ' + str(args))
  thread_id = args[0]
  input_image = args[1]
  x_start = args[2]
  x_end = args[3]
  allowed_colour_types = args[4]
  disallowed_colour_types = args[5]
  allowed_colour_indexes = args[6]
  disallowed_colour_indexes = args[7]
  alpha_ignore = args[8]
  alpha_offset_2 = args[9]
  alpha_offset_1 = args[10]
  red_weight = args[11]
  green_weight = args[12]
  blue_weight = args[13]
  arg_colour_shift = args[14]
  arg_debug_level = args[15]
  offset_list = args[16]
  
  #create allowed colours list
  colours_to_filter = []
  for coltype in allowed_colour_types:
    if coltype == 'ALL':
      for n in range(1, 80):
        colours_to_filter.append(n)
      for n in range(88, 197):
        colours_to_filter.append(n)
      for n in range(205, 215):
        colours_to_filter.append(n)
    if coltype == 'GRAYSCALE':
      for n in range(1, 16):
        colours_to_filter.append(n)
    if coltype == 'METAL': 
      for n in range(16, 24):
        colours_to_filter.append(n)
    if coltype == 'LIME_GREEN': 
      for n in range(24, 32):
        colours_to_filter.append(n)
    if coltype == 'BEIGE': 
      for n in range(32, 40):
        colours_to_filter.append(n)
    if coltype == 'DARK_PINK': 
      for n in range(40, 48):
        colours_to_filter.append(n)
    if coltype == 'YELLOW': 
      for n in range(50, 53):
        colours_to_filter.append(n)
    if coltype == 'DARK_BEIGE': 
      for n in range(53, 60):
        colours_to_filter.append(n)
    if coltype == 'YELLOW': 
      for n in range(60, 70):
        colours_to_filter.append(n)
    if coltype == 'BROWN_1': 
      for n in range(70, 80):
        colours_to_filter.append(n)
    if coltype == 'CC2': 
      for n in range(80, 88):
        colours_to_filter.append(n)
    if coltype == 'DARK_GREEN': 
      for n in range(88, 96):
        colours_to_filter.append(n)
    if coltype == 'PALE_GREEN': 
      for n in range(96, 104):
        colours_to_filter.append(n)
    if coltype == 'BROWN_2': 
      for n in range(104, 112):
        colours_to_filter.append(n)
    if coltype == 'BROWN_3': 
      for n in range(112, 122):
        colours_to_filter.append(n)
    if coltype == 'BROWN_4': 
      for n in range(122, 128):
        colours_to_filter.append(n)
    if coltype == 'MAUVE': 
      for n in range(128, 136):
        colours_to_filter.append(n)
    if coltype == 'PURPLE': 
      for n in range(136, 144):
        colours_to_filter.append(n)
    if coltype == 'BLUE': 
      for n in range(144, 154):
        colours_to_filter.append(n)
    if coltype == 'LIGHT_BLUE': 
      for n in range(154, 162):
        colours_to_filter.append(n)
    if coltype == 'PINK': 
      for n in range(162, 170):
        colours_to_filter.append(n)
    if coltype == 'LIGHT_PURPLE': 
      for n in range(170, 178):
        colours_to_filter.append(n)
    if coltype == 'RED_1': 
      for n in range(178, 185):
        colours_to_filter.append(n)
    if coltype == 'RED_2': 
      for n in range(185, 192):
        colours_to_filter.append(n)
    if coltype == 'ORANGE': 
      for n in range(192, 198):
        colours_to_filter.append(n)
    if coltype == 'CC1': 
      for n in range(198, 206):
        colours_to_filter.append(n)
    if coltype == 'GREEN': 
      for n in range(206, 210):
        colours_to_filter.append(n)
    if coltype =='CYAN':
      for n in range(210, 215):
        colours_to_filter.append(n)
    if coltype == 'COLA': 
      for n in range(227, 232):
        colours_to_filter.append(n)
    if coltype == 'FIRE': 
      for n in range(232, 239):
        colours_to_filter.append(n)
    if coltype == 'LED_RED': 
      for n in range(239, 241):
        colours_to_filter.append(n)
    if coltype == 'LED_YELLOW': 
      for n in range(241, 245):
        colours_to_filter.append(n)
    if coltype == 'WATER': 
      for n in range(245, 255):
        colours_to_filter.append(n)
    if coltype == 'WHITE':
      for n in range(255, 256):
        colours_to_filter.append(n)
  
  # create disallowed colours list
  disallowed_colours = []
  for coltype in disallowed_colour_types:
    if coltype == 'ALL':
      for n in range(1, 80):
        disallowed_colours.append(n)
      for n in range(88, 197):
        disallowed_colours.append(n)
      for n in range(205, 215):
        disallowed_colours.append(n)
    if coltype == 'GRAYSCALE':
      for n in range(1, 16):
        disallowed_colours.append(n)
    if coltype == 'METAL': 
      for n in range(16, 24):
        disallowed_colours.append(n)
    if coltype == 'LIME_GREEN': 
      for n in range(24, 32):
        disallowed_colours.append(n)
    if coltype == 'BEIGE': 
      for n in range(32, 40):
        disallowed_colours.append(n)
    if coltype == 'DARK_PINK': 
      for n in range(40, 48):
        disallowed_colours.append(n)
    if coltype == 'YELLOW': 
      for n in range(50, 53):
        disallowed_colours.append(n)
    if coltype == 'DARK_BEIGE': 
      for n in range(53, 60):
        disallowed_colours.append(n)
    if coltype == 'YELLOW': 
      for n in range(60, 70):
        disallowed_colours.append(n)
    if coltype == 'BROWN_1': 
      for n in range(70, 80):
        disallowed_colours.append(n)
    if coltype == 'CC2': 
      for n in range(80, 88):
        disallowed_colours.append(n)
    if coltype == 'DARK_GREEN': 
      for n in range(88, 96):
        disallowed_colours.append(n)
    if coltype == 'PALE_GREEN': 
      for n in range(96, 104):
        disallowed_colours.append(n)
    if coltype == 'BROWN_2': 
      for n in range(104, 112):
        disallowed_colours.append(n)
    if coltype == 'BROWN_3': 
      for n in range(112, 122):
        disallowed_colours.append(n)
    if coltype == 'BROWN_4': 
      for n in range(122, 128):
        disallowed_colours.append(n)
    if coltype == 'MAUVE': 
      for n in range(128, 136):
        disallowed_colours.append(n)
    if coltype == 'PURPLE': 
      for n in range(136, 144):
        disallowed_colours.append(n)
    if coltype == 'BLUE': 
      for n in range(144, 154):
        disallowed_colours.append(n)
    if coltype == 'LIGHT_BLUE': 
      for n in range(154, 162):
        disallowed_colours.append(n)
    if coltype == 'PINK': 
      for n in range(162, 170):
        disallowed_colours.append(n)
    if coltype == 'LIGHT_PURPLE': 
      for n in range(170, 178):
        disallowed_colours.append(n)
    if coltype == 'RED_1': 
      for n in range(178, 185):
        disallowed_colours.append(n)
    if coltype == 'RED_2': 
      for n in range(185, 192):
        disallowed_colours.append(n)
    if coltype == 'ORANGE': 
      for n in range(192, 198):
        disallowed_colours.append(n)
    if coltype == 'CC1': 
      for n in range(198, 206):
        disallowed_colours.append(n)
    if coltype == 'GREEN': 
      for n in range(206, 210):
        disallowed_colours.append(n)
    if coltype =='CYAN':
      for n in range(210, 215):
        disallowed_colours.append(n)
    if coltype == 'COLA': 
      for n in range(227, 232):
        disallowed_colours.append(n)
    if coltype == 'FIRE': 
      for n in range(232, 239):
        disallowed_colours.append(n)
    if coltype == 'LED_RED': 
      for n in range(239, 241):
        disallowed_colours.append(n)
    if coltype == 'LED_YELLOW': 
      for n in range(241, 245):
        disallowed_colours.append(n)
    if coltype == 'WATER': 
      for n in range(245, 255):
        disallowed_colours.append(n)
    if coltype == 'WHITE':
      for n in range(255, 256):
        disallowed_colours.append(n)

#add individual disallowed colours
  for n in disallowed_colour_indexes:
    disallowed_colours.append(n)

#move non-disallowed colours to a new list
  filtered_colours_to_filter = []
  for c in colours_to_filter:
    skip = 0
    for d in disallowed_colours:
      if c == d:
        skip = 1
    if skip == 0:
      filtered_colours_to_filter.append(c)
  
  #add individual allowed colours
  for n in allowed_colour_indexes:
    filtered_colours_to_filter.append(n)

print_lvl_4(arg_debug_level, 'Colours to filter: ' + str(filtered_colours_to_filter))

#open input image
  i = Image.open(inputFolder + input_image + '.png')
  #i.show()
  print_lvl_2(arg_debug_level, 'Thread ' + str(thread_id) + ' Opening: ' + input_image + '.png')  
  
  #create new empty image for output
  imageOutput = Image.new('L', (i.width,i.height), color = 0)

for y in range (0, i.height):
    #timeStamp
    ts = time.time()
    timeStamp = datetime.datetime.fromtimestamp(ts).strftime('%H:%M:%S')
    if y%32 == 0:
      print_lvl_5(arg_debug_level, 'Thread ' + str(thread_id) + ' ' + timeStamp + ' - ' + input_image + ' row {}'.format(y))
    for x in range (x_start, x_end):
      #defining winner variables
      winnerDistance = 100000000
      winnerID = 0
      
      #loading pixel from image and separating RGBA
      pixelNumber = x + (y * i.width)
      pix = i.getpixel((x,y))
      pixRed = pix[0]
      pixGreen = pix[1]
      pixBlue = pix[2]
      pixAlpha = pix[3]

#check Alpha in pixel, and output alpha/color offset
      if pixAlpha < alpha_ignore:
        finalAlpha = 0
        colorOffset = 0
      if pixAlpha >= alpha_ignore and pixAlpha < 178:
        finalAlpha = 255
        colorOffset = 2
      if pixAlpha >= alpha_offset_1 and pixAlpha < alpha_offset_2:
        finalAlpha = 255
        colorOffset = 1
      if pixAlpha >= alpha_offset_2:
        finalAlpha = 255
        colorOffset = 0
          
      #if alpha above 50%, do colour comparing to palette
      if pixAlpha >= alpha_ignore:
        for colour_id in filtered_colours_to_filter:
          rgb1 = p[colour_id]
          r1 = rgb1[0]
          g1 = rgb1[1]
          b1 = rgb1[2]

l1 = (r1*red_weight + g1*green_weight + b1*blue_weight) / 255000
          l2 = (pixRed*red_weight + pixGreen*green_weight + pixBlue*blue_weight) / 255000
          dL = l1-l2
          dR = (r1-pixRed)/255
          dG = (g1-pixGreen)/255
          dB = (b1-pixBlue)/255
          distance = (dR*dR*red_weight*0.001 + dG*dG*blue_weight*0.001 + dB*dB*blue_weight*0.001)*0.75 + dL*dL
          
          if distance < winnerDistance:
            winnerDistance = distance
            winnerID = colour_id

#final color changed by colorOffset
      finalID = offset_list[winnerID][colorOffset] #winnerID - colorOffset
      #finalAlpha taken from the if output above palette colour comparing

if colorOffset == 2:
        for g in disallowed_colours:
          if g == finalID:
            colorOffset = 1
            finalID = offset_list[winnerID][colorOffset]
      if colorOffset == 1:
        for g in disallowed_colours:
          if g == finalID:
            colorOffset = 0
            finalID = offset_list[winnerID][colorOffset]
         
      #argument to ignore colorOffset
      if arg_colour_shift == False:
        finalID = winnerID

#put the final pixel into the output picture
      imageOutput.putpixel((x,y),(finalID))
      #print('Thread ' + str(thread_id) + ' Pixel ' + str(pixelNumber) + ': R= ' + str(finalR) + ', G= ' + str(finalG) + ', B= ' + str(finalB) + ', A= '  + str(finalAlpha)   )
  
  cropped_imageOutput = imageOutput.crop((x_start, 0,x_end,i.height))
  cropped_imageOutput.putpalette(palette_data)
  cropped_imageOutput.save(outputFolder + 'temp/' + 'temp' + '_'  + str(thread_id) + '_8bpp.png') #assumes _#### frame number format (removes last 5 characters)
  i.close()
  cropped_imageOutput.close()    
    
def combineResults(args, thread_count, palette_data, arg_debug_level):
  print_lvl_5(arg_debug_level, 'combineResults args: ' + str(args))
  thread_id = args[0]
  combine_input_image = args[1]
  x_start = args[2]
  x_end = args[3]

image_for_resolution = Image.open(inputFolder + str(combine_input_image[1]) + '.png')
  final_image = Image.new('L', (image_for_resolution.width, image_for_resolution.height), color = 0)
  final_image.putpalette(palette_data)

print_lvl_3(arg_debug_level, 'img_resolution.height = ' + str(image_for_resolution.height))
  for combine_order in args:
    image_to_paste = Image.open(outputFolder + 'temp/' + 'temp' + '_'  + str(combine_order[0]) + '_8bpp.png')
    
    print_lvl_3(arg_debug_level, 'Combine strip with x_start = ' + str(combine_order[2]))

final_image.paste(image_to_paste, box = (combine_order[2], 0))

final_image.putpalette(palette_data)
  final_image.save(outputFolder + str(combine_input_image[1]) + '_8bpp.png')

def check_list_count(arg_debug_level, list_to_check, n):
  w = 0
  for stuff in list_to_check:
    w += 1
  print_lvl_5(arg_debug_level, 'Offset list item count: ' + str(w) + ' , last n is: ' + str(n))

def append_offset_list(offset_list, temp_list):
  for t in temp_list:
    offset_list.append(t)

def add_6_index_list(offset_list, n):
    temp_list = [
        [   n,  n+1,  n+2],#1
        [ n+1,  n+2,  n+3],#2
        [ n+2,  n+3,  n+3],#3--
        [ n+3,  n+3,  n+2],#4--
        [ n+4,  n+3,  n+2],#5
        [ n+5,  n+4,  n+3]# 6
      ]
    append_offset_list(offset_list,temp_list)

def add_8_index_list(offset_list, n):
    temp_list = [
        [   n,  n+1,  n+2],#1
        [ n+1,  n+2,  n+3],#2
        [ n+2,  n+3,  n+4],#3
        [ n+3,  n+4,  n+4],#4--
        [ n+4,  n+4,  n+3],#5--
        [ n+5,  n+4,  n+3],#6
        [ n+6,  n+5,  n+4],#7
        [ n+7,  n+6,  n+5]# 8
      ]
    append_offset_list(offset_list,temp_list)
      
def add_10_index_list(offset_list, n):
    temp_list = [
        [   n,  n+1,  n+2],#1
        [ n+1,  n+2,  n+3],#2
        [ n+2,  n+3,  n+4],#3
        [ n+3,  n+4,  n+5],#4
        [ n+4,  n+5,  n+5],#5--
        [ n+5,  n+5,  n+4],#6--
        [ n+6,  n+5,  n+4],#7
        [ n+7,  n+6,  n+5],#8
        [ n+8,  n+7,  n+6],#9
        [ n+9,  n+8,  n+7]#10
      ]
    append_offset_list(offset_list,temp_list)
      
      
def run():
  # ----------------------------------------------------------------------------------------------------------------
  #VARIABLES
  # ----------------------------------------------------------------------------------------------------------------
  job_list = [  
      [
      options['input_name'],        
      options['allowed_colour_types'],#allowed colour types (string list)
      options['disallowed_colour_types'],#disallowed colour types (string list)
      options['allowed_colour_indexes'],#allowed colour indexes (number list)
      options['disallowed_colour_indexes'],#disallowed colour indexes (number list)
      options['alpha_ignore'],
      options['alpha_offset_2'],
      options['alpha_offset_1'],
      options['red_weight'],#red weight (number, default = 1)
      options['green_weight'],#green weight (number, default = 1)
      options['blue_weight'],#blue weight (number, default = 1)
      options['colour_shift'],
      options['debug_level']
      ]
    ]

# ----------------------------------------------------------------------------------------------------------------
  thread_count = options['thread_count']
  # ----------------------------------------------------------------------------------------------------------------
  # ----------------------------------------------------------------------------------------------------------------
  # ----------------------------------------------------------------------------------------------------------------

#--------------------------------------------------------------------------------
  #creating offset list -----------------------------------------------------------
  #--------------------------------------------------------------------------------
  offset_list = []

#TRANSPARENCY
  n = 0
  check_list_count(options['debug_level'], offset_list, n)
  temp_list = [
    [n,n,n]
  ]
  append_offset_list(offset_list,temp_list)

#GRAYSCALE
  n = 1
  check_list_count(options['debug_level'], offset_list, n)
  temp_list = [
      [   n,  n+1,  n+2],#1
      [ n+1,  n+2,  n+3],#2
      [ n+2,  n+3,  n+4],#3
      [ n+3,  n+4,  n+5],#4
      [ n+4,  n+5,  n+6],#5
      [ n+5,  n+6,  n+7],#6
      [ n+6,  n+7,  n+7],#7--
      [ n+7,  n+8,  n+8],#8--
      [ n+8,  n+8,  n+7],#9--
      [ n+9,  n+8,  n+7],#10
      [n+10,  n+9,  n+8],#11
      [n+11, n+10,  n+9],#12
      [n+12, n+11, n+10],#13
      [n+13, n+12, n+11],#14
      [n+14, n+13, n+12],#15
  ]
  append_offset_list(offset_list, temp_list)

#METAL
  n = 16
  check_list_count(options['debug_level'], offset_list, n)
  add_8_index_list(offset_list, n)

#LIME_GREEN
  n = 24
  check_list_count(options['debug_level'], offset_list, n)
  add_8_index_list(offset_list, n)

#BEIGE
  n = 32
  check_list_count(options['debug_level'], offset_list, n)
  add_8_index_list(offset_list, n)

#DARK_PINK
  n = 40
  check_list_count(options['debug_level'], offset_list, n)
  add_10_index_list(offset_list, n)

#YELLOW
  n = 50
  check_list_count(options['debug_level'], offset_list, n)
  temp_list = [
    [   n,  189,  188],#1
    [ n+1,  n+0,  188],#2
    [ n+2,  n+1,  n+0]# 3
  ]
  append_offset_list(offset_list, temp_list)

#DARK_BEIGE
  n = 53
  check_list_count(options['debug_level'], offset_list, n)
  temp_list = [
    [   n,  n+1,  n+2],#1
    [ n+1,  n+2,  n+3],#2
    [ n+2,  n+3,  n+3],#3--
    [ n+3,  n+3,  n+4],#4--
    [ n+4,  n+3,  n+3],#5--
    [ n+5,  n+4,  n+3],#6
    [ n+6,  n+5,  n+4]# 7
  ]
  append_offset_list(offset_list, temp_list)

#YELLOW
  n = 60
  check_list_count(options['debug_level'], offset_list, n)
  add_10_index_list(offset_list, n)

#BROWN_1
  n = 70
  check_list_count(options['debug_level'], offset_list, n)
  add_10_index_list(offset_list, n)

#CC2,
  n = 80
  check_list_count(options['debug_level'], offset_list, n)
  add_8_index_list(offset_list, n)

#DARK_GREEN
  n = 88
  check_list_count(options['debug_level'], offset_list, n)
  add_8_index_list(offset_list, n)

#PALE_GREEN
  n = 96
  check_list_count(options['debug_level'], offset_list, n)
  add_8_index_list(offset_list, n)

#BROWN_2
  n = 104
  check_list_count(options['debug_level'], offset_list, n)
  add_8_index_list(offset_list, n)

#BROWN_3
  n = 112
  check_list_count(options['debug_level'], offset_list, n)
  add_10_index_list(offset_list, n)

#BROWN_4
  n = 122
  check_list_count(options['debug_level'], offset_list, n)
  add_6_index_list(offset_list, n)

#MAUVE
  n = 128
  check_list_count(options['debug_level'], offset_list, n)
  add_8_index_list(offset_list, n)

#PURPLE
  n = 136
  check_list_count(options['debug_level'], offset_list, n)
  add_8_index_list(offset_list, n)

#BLUE
  n = 144
  check_list_count(options['debug_level'], offset_list, n)
  add_10_index_list(offset_list, n)

#LIGHT_BLUE
  n = 154
  check_list_count(options['debug_level'], offset_list, n)
  add_8_index_list(offset_list, n)

#PINK
  n = 162
  check_list_count(options['debug_level'], offset_list, n)
  add_8_index_list(offset_list, n)

#LIGHT_PURPLE
  n = 170
  check_list_count(options['debug_level'], offset_list, n)
  add_8_index_list(offset_list, n)

#RED
  n = 178
  check_list_count(options['debug_level'], offset_list, n)
  temp_list = [
    [   n,  n+1,  n+2],#1
    [ n+1,  n+2,  n+3],#2
    [ n+2,  n+3,  n+4],#3
    [ n+3,  n+4,  n+5],#4
    [ n+4,  n+5,  n+6],#5
    [ n+5,  n+6,  n+7],#6
    [ n+6,  n+7,  n+7],#7--
    [ n+7,  n+6,  n+6],#8--
    [ n+8,  n+7,  n+6],#9
    [ n+9,  n+8,  n+7],#10
    [n+10,  n+9,  n+8],#11
    [n+11, n+10,  n+9],#12
    [n+12, n+11, n+10],#13
    [n+13, n+12, n+11]#14
  ]
  append_offset_list(offset_list, temp_list)

#ORANGE
  n = 192
  check_list_count(options['debug_level'], offset_list, n)
  temp_list = [
    [  n,   64,  63],#1
    [ n+1, n+0,  64],#2
    [ n+2, n+1, n+0],#3
    [ n+3, n+2,  n+1],#4
    [ n+4, n+3, n+2],#5
    [ n+5, n+4, n+3]#6
  ]
  append_offset_list(offset_list, temp_list)

#CC1
  n = 198
  check_list_count(options['debug_level'], offset_list, n)
  add_8_index_list(offset_list, n)

#GREEN
  n = 206
  check_list_count(options['debug_level'], offset_list, n)
  temp_list = [
    [    n, 93,  92],#1
    [ n+1, n+0,  93],#2
    [ n+2, n+1, n+0],#3
    [ n+3, n+2, n+1]# 4
  ]
  append_offset_list(offset_list, temp_list)

#CYAN
  n = 210
  check_list_count(options['debug_level'], offset_list, n)
  temp_list = [
    [  n, n+1, n+2],#1
    [n+1, n+2, n+2],#2
    [n+2, n+3, n+3],#3
    [n+3, n+2, n+2],#4
    [n+4, n+3, n+2]# 5
  ]
  append_offset_list(offset_list, temp_list)

#ALPHAPINK & ACT
  n = 215
  check_list_count(options['debug_level'], offset_list, n)
  temp_list = [
    [  n+0,  n+0,  n+0],#1  - index 215
    [  n+1,  n+1,  n+1],#2  - index 216
    [  n+2,  n+2,  n+2],#3  - index 217
    [  n+3,  n+3,  n+3],#4  - index 218
    [  n+4,  n+4,  n+4],#5  - index 219
    [  n+5,  n+5,  n+5],#6  - index 220
    [  n+6,  n+6,  n+6],#7  - index 221
    [  n+7,  n+7,  n+7],#8  - index 222
    [  n+8,  n+8,  n+8],#9  - index 223
    [  n+9,  n+9,  n+9],#10 - index 224
    [ n+10, n+10, n+10],#11 - index 225
    [ n+11, n+11, n+11],#12 - index 226
    [ n+12, n+12, n+12],#13 - index 227
    [ n+13, n+13, n+13],#14 - index 228
    [ n+14, n+14, n+14],#15 - index 229
    [ n+15, n+15, n+15],#16 - index 230
    [ n+16, n+16, n+16],#17 - index 231
    [ n+17, n+17, n+17],#18 - index 232
    [ n+18, n+18, n+18],#19 - index 233
    [ n+19, n+19, n+19],#20 - index 234
    [ n+20, n+20, n+20],#21 - index 235
    [ n+21, n+21, n+21],#22 - index 236
    [ n+22, n+22, n+22],#23 - index 237
    [ n+23, n+23, n+23],#24 - index 238
    [ n+24, n+24, n+24],#25 - index 239
    [ n+25, n+25, n+25],#26 - index 240
    [ n+26, n+26, n+26],#27 - index 241
    [ n+27, n+27, n+27],#28 - index 242
    [ n+28, n+28, n+28],#29 - index 243
    [ n+29, n+29, n+29],#30 - index 244
    [ n+30, n+30, n+30],#31 - index 245
    [ n+31, n+31, n+31],#32 - index 246
    [ n+32, n+32, n+32],#33 - index 247
    [ n+33, n+33, n+33],#34 - index 248
    [ n+34, n+34, n+34],#35 - index 249
    [ n+35, n+35, n+35],#36 - index 250
    [ n+36, n+36, n+36],#37 - index 251
    [ n+37, n+37, n+37],#38 - index 252
    [ n+38, n+38, n+38],#39 - index 253
    [ n+39, n+39, n+39],#40 - index 254
    [ n+40, n+40, n+40] #41 - index 255
  ]
  append_offset_list(offset_list, temp_list)

n = 256
  check_list_count(options['debug_level'], offset_list, n)

for job in job_list:
    all_jobs = []
    job_chunks = []
    queue = []

extra = 0
    chunk_image = Image.open(inputFolder + job[0] + '.png')
    chunk_average_size = math.floor(chunk_image.width/thread_count)
    chunk_modulo_size = chunk_image.width % thread_count 
    for thread in range(0, thread_count):
      start = chunk_average_size * thread
      end = (chunk_average_size * (thread+1))

start += extra
      if thread < chunk_modulo_size:   
        extra += 1
      end += extra

start_and_end = [
                        thread, #0 - threadID
                        job[0], #1 - input_name
                        start,  #2 - x_start
                        end,    #3 - x_end
                        job[1], #4 - allowed_colour_types
                        job[2], #5 - disallowed_colour_types
                        job[3], #6 - allowed_colour_indexes
                        job[4], #7 - disallowed_colour_indexes
                        job[5], #8 - alpha_ignore
                        job[6], #9 - alpha_offset_1
                        job[7], #10- alpha_offset_2
                        job[8], #11- red_weight
                        job[9], #12- green_weight
                        job[10],#13- blue_weight
                        job[11],#14- colour_shift
                        job[12],#15- debug_level
                        offset_list
                      ]
      job_chunks.append(start_and_end)
      queue.append( [thread, job[0], start, end, job[1], job[2], job[3], job[4], job[5], job[6], job[7], job[8], job[9], job[10], job[11], job[12], offset_list ])

all_jobs.append(job_chunks)

for a_job in all_jobs:
      print_lvl_5(options['debug_level'], '-'*32)
      thread_id = 0
      for b_thread in a_job:
        if thread_id == 0:
          thread_id += 1
          print_lvl_5(options['debug_level'], 'Job: ' + str(b_thread[0]))
          print_lvl_5(options['debug_level'], ' '*10 + 'Start, ' + 'End')
          print_lvl_5(options['debug_level'], 'Thread ' + str(thread_id) + ': ' + str(b_thread[1]) + ', ' + str(b_thread[2]))#
        
        
    print_lvl_7(options['debug_level'], (queue))

# ----------------------------------------------------------------------------------------------------------------
    # PROCESS
    # ----------------------------------------------------------------------------------------------------------------
    
    pool = multiprocessing.Pool(processes = thread_count)
    pool.map(rgb2palette, queue)
    pool.close()
    pool.join()
    
    combineResults(queue, thread_count, palette_data, options['debug_level'])

#finished time
    tx = time.time()
    finishedTime = datetime.datetime.fromtimestamp(tx).strftime('%H:%M:%S')
    
    print('Started:  ' + startedTime)
    print('Finished: ' + finishedTime)

#run()

if __name__ == '__main__':
  parser = argparse.ArgumentParser(description = 'Process some arguments.')
  parser.add_argument('-t','--thread_count',
                      help='Number of theads to run, Default: 16',
                      type = int,
                      required = False)
  parser.add_argument('-n','--input_name',
                      help='File to process. Without .png extension. File can only be RGBA (not RGB)',
                      required = True)
  parser.add_argument('-c','--allowed_colour_types',
                      help='Allowed colour types (list of strings), Default: "ALL"',
                      nargs = '+',
                      required = False)
  parser.add_argument('-d','--disallowed_colour_types',
                      help='Disallowed colour types (list of strings), Default: nothing',
                      nargs = '+',
                      required = False)
  parser.add_argument('-e','--allowed_colour_indexes',
                      help='Allowed colour indexes (list of numbers), Default: nothing',
                      nargs = '+',
                      type = int,
                      required = False)
  parser.add_argument('-f','--disallowed_colour_indexes',
                      help='Disallowed colour indexes (list of numbers), Default: nothing',
                      nargs = '+',
                      type = int,
                      required = False)
  parser.add_argument('-i','--alpha_ignore',
                      help='Threshold of ignoring transparency. Default: 128',
                      type = int,
                      required = False)
  parser.add_argument('-k','--alpha_offset_1',
                      help='Threshold of transparency to colour shift by 1 index. Default: 178',
                      type = int,
                      required = False)
  parser.add_argument('-j','--alpha_offset_2',
                      help='Threshold of transparency to colour shift by 2 indexes. Default: 230',
                      type = int,
                      required = False)
  parser.add_argument('-o','--red_weight',
                      help='Weight of red input for colour comparing. Default: 1',
                      type = float,
                      required = False)
  parser.add_argument('-p','--green_weight',
                      help='Weight of green input for colour comparing. Default: 1',
                      type = float,
                      required = False)
  parser.add_argument('-q','--blue_weight',
                      help='Weight of blue input for colour comparing. Default: 1',
                      type = float,
                      required = False)
  parser.add_argument('-r','--colour_shift',
                      help='For semi-transparent pixels, shifts index to attempt to compensate alpha. Default: True',
                      type = bool,
                      required = False)
  parser.add_argument('-s', '--debug_level',
                      help='Amount of info shown in console. Default: 1, Min: 1, Max: 7',
                      type = int,
                      required = False)
  options = vars(parser.parse_args())

if not options['thread_count']:
    options['thread_count'] = 16
  if not options['allowed_colour_types']:
    options['allowed_colour_types'] = ['ALL']
  if not options['disallowed_colour_types']:
    options['disallowed_colour_types'] = []
  if not options['allowed_colour_indexes']:
    options['allowed_colour_indexes'] = []
  if not options['disallowed_colour_indexes']:
    options['disallowed_colour_indexes'] = []
  if not options['alpha_ignore']:
    options['alpha_ignore'] = 128
  if not options['alpha_offset_1']:
    options['alpha_offset_1'] = 178
  if not options['alpha_offset_2']:
    options['alpha_offset_2'] = 230
  if not options['red_weight']:
    options['red_weight'] = 1
  if not options['green_weight']:
    options['green_weight'] = 1
  if not options['blue_weight']:
    options['blue_weight'] = 1
  if not options['colour_shift']:
    options['colour_shift'] = False
  if not options['debug_level']:
    options['debug_level'] = 1

run()

Mark as private