kurt/generate-pngs

kurt/generate-pngs

Author: livingkurt

.gitignore

@@ -9,6 +9,7 @@
 !*.pattern
 !*.h
 !*.cpp
+!*.py
 !*.atsln
 !*.componentinfo.xml
 !*.cppproj
@@ -29,3 +30,6 @@
 # Ignore bitmap files
 *.bmp
 
+# Ignore png
+*.png
+

Helios/Patterns.cpp

@@ -82,7 +82,7 @@ void Patterns::make_pattern(PatternID id, Pattern &pat)
   default:
 
   case PATTERN_RIBBON:
-    args.on_dur = 9;
+    args.on_dur = 9; // 10 for flashing pattern circles
     break;
 
   case PATTERN_ULTRA_DOPS:
@@ -97,7 +97,7 @@ void Patterns::make_pattern(PatternID id, Pattern &pat)
 
   case PATTERN_STROBE:
     args.on_dur = 5;
-    args.off_dur = 8;
+    args.off_dur = 8; // 10 for flashing pattern circles
     break;
 
   case PATTERN_HYPNOSTROBE:
@@ -107,87 +107,87 @@ void Patterns::make_pattern(PatternID id, Pattern &pat)
 
   case PATTERN_STROBIE:
     args.on_dur = 3;
-    args.off_dur = 23;
+    args.off_dur = 23; // 21 for flashing pattern circles
     break;
 
   case PATTERN_RAZOR:
     args.on_dur = 3;
     args.off_dur = 1;
-    args.gap_dur = 30;
+    args.gap_dur = 30; // 29 for flashing pattern circles
     break;
 
   case PATTERN_FLARE:
     args.on_dur = 2;
-    args.off_dur = 30;
+    args.off_dur = 30; // 28 for flashing pattern circles
     break;
 
   case PATTERN_BURST:
     args.on_dur = 3;
-    args.off_dur = 40;
+    args.off_dur = 40; // 37 for flashing pattern circles
     break;
 
   case PATTERN_GLOW:
     args.on_dur = 2;
-    args.gap_dur = 40;
+    args.gap_dur = 40; // 39 for flashing pattern circles
     break;
 
   case PATTERN_FLICKER:
     args.on_dur = 1;
-    args.off_dur = 50;
+    args.off_dur = 50; // 44 for flashing pattern circles
     break;
 
   case PATTERN_FLASH:
     args.on_dur = 10;
-    args.off_dur = 250;
+    args.off_dur = 250; // 120 for flashing pattern circles
     break;
 
   case PATTERN_MORPH:
     args.on_dur = 9;
-    args.blend_speed = 5;
+    args.blend_speed = 5; // 14 for flashing pattern circles
     break;
 
   case PATTERN_MORPH_STROBE:
     args.on_dur = 5;
     args.off_dur = 8;
-    args.blend_speed = 10;
+    args.blend_speed = 10; // 19 for flashing pattern circles
     break;
 
   case PATTERN_MORPH_STROBIE:
     args.on_dur = 3;
     args.off_dur = 23;
-    args.blend_speed = 10;
+    args.blend_speed = 10; // 35 for flashing pattern circles
     break;
 
   case PATTERN_MORPH_GLOW:
     args.on_dur = 1;
     args.off_dur = 3;
-    args.gap_dur = 40;
+    args.gap_dur = 40; // 36 for flashing pattern circles
     args.blend_speed = 30;
     break;
 
   case PATTERN_DASH_DOPS:
     args.on_dur = 1;
     args.off_dur = 9;
     args.gap_dur = 6;
-    args.dash_dur = 15;
+    args.dash_dur = 15; // 17 for flashing pattern circles
     break;
 
   case PATTERN_DASH_DOT:
     args.on_dur = 2;
     args.off_dur = 3;
-    args.dash_dur = 24;
+    args.dash_dur = 24; // 22 for flashing pattern circles
     break;
 
   case PATTERN_WAVE_PARTICLE:
     args.on_dur = 1;
     args.off_dur = 9;
