Sid_Dithers.py

# =======================
# Imports
# =======================

import os, sys, time, re
from datetime import datetime as dt
from itertools import chain, filterfalse

from urllib.request import urlopen
from urllib.request import Request
import urllib.error

import numpy as np
from PIL import Image


# =======================
# Functions
# =======================

# Internet Functions

def check_site_redirected(starturl):

        res = urllib.request.urlopen(starturl)
        finalurl = res.geturl()
        return finalurl

def get_links(start_html, c_regex):

        html_links = []

        try:
                # Spoof Header to look like regular user browser
                req = Request(start_html)
                req.add_header('User-Agent', 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/43.0.2357.130 AOL/9.8 AOLBuild/4346.2019.US Safari/537.36')
                start_file = urlopen(req)

        except urllib.error.HTTPError as e:
                print('Download Failed for',start_html)
                print('Status', e.code,' - Reason', e.reason,' - Url', e.url)
                return html_links

        start_text = str(start_file.read(),encoding="utf-8",errors="ignore")   # is there an encoding problem -- eg utf-8    -- or errors="replace" - replaces the unencodable unicode to a question mark ?
        start_file.close()

        #print("DEBUG - sleep on link download")
        #time.sleep(0.5)   # DEBUG

        if start_text != "":                          # If content exists
                html_links  = c_regex.findall(start_text)

        return html_links

# Data Pipe functions

def pipe_inspector(link_input):
        print("'",link_input,"',")
        yield link_input

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

def link_from_list(link_list):
        for link_input in link_list:
                yield link_input

def get_test_links(link_input, c_regex):
        html_links = c_regex.findall(str(link_input))
        return html_links

def link_text_replace_filter(file_link):
        return [file_link.replace("vids","highres")]

def link_prefix_adder(file_link):
        return [prefix_adder+file_link]


def file_name_filter(file_link,c_regex):
        file_name = file_link[file_link.rfind("/")+1:]
        file_name = file_name[:-4]
        #print(file_name)
        link_filter = c_regex.findall(str(file_name))
        if link_filter == []:
                return ""
        else:
                return [file_link]

def file_name_generator(file_link):

        str_template = "%2d"
        file_list = []

        for c in range(1,10+1):
                file_name = str_template % (c)
                file_list.append(file_name)
                
        return file_list


# ========================

class link_prefix():

        def __init__(self, file_prefix):
                self.file_prefix = file_prefix
                return

        def add(self, file_link):
                #print("'" + self.file_prefix + file_link + "',")
                return [self.file_prefix + file_link]

class link_two_string():

        def __init__(self, string_format, func1=None, func2=None):
                self.string_format = string_format
                self.func1 = func1
                self.func2 = func2
                return

        def add(self, file_link):

                if (self.func1 == None and self.func2 != None):
                        return [self.string_format % (file_link,self.func2(file_link))]
                elif (self.func1!=None and self.func2==None):
                        return [self.string_format % (self.func1(file_link),file_link)]
                elif (self.func1!=None and self.func2!=None):
                        return [self.string_format % (self.func1(file_link),self.func2(file_link))]
                else: 
                        return [self.string_format % (file_link,file_link)]

class link_generator():

        def __init__(self, file_ext,header,start,end):
                self.file_ext   = file_ext
                self.header     = header
                self.start      = start
                self.end        = end
                self.filelist   = []
                return

        def add(self, file_link):
                self.filelist   = []
                for c in range(self.start,self.end+1):
                        #filename = file_link + "/" + self.header % (c) + self.file_ext
                        filename = file_link + self.header % (c) + self.file_ext
                        self.filelist.append(filename)
                return self.filelist

# Iterator Functions

def html_cal_iter(html_str,start_year,end_year,end_month):
        for tgt_year in range(start_year, end_year+1):
                for tgt_month in range(1,12+1):
                        if tgt_year < end_year or (tgt_year == end_year and tgt_month <= end_month): 
                                yield html_str % (tgt_year,tgt_month)

def html_num_iter(html_str,start_page,end_page):
        for tgt_page in range(start_page, end_page+1):
                yield html_str % (tgt_page)

def html_list_iter(iter_list):
        for tgt_page in iter_list:
                yield tgt_page

def html_alpha_iter(html_str,start_letter=0,end_letter=26,use_upper=True):

        alpha     = "abcdefghijklmnopqrstuvwxyz"
        alpha     = alpha[start_letter:end_letter]

        if use_upper:
                alpha = alpha.upper()
        
        for tgt_page in alpha:
                yield html_str % (tgt_page)


# =========================
# Classes
# =========================

# Wrapper classes used for data pipes

class cDownloader:

        def __init__(self, file_namer, file_extension, file_prefix="", file_start_counter=0, pause=0.2, dead_link_kill=3, snap_page=False):

                # Parameters to set for processing by the data pipes

                self.file_namer         = file_namer
                self.file_ext           = file_extension
                self.prefix             = file_prefix
                #self.html_level_prefix  = html_level_prefix
                self.file_count         = file_start_counter
                self.pause              = pause

                self.dead_link_kill     = dead_link_kill
                self.dead_links         = 0
                self.last_dead_link     = ""
                self.snap_page          = snap_page

                if self.snap_page:

                        options = webdriver.ChromeOptions()
                        options.add_argument("headless")
                        options.add_argument("window-size=2500,1200")

                        self.browser = webdriver.Chrome(chrome_options=options)

        def __del__(self):

                if self.snap_page:
                        self.browser.quit()        # close() ?              

        def download(self, file_link):                      # This gets called externally by the data pipes

                if file_link is None:
                        pass

                else:

                        self.file_count += 1
                        add_prefix = ""

                        if self.file_namer == "FILENAME":
                                
                                trim_file_link = file_link[:file_link.rfind(self.file_ext)+len(self.file_ext)]                          # Clip name if filelink has parameters after the filename 
                                file_name = self.prefix + add_prefix + trim_file_link[trim_file_link.rfind("/")+1:]                     # Extract file name from link

                        else:   # defaults to file counter
                                file_name = (self.prefix + add_prefix + "%06d" + self.file_ext) % self.file_count

                        # Attempt to download the file but check if we have exceeded the dead link count

                        if (self.dead_links >= self.dead_link_kill and self.last_dead_link == file_link[:file_link.rfind("/")]):

                                #print('ERROR: cDownloader - REASON: Exceeded dead links')
                                pass

                        elif os.path.exists(file_name):
                                print("WARNING: File exists ",file_name," skipping")
                                pass


                        # Begin download

                        if self.snap_page:                   # Take a snapshot of the webpage instead of downloading a file

                                self.browser.get(file_link)
                                self.browser.save_screenshot(file_name+".png")   # always a png ext
                                time.sleep(self.pause)

                        else: # download the file

                                try:
                                        req = Request(file_link)
                                        req.add_header('User-Agent', 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/43.0.2357.130 AOL/9.8 AOLBuild/4346.2019.US Safari/537.36')
                                        remotefile = urlopen(req)

                                        localfile  = open(file_name, 'wb')                
                                        localfile.write(remotefile.read())
                                        localfile.close()
                                        remotefile.close()

                                        #print("DEBUG - sleep on file download")
                                        #time.sleep(0.5) # DEBUG

                                        self.dead_links         = 0       # successful download, reset dead link count to zero
                                        self.last_dead_link     = ""

                                except urllib.error.HTTPError as e:

                                        print('ERROR: ',e.code,' REASON: ',e.reason, " => ",file_link)  # Url = e.url

                                        self.dead_links += 1              # unsuccessful download, add dead link data
                                        self.last_dead_link = file_link[:file_link.rfind("/")]   # root of file attempted



## END class cDownloader


# Data Pipe Class

class cDataPipe:

    def __init__(self):

        self.nLayers            = 0
        self.DataPipes          = []

    def new_pipe(self, data_pump):
        self.DataPipes.append([data_input for data_input in data_pump])

    def end_pipe(self, data_downloader):
        self.nLayers += 1
        self.DataPipes.append([data_downloader(data_input) for data_input in self.DataPipes[self.nLayers-1]])

    def add_pipe(self, data_processor, c_regex=""):

        self.nLayers += 1

        if c_regex == "":
                self.DataPipes.append(self.unique_items(self.flatten([data_processor(data_input) for data_input in self.DataPipes[self.nLayers-1]])))
        else:
                self.DataPipes.append(self.unique_items(self.flatten([data_processor(data_input,c_regex) for data_input in self.DataPipes[self.nLayers-1]])))
                
    def output(self):
        return list(self.DataPipes[self.nLayers])

    def flow(self):
        yield self.DataPipes[self.nLayers]

    def flatten(self, list_of_lists):

        flat_list = []
        
        try:
                flat_list = list(chain.from_iterable(list_of_lists))      # Note -- this will fail if any item is not an iterable - oth params ??
        except:
                print("ERROR - Non-iterable in flatten chain")
                return []

        return flat_list

    def unique_items(self, iterable):

        seen = set()

        for element in filterfalse(seen.__contains__,iterable):
                seen.add(element)
                yield element


# ===================
# Image Processing Functions
# ===================

              


'''



Floyd-Steinberg Dithering Example

https://scipython.com/blog/floyd-steinberg-dithering/



Also see:



https://tannerhelland.com/2012/12/28/dithering-eleven-algorithms-source-code.html

https://en.wikipedia.org/wiki/Ordered_dithering

https://archive.ph/71e9G



Adjusted for ePaper colours - which are 7



Supported Colours



Brown  R - 255 G - 128 B - 0

Green  R - 0   G - 255 B - 0

White  R - 255 G - 255 B - 255

Black  R - 0   G - 0   B - 0

Red    R - 255 G -0    B - 0

Blue   R - 0   G - 0   B - 255

Yellow R - 255 G 255   B - 0



Not Supported (but would be normal 2 channel colours)



Purple R - 255 G 0     B - 255

Turq   R - 0   G 255   B - 255



'''



# =================================
# Constants
# =================================



colour_map = [np.array([0,0,0]),       # Black
              np.array([255,0,0]),     # Red
              np.array([0,255,0]),     # Green
              np.array([0,0,255]),     # Blue
              np.array([255,255,0]),   # Yellow
              np.array([255,128,0]),   # Brown
              np.array([255,255,255]), # White
              ]

NUMBER_COLOURS = len(colour_map)


# =================================
# FUNCTIONS
# =================================


def get_new_val(old_val, nc):
    """

    Get the "closest" colour to old_val in the range [0,1] per channel divided

    into nc values.



    """

    return np.round(old_val * (nc - 1)) / (nc - 1)

'''



Floyd-Steinberg algo dithers the image into a palette with fixed colours per channel



F = 1/16 |  _  *   7  |

         |  3  5   1  |



Stucki

         |       *  8  4 | 

=  1/42  | 2  4  8  4  2 |

         | 1  2  4  2  1 |



where * is the current pixel



'''

def fs_dither(img, height=448, width=600):

    arr = np.array(img, dtype=int)

    for ir in range(height-1):    #new_height):
        
        for ic in range(width-1): # new_width):

            matches     = colour_map - np.tile(arr[ir, ic],(NUMBER_COLOURS,1))
            dist_match  = np.apply_along_axis(np.linalg.norm,1,matches)
            best_match  = np.argmin(dist_match)
            best_colour = colour_map[best_match]
            diff_best   = arr[ir,ic] - best_colour
            dist_best   = np.linalg.norm(diff_best)

            # Clamp to best colour

            arr[ir,ic] = best_colour

            # Error spread to adjacent pixels

            if dist_best > 88:      # Error threshold to prevent unnecessary dithering - 88 = ~20% error  45 ~ 10% 66 - 15%

                for factor,ir_d,ic_d in [(7,0,1),(3,1,-1),(5,1,0),(1,1,1)]:

                    arr[ir+ir_d, ic+ic_d][0] = min(arr[ir+ir_d, ic+ic_d][0] + round(diff_best[0] * factor/16,0),255)
                    arr[ir+ir_d, ic+ic_d][1] = min(arr[ir+ir_d, ic+ic_d][1] + round(diff_best[1] * factor/16,0),255)
                    arr[ir+ir_d, ic+ic_d][2] = min(arr[ir+ir_d, ic+ic_d][2] + round(diff_best[2] * factor/16,0),255)


    return Image.fromarray(np.uint8(arr))



# Create a new white image with the specified dimensions.
# Load the JPEG image.
# Rescale the JPEG image to have a height of 448 pixels while maintaining its aspect ratio.
# Paste the rescaled image onto the white image, aligning it to the left.

# from PIL import Image

def load_image(input_image):

        new_image = Image.new("RGB", (600, 448), "white")    # Create a new white image with a width of 600 pixels and a height of 448 pixels

        jpeg_image = Image.open(input_image)                 # Load the JPEG image

        aspect_ratio = jpeg_image.width / jpeg_image.height  # Rescale the JPEG image to have a height of 448 pixels and calculate the new width to maintain the aspect ratio
        new_height = 448
        new_width = int(aspect_ratio * new_height)
        rescaled_image = jpeg_image.resize((new_width, new_height)) #, Image.ANTIALIAS)

        new_image.paste(rescaled_image, (0, 0))              # Paste the rescaled image onto the white image, aligning it to the left

        return new_image

# Save or display the result
# new_image.show()  # To display the image
# white_image.save("output.jpg")  # To save the image



# =================================
# MAIN PROGRAM
# =================================

'''



The display dimensions of the ePaper device is



width  - 600

height - 448



We need to adjust according



TODO - rotate image based on best fit



'''

# rename files

##input_files = [file.name for file in os.scandir() if file.name[-3:]=="jpg"]
##
##for idx,input_file in enumerate(input_files):
##        day_of_year = (idx % 365) + 1
##        file_number = idx // 365
##        new_file_name = "%03d%03d.jpg" % (day_of_year, file_number)
##        print(new_file_name)
##

        



sys.exit()





start_time = dt.now()
print("Running",start_time)

input_files = [file.name for file in os.scandir() if file.name[-3:]=="jpg" and not os.path.exists(file.name[:-3]+"bmp")]

for input_image in input_files:

        print("Processing:",input_image)

        img = load_image(input_image)
        dim = fs_dither(img)

        if dim is not None:
            dim.save(input_image[:-3]+"bmp")
        else:
            print("ERROR: No image returned for",input_image)
            
    
print("Finished",dt.now()-start_time)













'''



from PIL import Image



# Open the larger calendar image

calendar = Image.open("calendar.bmp")



# Open the smaller weather image

weather = Image.open("weather.bmp")



# Get the dimensions of the calendar image

calendar_width, calendar_height = calendar.size



# Get the dimensions of the weather image

weather_width, weather_height = weather.size



# Calculate the position to paste the weather image

position = (calendar_width - weather_width, calendar_height - weather_height)



# Paste the weather image onto the calendar image at the calculated position

calendar.paste(weather, position)



# Save the modified calendar image

calendar.save("calendar_with_weather.bmp")



# Optionally, show the result

calendar.show()







































# test calendar code



from datetime import datetime



# Get the current date

current_date = datetime.now()



# Extract the current year and month as integers

current_year = current_date.year

current_month = current_date.month



# Print the year and month

print("Year:", current_year)

print("Month:", current_month)



current_date = datetime.now()



print(current_date.strftime("%A"))



print(current_date.strftime("%b %d, %Y"))



import calendar 

   

yy = 2025

mm = 1



cal = calendar.month(yy, mm)

cal_lines = cal.split(chr(10))



for cal_line in cal_lines[1:]:

        print(cal_line)



#print(cal)

#print(cal_lines)



#for char in cal:

#        print(ord(char))









# Downloader



##pipe = cDataPipe()

##pipe.new_pipe(html_list_iter([r"https://creator.nightcafe.studio/"])) 

##pipe.add_pipe(get_links,re.compile(r"(https:\/\/images\.nightcafe\.studio\/(?!\/assets)[A-z0-9\/\.\-]*jpg)"))

##pipe.add_pipe(pipe_inspector)

###pipe.end_pipe(cDownloader(file_namer="COUNTER",file_extension=".jpg").download)

##pipe.flow()

##

##sys.exit()











# width, height = img.size

#print(img.__dict__) #, width, height)

#new_width = 600

#new_height = int(height * new_width / width)

#img = img.resize((new_width, new_height), Image.ANTIALIAS)



def fs_dither_old(img, nc=2):



    arr = np.array(img, dtype=float) / 255



    for ir in range(new_height):



        for ic in range(new_width):

            

            # NB need to copy here for RGB arrays otherwise err will be (0,0,0)!



            old_val = arr[ir, ic].copy()

            new_val = get_new_val(old_val, nc)

            arr[ir, ic] = new_val

            err = old_val - new_val



            # In this simple example, we will just ignore the border pixels.



            if ic < new_width - 1:

                arr[ir, ic+1] += (err * 7/16)

            if ir < new_height - 1:

                if ic > 0:

                    arr[ir+1, ic-1] += (err * 3/16)

                arr[ir+1, ic] += (err * 5/16)

                if ic < new_width - 1:

                    arr[ir+1, ic+1] += (err / 16)



    carr = np.array(arr/np.max(arr, axis=(0,1)) * 255, dtype=np.uint8)



    return Image.fromarray(carr)







'''