vissen-output 0.6.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ee97aa25edd367c68a4f113fac72270890711d5859eb61bec40a71470753fb8e
+  data.tar.gz: c1069056b86a4f7d62ab4e5d5602bcf5c8131d684e8dc9631955f2582d516e3a
+SHA512:
+  metadata.gz: 7475b3b4f78d4fd8f0a656d9dc3e45ade1af5a06e1596df9faa5de8eaa508c3489001b714aaf8f509f9b09d9416ecd99c95ac8682aa17f4cc5ced85003299ad1
+  data.tar.gz: 9c552a4b52af3646f6459116e3dda5a297c147886f90c261bb85448b1c978eda53155f68028d186af7b7fa0a77c428e4c9e598ae2ae2ebfb67069e46f2ba54ab

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,64 @@
+AllCops:
+  Exclude:
+    - 'vendor/**/*'
+    - 'tmp/**/*'
+  TargetRubyVersion: 2.5
+
+Style/FrozenStringLiteralComment:
+  EnforcedStyle: always
+
+Layout/EndOfLine:
+  EnforcedStyle: lf
+
+Layout/ClassStructure:
+  Enabled: true
+  Categories:
+    module_inclusion:
+      - include
+      - prepend
+      - extend
+  ExpectedOrder:
+      - module_inclusion
+      - constants
+      - public_class_methods
+      - initializer
+      - instance_methods
+      - protected_methods
+      - private_methods
+
+Layout/IndentHeredoc:
+  EnforcedStyle: squiggly
+
+Lint/AmbiguousBlockAssociation:
+  Exclude:
+    - 'test/**/*.rb'
+
+Lint/InterpolationCheck:
+  Exclude:
+    - 'test/**/*.rb'
+
+Metrics/BlockLength:
+  Exclude:
+    - 'Rakefile'
+    - '**/*.rake'
+    - 'test/**/*.rb'
+
+Metrics/ModuleLength:
+  Exclude:
+    - 'test/**/*.rb'
+
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+
+Naming/UncommunicativeMethodParamName:
+  AllowedNames:
+    - x
+    - y
+    - i
+    - p
+    - n
+    - r
+    - g
+    - b
+    - to
+    

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 1.16.1

data/CHANGELOG.md