-    args.dash_dur = 5;
+    args.dash_dur = 5; // 10 for flashing pattern circles
     break;
 
   case PATTERN_LIGHTSPEED:
     args.on_dur = 2;
     args.off_dur = 3;
-    args.dash_dur = 24;
+    args.dash_dur = 24; // 23 for flashing pattern circles
     args.blend_speed = 10;
     break;
   }

HeliosCLI/Makefile

@@ -2,7 +2,7 @@
 .SUFFIXES:
 
 # List all make targets which are not filenames
-.PHONY: all tests clean clean_storage
+.PHONY: all tests clean pngs bmps clean_storage
 
 # compiler tool definitions
 CC=g++
@@ -105,6 +105,18 @@ FORCE:
 clean:
 	@$(RM) $(DFILES) $(OBJS) $(TARGETS) $(TESTS)
 
+# generate svg
+svgs: bmps
+	./generate_svgs.sh
+
+# generate pngs
+pngs: bmps
+	./generate_pngs.sh
+
+# generate pngs
+bmps:
+	./generate_bmps.sh -c
+
 clean_storage:
 	@echo "Cleaning Helios storage file..."
 	@$(RM) Helios.storage

HeliosCLI/cli_main.cpp

@@ -59,6 +59,7 @@ float brightness_scale = 1.0f;
 uint8_t minumum_brightness = 75;
 std::string initial_colorset_str = "";
 std::string initial_pattern_str = "";
+std::string initial_pattern_args_str = "";
 uint32_t initial_mode_index = 0;
 
 // used to switch terminal to non-blocking and back
@@ -106,6 +107,27 @@ int main(int argc, char *argv[])
     // re-initialize the current pattern
     Helios::cur_pattern().init();
   }
+  // set initial pattern args based on user arguments
+  if (initial_pattern_args_str.length() > 0) {
+    // parse the list of args into an array of ints
+    std::vector<uint32_t> vals;
+    std::istringstream ss(initial_pattern_args_str);
+    // push 6 args into the array
+    while (vals.size() < 6) {
+      std::string arg;
+      uint32_t val = 0;
+      // try to parse out a number
+      if (std::getline(ss, arg, ',')) {
+        val = strtoul(arg.c_str(), NULL, 10);
+      }
+      // push the val either 0 or parsed number
+      vals.push_back(val);
+    }
+    // construct pattern args from the array of values
+    PatternArgs args(vals[0], vals[1], vals[2], vals[3], vals[4], vals[5]);
+    // set the args of the current pattern
+    Helios::cur_pattern().setArgs(args);
+  }
   // Set the initial colorset based on user arguments
   if (initial_colorset_str.length() > 0) {
     std::stringstream ss(initial_colorset_str);
@@ -206,14 +228,15 @@ static void parse_options(int argc, char *argv[])
     {"min-brightness", required_argument, nullptr, 'm'},
     {"colorset", required_argument, nullptr, 'C'},
     {"pattern", required_argument, nullptr, 'P'},
+    {"pattern-args", required_argument, nullptr, 'A'},
     {"mode-index", required_argument, nullptr, 'I'},
     {"bmp", optional_argument, nullptr, 'b'},
     {"eeprom", no_argument, nullptr, 'E'},
     {"parse-save", required_argument, nullptr, 'S'},
     {"help", no_argument, nullptr, 'h'},
     {nullptr, 0, nullptr, 0}
   };
