jazzicon 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1c28a74ab282c10c0caea691c048f7bc5598ee0cc92a867950b8bd20176cd4e2
+  data.tar.gz: befd3d81c9bbed1bfcecac4bc6d911761f053814eb2066d27ce8904b13c36444
+SHA512:
+  metadata.gz: 7c5d2eef67d11f3284e34f567ea236510fca7f746f9e4281a645aa7b6121bc9436a78a777401bcdbf08a0d0f140512497423c588184f8d147e44692db3f1e723
+  data.tar.gz: 892a0e2f7a0d3ec3a14208f1df3f283392a0e419a7f0e3c8cbfd0c556fdf3dbfe4e5cbe8b434ab8298309204313bb26e2c3566f310653b8e13028c03d64c011d

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Arux Software, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,44 @@
+# Jazzicon
+
+This is a ruby port of https://github.com/danfinlay/jazzicon
+
+> Say goodbye to boring blocky identicons that look like they came out of the 70s, and replace them with jazzy, colorful collages that more likely came out of the 80's.
+
+![Example](https://github.com/Arux-Software/jazzicon_ruby/examples.png?raw=true)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jazzicon'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install jazzicon
+
+## Usage
+
+```ruby
+require 'jazzicon'
+Jazzicon::Icon.generate("random string or integer").save("icon.png")
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Arux-Software/jazzicon_ruby.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/jazzicon/helpers/color_helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Jazzicon
+  HUE_WOBBLE = 30
+  # The Jazzicon::ColorHelpers module provides color-related helper methods.
+  module ColorHelpers
+    # Shifts the hue of the given colors by a random amount.
+    #
+    # @param colors [Array<String>] Array of hex color strings.
+    # @param random [Random] Random object for deterministic randomness.
+    # @return [Array<String>] Array of hue-shifted colors.
+    def self.hue_shift(colors, random)
+      amount = (random.rand * 30) - (HUE_WOBBLE / 2.0)
+
+      colors.map do |hex|
+        hsl = ChunkyPNG::Color.to_hsl(ChunkyPNG::Color.from_hex(hex))
+        hsl[0] = (hsl[0] + amount) % 360
+        hsl[3] = 255
+        ChunkyPNG::Color.from_hsl(*hsl)
+      end
+    end
+  end
+end

data/lib/jazzicon/helpers/geometry_helpers.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Jazzicon
+  Rectangle = Struct.new(:corners, keyword_init: true)
+  Point = Struct.new(:x, :y, keyword_init: true)
+  Size = Struct.new(:width, :height, keyword_init: true)
+
+  # The Jazzicon::GeometryHelpers module provides methods for geometric calculations and operations.
+  module GeometryHelpers
+    # Adds a randomly positioned and rotated rectangle to the given image.
+    #
+    # @param image [ChunkyPNG::Image] The image to modify.
+    # @param diameter [Integer] The diameter of the image.
+    # @param color [String] The color of the rectangle.
+    # @param index [Integer] The index of the current shape.
+    # @param total [Integer] The total number of shapes.
+    # @param random_numbers [Array<Float>] Array of random numbers for positioning and rotation.
+    def self.random_rectangle(diameter, index, total, random_numbers)
+      velocity, rotation, angle = generate_momentum(diameter, index, total, random_numbers)
+      center = diameter / 2.0
+
+      point = Point.new(
+        x: center + (Math.cos(angle) * velocity),
+        y: center + (Math.sin(angle) * velocity)
+      )
+      size = Size.new(width: diameter, height: diameter)
+
+      # Draw the rectangle
+      rotated_rectangle(point, size, rotation, center)
+    end
+
+    private_class_method def self.generate_momentum(diameter, index, total, random_numbers)
+      first_rot = random_numbers.pop
+      velocity = (diameter / total * random_numbers.pop) + (index * diameter / total)
+      rotation = (first_rot * 360) + (random_numbers.pop * 180)
+      angle = Math::PI * 2 * first_rot
+
+      [velocity, rotation, angle]
+    end
+
+    # Draws a rotated rectangle on the image.
+    #
+    # @param image [ChunkyPNG::Image] The image to modify.
+    # @param x [Float] The x-coordinate of the rectangle's center.
+    # @param y [Float] The y-coordinate of the rectangle's center.
+    # @param width [Float] The width of the rectangle.
+    # @param height [Float] The height of the rectangle.
+    # @param color [String] The color of the rectangle.
+    # @param rotation [Float] The rotation angle in degrees.
+    # @param center [Float] The center point of the image.
+    def self.rotated_rectangle(point, size, rotation, center)
+      # Define the four corners of the rectangle
+      corners = rotate_corners(calculate_corners(point, size), rotation, center)
+      Rectangle.new(corners: corners)
+    end
+
+    # Calculates the four corners of a rectangle given its width and height.
+    #
+    # @param x [Float] The x-coordinate of the rectangle's center.
+    # @param y [Float] The y-coordinate of the rectangle's center.
+    # @param width [Float] The width of the rectangle.
+    # @param height [Float] The height of the rectangle.
+    # @return [Array<Array<Float>>] Array of coordinates representing the rectangle's corners.
+    def self.calculate_corners(point, size)
+      half_width = size.width / 2
+      half_height = size.height / 2
+
+      offsets = [
+        [-half_width, -half_height], # Top-left
+        [half_width, -half_height], # Top-right
+        [half_width, half_height],  # Bottom-right
+        [-half_width, half_height]  # Bottom-left
+      ]
+
+      offsets.map { |dx, dy| Point.new(x: point.x + dx, y: point.y + dy) }
+    end
+
+    # Rotates the given corners of a rectangle around its center.
+    #
+    # @param corners [Array<Array<Float>>] Array of rectangle corner coordinates.
+    # @param rotation [Float] The rotation angle in degrees.
+    # @param center [Float] The center point of the image.
+    # @return [Array<Array<Float>>] Array of rotated corner coordinates.
+    def self.rotate_corners(corners, rotation, center)
+      rad_rotation = rotation * Math::PI / 180
+
+      corners.map do |point|
+        rotate_point(point, rad_rotation, center)
+      end
+    end
+
+    private_class_method def self.rotate_point(point, rad_rotation, center)
+      point.x -= center
+      point.y -= center
+      cos_theta = Math.cos(rad_rotation)
+      sin_theta = Math.sin(rad_rotation)
+
+      [
+        (cos_theta * point.x) - (sin_theta * point.y) + center,
+        (sin_theta * point.x) + (cos_theta * point.y) + center
+      ]
+    end
+  end
+end

data/lib/jazzicon/helpers/image_helpers.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "chunky_png"
+
+module Jazzicon
+  # The Jazzicon::ImageHelpers module provides methods for adjusting the whole image.
+  module ImageHelpers
+    # Crops the image to a perfect circle.
+    #
+    # @param image [ChunkyPNG::Image] The image to crop.
+    # @param diameter [Integer] The diameter of the circle.
+    def self.crop_to_circle(image, diameter)
+      center = diameter / 2.0
+      radius = diameter / 2.0
+
+      image.height.times do |y|
+        image.width.times do |x|
+          # Check if the pixel is outside the circle
+          outside = (((x - center)**2) + ((y - center)**2)) > radius**2
+          image.set_pixel(x, y, ChunkyPNG::Color::TRANSPARENT) if outside
+        end
+      end
+    end
+  end
+end

data/lib/jazzicon/icon.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "chunky_png"
+require "digest"
+
+require_relative "helpers/color_helpers"
+require_relative "helpers/geometry_helpers"
+require_relative "helpers/image_helpers"
+
+module Jazzicon
+  COLORS = [
+    "#01888C", "#FC7500", "#34E90B", "#FF4A4A",
+    "#662E9B", "#FC7500", "#0284C7", "#A0D911",
+    "#A855F7", "#FF7875"
+  ].freeze
+  Iteration = Struct.new(:index, :color, :random_numbers, keyword_init: true)
+
+  # The Jazzicon::Icon class provides functionality to generate jazzy and colorful identicons.
+  # These identicons are generated based on a given seed and can be customized by specifying the diameter and the number
+  # of shapes that make up the icon.
+  #
+  # The main steps involved in generating an icon include:
+  # - Hashing the seed to ensure deterministic randomness.
+  # - Randomly selecting and hue-shifting colors.
+  # - Generating and combining multiple layers of shapes (rectangles) to create a visually distinctive pattern.
+  # - Cropping the image into a circular form.
+  #
+  # Key Features:
+  # - Deterministic: The same seed always produces the same icon.
+  # - Customizable: Supports customization of diameter and shape count.
+  #
+  # Dependencies:
+  # - `chunky_png`: Used for image creation and manipulation.
+  #
+  # Example Usage:
+  # ```
+  # require "jazzicon/icon"
+  #
+  # seed = "example-seed"
+  # diameter = 500
+  # shape_count = 4
+  #
+  # icon = Jazzicon::Icon.generate(seed, diameter: diameter, shape_count: shape_count)
+  # icon.save("icon.png")
+  # ```
+  class Icon
+    # Generates a unique icon based on the given seed.
+    #
+    # @param seed [String, Integer] The input seed used to generate the icon.
+    # @param diameter [Integer] The diameter of the generated icon.
+    # @param shape_count [Integer] The number of shapes to include in the icon.
+    # @return [ChunkyPNG::Image] The generated icon image.
+    def self.generate(seed, diameter: 500, shape_count: 4)
+      random = random(seed)
+      colors = ColorHelpers.hue_shift(COLORS.shuffle(random: random), random)
+
+      final_image = ChunkyPNG::Image.new(diameter, diameter, colors.delete(colors.sample(random: random)))
+
+      # Generate each shape and adds it
+      iterations(shape_count, colors, random).each do |iteration|
+        rec = GeometryHelpers.random_rectangle(diameter, iteration.index, shape_count, iteration.random_numbers)
+        final_image.polygon(rec.corners, iteration.color, iteration.color)
+      end
+
+      # Crop to a perfect circle
+      ImageHelpers.crop_to_circle(final_image, diameter)
+
+      # Profit!$!
+      final_image
+    end
+
+    private_class_method def self.random(seed)
+      # Hash the seed if it is a string
+      seed = Digest::SHA256.hexdigest(seed).to_i(16) if seed.is_a?(String)
+      Random.new(seed)
+    end
+
+    private_class_method def self.iterations(shape_count, colors, random)
+      (0...shape_count).map do |i|
+        Iteration.new(
+          index: i,
+          color: colors.delete(colors.sample(random: random)),
+          random_numbers: 3.times.map { random.rand }
+        )
+      end
+    end
+  end
+end

data/lib/jazzicon/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Jazzicon
+  VERSION = "0.1.0"
+end

data/lib/jazzicon.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "jazzicon/version"
+require "jazzicon/icon"
+
+module Jazzicon
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: jazzicon
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stephen Heuer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-01-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chunky_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: Jazzicon is a Ruby implementation of the javascript Jazzicon identicon
+  generator (https://github.com/danfinlay/jazzicon).
+email:
+- sheuer@aruxsoftware.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE.txt
+files:
+- LICENSE.txt
+- README.md
+- lib/jazzicon.rb
+- lib/jazzicon/helpers/color_helpers.rb
+- lib/jazzicon/helpers/geometry_helpers.rb
+- lib/jazzicon/helpers/image_helpers.rb
+- lib/jazzicon/icon.rb
+- lib/jazzicon/version.rb
+homepage: https://github.com/Arux-Software/jazzicon_ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Arux-Software/jazzicon_ruby
+  source_code_uri: https://github.com/Arux-Software/jazzicon_ruby
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: A Ruby implementation of the javascript Jazzicon identicon generator.
+test_files: []