@@ -0,0 +1,61 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+## [0.6.1] - 2018-04-20
+### Changed
+- Improved, more descriptive comments.
+
+## [0.6.0] - 2018-04-14
+### Added
+- Output filter support in PixelBuffer.
+- More descriptive ContextErrors that are raised when contexts do not match.
+
+### Changed
+- Grid context now accepts a with and height instead of an aspect ratio.
+
+## [0.5.1] - 2018-04-14
+### Added
+- PixelBuffer#finalize!.
+- The convenience method Context::Cloud.scatter that randomly places n points.
+
+### Fixed
+- A bug in the Circle context caused the circle to be centered in (0,0), rather than in the center of the context.
+
+## [0.5.0] - 2018-04-13
+### Changed
+- Changed the name of the Cloud module to Buffer to distance it from the cloud context.
+- Moved all context to their own submodule.
+- Changed the name of the PixelCloud to PixelBuffer to better indicate what it should be used for.
+- Changed the name of the VixelCloud to VixelBuffer to better indicate what it should be used for.
+
+### Removed
+- The Grid class.
+
+## [0.4.1] - 2018-04-13
+### Added
+- A Circle context.
+
+### Changed
+- Improved the documentation.
+
+## [0.4.0] - 2018-04-10
+### Added
+- Output filters.
+- Gamma filter.
+- Quantizer filter.
+- Introduced the more general concept of point clouds.
+- Created the Context as a more general form of the GridContext.
+- Create a new CloudContext that handles arbitrarily positioned Point objects.
+
+### Changed
+- Made the Grid into a special kind of Cloud.
+- Made the VixelGrid into a VixelCloud.
+- Made the PixelGrid into a PixelCloud.
+- The GridContext is now a class instead of a module.
+- The Stack is now longer a GridContext but instead accepts one as its first argument.
+- The argument order of Vixel.new is now reversed, so that is is alphabetical.
+- Renamed Stack -> VixelStack.

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in vissen-output.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,46 @@
+PATH
+  remote: .
+  specs:
+    vissen-output (0.6.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.0)
+    docile (1.3.0)
+    json (2.1.0)
+    minitest (5.11.3)
+    parallel (1.12.1)
+    parser (2.5.1.0)
+      ast (~> 2.4.0)
+    powerpack (0.1.1)
+    rainbow (3.0.0)
+    rake (10.5.0)
+    rubocop (0.55.0)
+      parallel (~> 1.10)
+      parser (>= 2.5)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.9.0)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    unicode-display_width (1.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  minitest (~> 5.0)
+  rake (~> 10.0)
+  rubocop (~> 0.52)
+  simplecov (~> 0.16)
+  vissen-output!
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Sebastian Lindberg
+
+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,40 @@
+# Vissen::Output
+
+[![Build Status](https://travis-ci.org/midi-visualizer/vissen-output.svg?branch=master)](https://travis-ci.org/midi-visualizer/vissen-output)
+[![Inline docs](http://inch-ci.org/github/midi-visualizer/vissen-output.svg?branch=master)](http://inch-ci.org/github/midi-visualizer/vissen-output)
+
+The Vissen Output library implements the objects used by the Vissen Engine to talk to the various sinks.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'vissen-output'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vissen-output
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` 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 tags, 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/midi-visualizer/vissen-output.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rubocop/rake_task'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+RuboCop::RakeTask.new(:rubocop) do |t|
+  t.options = ['-a']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'vissen/output'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require 'pry'
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/vissen/output/buffer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Vissen
+  module Output
+    # Buffer
+    #
+    #
+    module Buffer
+      extend Forwardable
+
+      # @return [Context] the context of the buffer.
+      attr_reader :context
+
+      # @return [Object] the elements at the buffer points.
+      attr_reader :elements
+
+      def_delegators :@context, :width, :height
+      def_delegators :@elements, :each, :each_with_index
+
+      # The grid is setup with a grid context as well as a class to places
+      # instances of in every grid point.
+      #
+      # @raise  [ArgumentError] if both an element class and a block are given.
+      #
+      # @param  context [Context] the context in which the buffer exists.
+      # @param  elements_klass [Class] the class to use when allocating
+      #   elements.
+      # @param  block [Proc] the block to use instead of `elements_klass` when
+      #   allocating element objects.
+      def initialize(context, elements_klass = nil, &block)
+        @context  = context
+        @elements =
+          if block_given?
+            raise ArgumentError if elements_klass
+            context.alloc_points(&block).freeze
+          else
+            context.alloc_points(elements_klass).freeze
+          end
+      end
+
+      # Prevents the context and element array from being changed.
+      #
+      # @return [self]
+      def freeze
+        @elements.freeze
+        super
+      end
+
+      # Context specific element accessor. Depends on `Context#index_from` to
+      # transform `args` into an index.
+      #
+      # @param  args (see Context#index_from).
+      # @return [Object] the element at the given index.
+      def [](*args)
+        @elements[@context.index_from(*args)]
+      end
+
+      # Iterates over each element in the buffer and yields the element along
+      # with its x and y coordinates.
+      #
+      # @return (see Context#each_position).
+      def each_with_position
+        return to_enum(__callee__) unless block_given?
+        @context.each_position { |i, x, y| yield @elements[i], x, y }
+      end
+
+      # Two buffers are considered equal if they share the same context.
+      #
+      # @param  other [#context, Object]
+      # @return [true, false] true if the other object share the same context.
+      def share_context?(other)
+        @context == other.context
+      rescue NoMethodError
+        false
+      end
+
+      alias === share_context?
+    end
+  end
+end

data/lib/vissen/output/color.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Vissen
+  module Output
+    # Basic value object representing a color in the RGB color space.
+    #
+    # == Usage
+    # The following example creates two colors, mixes them, and converts the
+    # result to an array of color component.
+    #
+    #   color_a = Color.new 0.3, 0.6, 0.2
+    #   color_b = Color.new 0.1, 0.2, 0.5
+    #
+    #   color_a.mix_with(color_b, 0.5).to_a => [0.2, 0.3, 0.35]
+    #
+    class Color
+      # Accessors for the red, green and blue color components.
+      attr_accessor :r, :g, :b
+
+      # @param  r [Float] the red color value in the range (0..1).
+      # @param  g [Float] the green color value in the range (0..1).
+      # @param  b [Float] the blue color value in the range (0..1).
+      def initialize(r = 0.0, g = 0.0, b = 0.0)
+        @r = r
+        @g = g
+        @b = b
+      end
+
+      # Color equality based on component values.
+      #
+      # TODO: Add some small delta around what is considered the same color?
+      #       Perhaps scale to 255 and floor before comparing?
+      #
+      # @param  other [Object] the object to check equality against.
+      # @return [true, false] true when two colors are exactly the same.
+      def ==(other)
+        r == other.r && g == other.g && b == other.b
+      rescue NoMethodError
+        false
+      end
+
+      # Creates a new array from the color.
+      #
+      # @return [Array<Float>] a new array containing the red, green and blue
+      #   color values.
+      def to_a
+        [r, g, b]
+      end
+
+      # rubocop:disable Metrics/AbcSize
+
+      # Moves this color toword the other based on the given ratio.
+      #
+      # ratio = 0 -> 100 % of this color
+      # ratio = 1 -> 100 % of the other color
+      #
+      # @param  other [Color] the color to mix with
+      # @param  ratio [Float] the amount (0..1) of the other color to mix in.
+      # @return [self]
+      def mix_with!(other, ratio)
+        anti_ratio = (1 - ratio)
+
+        self.r = r * anti_ratio + other.r * ratio
+        self.g = g * anti_ratio + other.g * ratio
+        self.b = b * anti_ratio + other.b * ratio
+
+        self
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # Returns a new color that is a mix between this and the other color,
+      # based on the ratio. See `#mix_with!` for more details.
+      #
+      # @param  (see #mix_with!)
+      # @return [Color] the result of the mix.
+      def mix_with(other, ratio)
+        dup.mix_with! other, ratio
+      end
+
+      # Returns a string formatted in the tradiotioal hex representation of a
+      # color: #04A4BF.
+      #
+      # @return [String] the object string representation.
+      def inspect
+        format('#%02X%02X%02X', *to_a.map! { |v| (v * 255).round })
+      end
+
+      class << self
+        # Cast a given object to a color.
+        #
+        # @param  obj [Color, Array<Numeric>, Integer, #to_a] the object to
+        #   coerce.
+        # @return [Color] a new color object.
+        def from(obj)
+          case obj
+          when self    then obj
+          when Array   then new(*obj)
+          when Integer then from_integer obj
+          else
+            new(*obj.to_a)
+          end
+        end
+
+        private
+
+        def from_integer(int)
+          b = (int & 0xFF) / 255.0
+          int >>= 8
+          g = (int & 0xFF) / 255.0
+          int >>= 8
+          r = (int & 0xFF) / 255.0
+
+          new r, g, b
+        end
+      end
+    end
+  end
+end

data/lib/vissen/output/context/circle.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Vissen
+  module Output
+    module Context
+      # Output context with the points placed counter clockwise on a circle. By
+      # specifying an offset it is possible to adjust the position of the end
+      # points of the element array.
+      class Circle < Cloud
+        # @param  point_count [Integer] the number of points.
+        # @param  offset [Numeric] the angle offset, in radians, of the first
+        #   point.
+        # @param  width [Numeric] (see Context)
+        # @param  height [Numeric] (see Context)
+        # @param  radius [Numeric] the radius of the context.
+        # @param  args (see CloudContext).
+        def initialize(point_count,
+                       offset: 0,
+                       width: 1.0,
+                       height: 1.0,
+                       radius: [width, height].min / 2.0,
+                       **args)
+
+          circle = self.class.position_generator(point_count, radius, offset)
+          center = [width.to_f / 2, height.to_f / 2]
+          points = self.class.place_points circle, center
+
+          super(points, width: width, height: height, **args)
+        end
+
+        class << self
+          # Creates a generator (`Enumerator`) for x and y coordinates
+          # equidistantly placed along a circle centered around (0, 0).
+          #
+          # @param  point_count [Integer] the number of points along the circle.
+          # @param  radius [Numeric] the radius of the circle.
+          # @param  offset [Numeric] the angular offset of the first point. An
+          #   offset of pi/2 would place the first point at the twelve o'clock
+          #   position.
+          # @return [Enumerator] an enumerator that yields `point_count` x and y
+          #   coordinates along a circle.
+          def position_generator(point_count, radius, offset = 0)
+            angle_factor = 2.0 * Math::PI / point_count
+
+            Enumerator.new(point_count) do |y|
+              point_count.times do |index|
+                angle = index * angle_factor + offset
+                y << [radius * Math.cos(angle), radius * Math.sin(angle)]
+              end
+            end
+          end
+
+          # Uses a position generator to allocate an array of `Point` objects
+          # placed arount a circle centered around the given coordinates.
+          #
+          # @param  generator [Enumerator] the position generator
+          #   (see .position_generator).
+          # @param  center [Array<Numeric>] the x and y coordinates of the
+          #   circle center.
+          # @return [Array<Point>] an array of `Point` objects placed around a
+          #   circle.
+          def place_points(generator, center)
+            x0, y0 = center
+            generator.map { |x, y| Point.new x0 + x, y0 + y }
+          end
+        end
+      end
+    end
+  end
+end