-  while ((opt = getopt_long(argc, argv, "xcqltisyamC:P:I:b::ES:h", long_options, &option_index)) != -1) {
+  while ((opt = getopt_long(argc, argv, "xcqltisyamC:P:A:I:b::ES:h", long_options, &option_index)) != -1) {
     switch (opt) {
     case 'x':
       // if the user wants pretty colors or hex codes
@@ -292,6 +315,10 @@ static void parse_options(int argc, char *argv[])
       // set the initial pattern from the string
       initial_pattern_str = optarg;
       break;
+    case 'A':
+      // set the initial pattern args from the string
+      initial_pattern_args_str = optarg;
+      break;
     case 'I':
       // set the initial mode index
       initial_mode_index = strtoul(optarg, NULL, 10);
@@ -534,6 +561,7 @@ static void print_usage(const char* program_name)
   fprintf(stderr, "Initial Pattern and Colorset (optional):\n");
   fprintf(stderr, "  -C, --colorset           Set the colorset of the first mode, ex: red,green,0x0000ff\n");
   fprintf(stderr, "  -P, --pattern            Set the pattern of the first mode, ex: 1 or blend\n");
+  fprintf(stderr, "  -A, --pattern-args       Set the pattern args of the first mode, ex: 1,2,3 or 1,2,3,4,5\n");
   fprintf(stderr, "  -I, --mode-index         Set the initial mode index, ex 4\n");
   fprintf(stderr, "\n");
   fprintf(stderr, "Other Options:\n");

HeliosCLI/convert_bmp_to_png.py

@@ -0,0 +1,72 @@
+from PIL import Image, ImageDraw, ImageFilter
+import numpy as np
+import argparse
+import os
+
+def map_pattern_to_circle(draw, pattern, center, outer_radius, thickness):
+    num_rings = 3  # Number of rings
+    gap_between_rings = thickness * 0.5  # Reduced gap between rings
+
+    segment_width = 1  # Width of each color segment in degrees
+    pattern_width = pattern.width
+
+    for ring in range(num_rings):
+        inner_radius = outer_radius - thickness - (ring * (thickness + gap_between_rings))
+        outer_r = inner_radius + thickness
+
+        for angle in range(0, 360, segment_width):
+            start_angle = angle - 90  # Adjust start angle (PIL uses 3 o'clock as 0 degrees)
+            end_angle = start_angle + segment_width
+
+            pattern_index = (angle // segment_width) % pattern_width
+            color = pattern.getpixel((pattern_index, 0))
+
+            if len(color) == 3:  # RGB
+                if color == (0, 0, 0):  # Black color
+                    continue  # Skip this segment (make it transparent)
+                fill_color = color + (255,)  # Add full opacity
+            elif len(color) == 4:  # RGBA
+                if color[:3] == (0, 0, 0):  # Black color
+                    continue  # Skip this segment (make it transparent)
+                fill_color = color
+
+            # Draw a filled arc
+            draw.arc([center[0] - outer_r, center[1] - outer_r,
+                      center[0] + outer_r, center[1] + outer_r],
+                     start=start_angle, end=end_angle, fill=fill_color, width=thickness)
+
+def create_circular_pattern(path_to_bmp):
+    print(f"-- Creating circular pattern for {path_to_bmp}")
+    pattern_strip = Image.open(path_to_bmp).convert('RGBA')  # Convert to RGBA
+
+    canvas_size = 1000  # Fixed canvas size for all patterns
+    canvas = Image.new('RGBA', (canvas_size, canvas_size), (0, 0, 0, 0))  # Transparent background
+    draw = ImageDraw.Draw(canvas)
+
+    center = (canvas_size // 2, canvas_size // 2)
+    outer_radius = int(canvas_size * 0.45)  # Adjusted for better fit
+    thickness = 50  # Adjusted thickness for balance
+
+    print(f"-- Canvas prepared with size {canvas_size}x{canvas_size}, center at {center}, outer radius {outer_radius}, and thickness {thickness}")
+    map_pattern_to_circle(draw, pattern_strip, center, outer_radius, thickness)
+
+    print("-- Pattern mapped successfully")
+
+    # Apply smoothing effect
+    smoothed_canvas = canvas.filter(ImageFilter.GaussianBlur(radius=2))
+    print("-- Smoothing effect applied")
+
+    return smoothed_canvas
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate a circular pattern from a BMP file.")
+    parser.add_argument("bmp_file", type=str, help="Path to the BMP file")
+    parser.add_argument("output_file", type=str, help="Path to the output PNG file")
+    args = parser.parse_args()
+
+    circular_pattern = create_circular_pattern(args.bmp_file)
+    circular_pattern.save(args.output_file)
+    print(f"** Saved smoothed circular pattern to {args.output_file}")
+
+if __name__ == "__main__":
+    main()

HeliosCLI/convert_bmp_to_svg.py

@@ -0,0 +1,88 @@
+import argparse
+import os
+from PIL import Image
+import svgwrite
+import math
+
+def create_circular_pattern_svg(path_to_bmp, output_file):
+    print(f"-- Creating circular pattern for {path_to_bmp}")
+    pattern_strip = Image.open(path_to_bmp).convert('RGBA')
+
+    canvas_size = 1000
+    center = canvas_size // 2
+    outer_radius = int(canvas_size * 0.45)
+    thickness = 50
+    num_rings = 3
+    gap_between_rings = thickness * 0.5
+
+    dwg = svgwrite.Drawing(output_file, size=(canvas_size, canvas_size))
+
+    for ring in range(num_rings):
+        inner_radius = outer_radius - thickness - (ring * (thickness + gap_between_rings))
+        outer_r = inner_radius + thickness
+
+        current_color = None
+        start_angle = 0
+
+        for angle in range(361):  # Go to 361 to close the loop
+            pattern_index = angle % pattern_strip.width
+            color = pattern_strip.getpixel((pattern_index, 0))
+
+            if len(color) == 3:  # RGB
+                fill_color = f'rgb{color}'
+                opacity = 1
+            elif len(color) == 4:  # RGBA
+                fill_color = f'rgb{color[:3]}'
+                opacity = color[3] / 255.0
+
+            if color[:3] == (0, 0, 0):  # Black color
+                fill_color = None
+                opacity = 0
+
+            if fill_color != current_color or angle == 360:
+                if current_color is not None:
+                    end_angle = angle
+                    path = create_arc_path(center, inner_radius, outer_r, start_angle, end_angle)
+                    dwg.add(dwg.path(d=path, fill=current_color, fill_opacity=current_opacity))
+
+                current_color = fill_color
+                current_opacity = opacity
+                start_angle = angle
+
+    print(f"-- Pattern mapped successfully")
+    dwg.save()
+    print(f"** Saved circular pattern to {output_file}")
+
+def create_arc_path(center, inner_radius, outer_radius, start_angle, end_angle):
+    start_angle_rad = math.radians(start_angle - 90)
+    end_angle_rad = math.radians(end_angle - 90)
+
+    x1 = center + inner_radius * math.cos(start_angle_rad)
+    y1 = center + inner_radius * math.sin(start_angle_rad)
+    x2 = center + outer_radius * math.cos(start_angle_rad)
+    y2 = center + outer_radius * math.sin(start_angle_rad)
+    x3 = center + outer_radius * math.cos(end_angle_rad)
+    y3 = center + outer_radius * math.sin(end_angle_rad)
+    x4 = center + inner_radius * math.cos(end_angle_rad)
+    y4 = center + inner_radius * math.sin(end_angle_rad)
+
+    large_arc_flag = 1 if end_angle - start_angle > 180 else 0
+
+    path = f'M {x1} {y1} '
+    path += f'L {x2} {y2} '
+    path += f'A {outer_radius} {outer_radius} 0 {large_arc_flag} 1 {x3} {y3} '
+    path += f'L {x4} {y4} '
+    path += f'A {inner_radius} {inner_radius} 0 {large_arc_flag} 0 {x1} {y1}'
+
+    return path
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate a circular pattern from a BMP file as SVG.")
+    parser.add_argument("bmp_file", type=str, help="Path to the BMP file")
+    parser.add_argument("output_file", type=str, help="Path to the output SVG file")
+    args = parser.parse_args()
+
+    create_circular_pattern_svg(args.bmp_file, args.output_file)
+
+if __name__ == "__main__":
+    main()