waves.py

@@ -2,79 +2,97 @@
 
 import cairo
 import math
-from datetime import datetime
+import datetime
 import calendar
 import random
-import colorsys
-import argparse
-
-
+from utils import random_color
+
+
+# dimensions of the output image
+WIDTH, HEIGHT = 1920, 1080
+# how much should the phases be offset?
+WAVE_OFFSET = math.pi / random.choice([1, 2, 4]) #-1.9 
+# amplitude of the sine wave
+#AMPLITUDE = 9
+# only 1 color with shades?
+MONOCHROME = True
+# works only if monochrome is set - uses todays date as base for the color
+DATE_BASED_COLOR = True
+DATE_BASED_AMPLITUDE = True
+DATE_BASED_COUNT = True
+# background black? White otherwise:
+DARK_BG = True
 # precision of the calculation
 PRECISION = 10000
 
-
-def get_color_from_date(date: datetime) -> tuple[float, float, float]:
-    """Return a color based on the progress through the year."""
+def days_color(date):
+    import colorsys
     # a day between 1 and 365 (inclusive)
     today = date.timetuple().tm_yday
-    days_in_year = 365 + calendar.isleap(date.year)
+    year = date.year
+    days_in_year = 365 + calendar.isleap(year)
     # between 0 and 1, how far through the year are we?
-    progress = today / days_in_year
+    progress = today/days_in_year
     return colorsys.hsv_to_rgb(progress, 1, 0.9)
 
-
-def get_amplitude_from_date(date: datetime, waves) -> float:
-    """Return the amplitude of waves, based on progress through the month."""
+def days_amp(date, waves):
+    day = date.day
     days_in_month = calendar.monthrange(date.year, date.month)[1]
-    max_amp = 1 / waves / 2
-    return date.day / days_in_month * max_amp
+    max_amp = 1/waves/2
+    return day/days_in_month * max_amp
 
+def days_count(date):
+    return date.month
 
-def create_wpotd(
-    width: int,
-    height: int,
-    frequency: int,
-    wave_offset: float,
-    date: datetime = datetime.now(),
-    dark: bool = True,
-) -> cairo.ImageSurface:
-    surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
+def create_wpotd(output):
+    surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, WIDTH, HEIGHT)
     ctx = cairo.Context(surface)
 
-    ctx.scale(width, height)  # Normalizing the canvas
-    # ctx.set_antialias(cairo.Antialias.BEST)
+    ctx.scale(WIDTH, HEIGHT)  # Normalizing the canvas
+    #ctx.set_antialias(cairo.Antialias.BEST)
 
-    lastpoints = [(x / PRECISION, 0) for x in range(PRECISION + 1)]
+    step_size = 1/PRECISION
+    lastpoints = [(x/PRECISION, 0) for x in range(PRECISION+1)]
 
-    waves = date.month
-    amplitude = get_amplitude_from_date(date, waves)
-
-    r, g, b = get_color_from_date(date)
-    alpha_step = 1 / waves
-
-    # background color
-    if dark:
-        ctx.set_source_rgb(0, 0, 0)
+    #date = datetime.datetime.strptime('2021-06-30', '%Y-%m-%d')
+    date = datetime.datetime.today()
+    frequency = random.randint(10, 40)
+    if DATE_BASED_COUNT:
+        waves = days_count(date)
+    else:
+        waves = 12
+    if DATE_BASED_AMPLITUDE:
+        amplitude = days_amp(date, waves)
     else:
-        ctx.set_source_rgb(255, 255, 255)
-    ctx.rectangle(0, 0, 1, 1)
-    ctx.fill()
+        amplitude = 25
     
-    wave_height = 1 / waves
-    step_size = 1 / PRECISION
+    if MONOCHROME:
+        if DATE_BASED_COLOR:
+            r, g, b = days_color(date) #datetime.datetime.now())
+        else:
+            r, g, b = random_color()
+        alpha_step = 1/waves
+    if DARK_BG:
+        # make bg black
+        ctx.rectangle(0, 0, 1, 1)
+        ctx.set_source_rgb(0, 0, 0)
+        ctx.fill()
 
-    for wave_index in range(waves + 1):
+    wave_height = 1/waves
+    for num in range(waves+1):
+        if not MONOCHROME:
+            r, g, b = random_color()
         points = []
         x = 0
         while x < 1:
-            # step along, create points along the wave
-            y = amplitude * math.sin(frequency * x + (wave_index * wave_offset))
-            points.append((x, (y + (0.5 + wave_index) * wave_height)))
+            y = amplitude * math.sin(frequency * x + (num * WAVE_OFFSET) ) 
+            points.append((x, ( y + (0.5+num)*wave_height)))
             x += step_size
-        # print(f'Draw {len(points)} points for curve {num}')
+        #print(f'Draw {len(points)} points for curve {num}')
+        if not MONOCHROME:
+            ctx.set_source_rgb(r, g, b)
         else:
-            # make more transparent toward bottom
-            ctx.set_source_rgba(r, g, b, 1 - (alpha_step * wave_index))
+            ctx.set_source_rgba(r, g, b, 1 - (alpha_step * num)) # make more transparent toward bottom
         # draw waves
         ctx.move_to(*points[0])
         for p in points[1:]:
@@ -86,45 +104,11 @@ def create_wpotd(
         ctx.line_to(*points[0])
         ctx.fill()
         lastpoints = points
-    return surface
-
+    #return surface
+    surface.write_to_png(output)  # Output to PNG
 
 def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("width", type=int, help="Width of the image")
-    parser.add_argument("height", type=int, help="Height of the image")
-    parser
-    parser.add_argument("--dark", help="Draw on dark background", action="store_true")
-    parser.add_argument(
-        "-o",
-        "--offset",
-        type=float,
-        help="How much the waves should be offset to each other",
-    )
-    parser.add_argument("-f", "--frequency", type=int, help="Frequency of the waves")
-    parser.add_argument(
-        "--stdout", help="Write output image to stdout", action="store_true"
-    )
-    args = parser.parse_args()
-    print(args)
-    if not args.offset:
-        args.offset = math.pi / random.choice([1, 2, 4])
-    if not args.frequency:
-        args.frequency = random.randint(10, 40)
-    output = create_wpotd(
-        args.width,
-        args.height,
-        dark=args.dark,
-        wave_offset=args.offset,
-        frequency=args.frequency,
-    )
-    if args.stdout:
-        import sys
-
-        output.write_to_png(sys.stdout.buffer)
-    else:
-        output.write_to_png("out/waves.png")
-
+    create_wpotd('out/waves.png')
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()