normal_map 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in normalmapper.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Colin MacKenzie IV
+
+MIT License
+
+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,47 @@
+# Normalmapper
+
+Command line tool and Ruby library for generating normal maps.
+
+Generates DOT3 bump maps, also known as normal maps, for use in 3D computing.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'normal_map'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install normal_map
+
+
+## Command Line Usage
+
+Generate a normal map from a regular full-color image:
+
+  Usage:
+    normal-map generate [options] COLORS NORMALS
+
+  Options:
+    -s, [--smooth]    # Average adjacent pixels to produce a smoother map
+    -d, [--diagonal]  # Consider diagonally-adjacent pixels in normal 
+                        calculations
+    -w, [--wrap]      # Wrap edge pixels to the opposite edge, to make the 
+                        map more tile-friendly
+
+  Generates a normal map from COLORS and saves it to NORMALS
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/normal-map

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'normal_map'
+NormalMap::CLI.start ARGV

data/lib/normal_map.rb

@@ -0,0 +1,193 @@
+require 'RMagick'
+
+class NormalMap
+  autoload :CLI,          'normal_map/cli'
+  autoload :Version,      'normal_map/version'
+  autoload :VERSION,      'normal_map/version'
+
+  include Magick
+  attr_reader :colors
+
+  def initialize filename, opts = {}
+    @colors = ImageList.new(filename)[0]
+    opts.each do |k, v|
+      instance_variable_set :"@#{k}", v
+    end
+    convert!
+  end
+
+  def to_blob *a, &b
+    to_image.to_blob *a, &b
+  end
+
+  def print *args
+    out.print *args unless silent?
+  end
+
+  def puts *args
+    out.puts *args unless silent?
+  end
+
+  # If true, calculated normals will be averaged with adjacent normals
+  # to produce a smoother, but less accurate, normal map.
+  def smooth?
+    !!@smooth
+  end
+
+  # If true, pixel coordinates out of range will be wrapped to the other
+  # side of the texture; otherwise, they will be clamped to the edge of
+  # the texture.
+  def wrap?
+    !!@wrap
+  end
+
+  # If true, nothing will be output during generation.
+  def silent?
+    !!@silent
+  end
+
+  # If true, normals will be calculated from diagonally adjacent pixels
+  # as well as vertically and horizontally adjacent. If `smooth` is also
+  # true, diagonal pixels will be considered in the smoothing algorithm
+  # as well.
+  def diagonal?
+    !!@diagonal
+  end
+
+  # The output stream to receive status updates. Defaults to `$stdout`.
+  def out
+    @out ||= $stdout
+  end
+
+  def to_image
+    normals
+  end
+
+  def normals
+    @normals ||= Image.new width, height
+  end
+
+  def convert!
+    total = width * height
+    increment = 0.05
+    current = 0
+    frac = 1.0 / total
+    pixels = Array.new total
+    width.times do |x|
+      height.times do |y|
+        current += frac
+        increment = progress current, increment
+        normal = calculate_normal x, y
+        normal[0] = normal[0] * 0.5 + 0.5
+        normal[1] = normal[1] * 0.5 + 0.5
+        normal[2] = normal[2] * 0.5 + 0.5
+        pixels[offset x, y] = Pixel.new normal[0] * QuantumRange,
+                                        normal[1] * QuantumRange,
+                                        normal[2] * QuantumRange, 
+                                        QuantumRange
+      end
+    end
+    normals.store_pixels 0, 0, width, height, pixels
+    puts
+  end
+
+  def progress percent, increment
+    if percent >= increment
+      print '.'
+      increment += 0.05
+    end
+    percent = (percent*100).to_i.to_s
+    print "  => ", percent, "%", "\b" * (percent.length + 6)
+    increment
+  end
+
+  def pixels
+    @pixels ||= colors.get_pixels 0, 0, width, height
+  end
+
+  def calculate_normal x, y
+    sx, sy = width, height
+    
+    # vertical/horizontal
+    az = intensity x+1, y
+    bz = intensity x, y+1
+    cz = intensity x-1, y
+    dz = intensity x, y-1
+    normal = normalize [cz - az, dz - bz, 2 ]
+
+    if diagonal?
+      # diagonal
+      az = intensity x+1, y+1
+      bz = intensity x-1, y+1
+      cz = intensity x+1, y-1
+      dz = intensity x-1, y-1
+      normal2 = normalize [cz - az, dz - bz, 2 ]
+      
+      # average them together
+      normal[0] = (normal[0] + normal2[0]) * 0.5
+      normal[1] = (normal[1] + normal2[1]) * 0.5
+      normal[2] = (normal[2] + normal2[2]) * 0.5
+    end
+
+    normal
+  end
+
+  def intensity(x, y)
+    # return intensity averaged with all adjacent pixels to produce
+    # a smoother result. Weight the current pixel to give it a little
+    # more influence.
+    if smooth?
+      sum = 0.0
+      sum += raw_intensity x-1, y
+      sum += raw_intensity x+1, y
+      sum += raw_intensity x, y-1
+      sum += raw_intensity x, y+1
+      if diagonal?
+        sum += raw_intensity x-1, y-1
+        sum += raw_intensity x-1, y+1
+        sum += raw_intensity x+1, y-1
+        sum += raw_intensity x+1, y+1
+        sum /= 8.0
+      else
+        sum / 4.0
+      end
+    else
+      raw_intensity x, y
+    end
+  end
+
+  def raw_intensity(x, y)
+    if wrap?
+      x += width  if x < 0
+      x -= width  if x >= width
+      y += height if y < 0
+      y -= height if y >= height
+    else
+      x = 0          if x <  0
+      x = width  - 1 if x >= width
+      y = 0          if y <  0
+      y = height - 1 if y >= height
+    end
+    pixels[offset x, y].intensity.to_f / QuantumRange.to_f
+  end
+
+  def offset x, y
+    y * width + x
+  end
+
+  def normalize vec
+    mag = 1.0 / Math.sqrt(vec[0]**2 + vec[1]**2 + vec[2]**2)
+    vec[0] *= mag
+    vec[1] *= mag
+    vec[2] *= mag
+    vec
+  end
+
+  def width
+    @width ||= colors.columns
+  end
+
+  def height
+    @height ||= colors.rows
+  end
+end

data/lib/normal_map/cli.rb

@@ -0,0 +1,16 @@
+require 'thor'
+
+class NormalMap::CLI < Thor
+  include Thor::Actions
+
+  desc "generate [options] COLORS NORMALS",
+       "Generates a normal map from COLORS and saves it to NORMALS"
+  method_option :smooth, :type => :boolean, :default => false, :aliases => '-s', :desc => "Average adjacent pixels to produce a smoother accurate map"
+  method_option :diagonal, :type => :boolean, :default => false, :aliases => '-d', :desc => "Consider diagonally-adjacent pixels in normal calculations"
+  method_option :wrap, :type => :boolean, :default => false, :aliases => '-w', :desc => "Wrap edge pixels to the opposite edge, to make the map more tile-friendly"
+  def generate colors_fn, normals_fn
+    create_file normals_fn do
+      NormalMap.new(colors_fn, options).to_blob { |f| f.format = "PNG" }
+    end
+  end
+end

data/lib/normal_map/version.rb

@@ -0,0 +1,8 @@
+class NormalMap
+  module Version
+    MAJOR, MINOR, TINY = 0, 0, 1
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+
+  VERSION = Version::STRING
+end

data/normal_map.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/normal_map/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Colin MacKenzie IV"]
+  gem.email         = ["sinisterchipmunk@gmail.com"]
+  gem.description   = %q{Generates DOT3 bump maps, also known as normal maps, for use in 3D computing.}
+  gem.summary       = %q{Command line tool and Ruby library for generating normal maps.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "normal_map"
+  gem.require_paths = ["lib"]
+  gem.version       = NormalMap::VERSION
+  gem.add_dependency 'thor'
+  gem.add_dependency 'rmagick'
+  gem.add_development_dependency 'rspec'
+end

data/spec/lib/normal_map_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe NormalMap do
+  let(:filename) { fixture_path 'in.png' }
+  let(:options) { {} }
+  subject { NormalMap.new filename, options }
+
+  shared_examples_for "expected result" do
+    it "should produce expected result" do
+      subject.to_blob { self.format = 'PNG' }.should == expected_result
+    end
+  end
+
+  describe "with no options" do
+    let(:expected_result) { fixture 'out_defaults.png' }
+    it_should_behave_like "expected result"
+  end
+
+  describe "with --smooth" do
+    let(:options) { { smooth: true } }
+    let(:expected_result) { fixture 'out_smooth.png' }
+    it_should_behave_like "expected result"
+  end
+
+  describe "with --diagonal" do
+    let(:options) { { diagonal: true } }
+    let(:expected_result) { fixture 'out_diagonal.png' }
+    it_should_behave_like "expected result"
+  end
+
+  describe "with --wrap" do
+    let(:options) { { wrap: true } }
+    let(:expected_result) { fixture 'out_wrap.png' }
+    it_should_behave_like "expected result"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'normal_map'
+
+Dir[File.expand_path('support/**/*.rb', File.dirname(__FILE__))].each do |f|
+  require f
+end
+
+RSpec.configure do |conf|
+  conf.include Fixtures
+end

data/spec/support/fixtures.rb

@@ -0,0 +1,12 @@
+module Fixtures
+  def fixture_path relative
+    File.expand_path File.join('../fixtures', relative),
+                     File.dirname(__FILE__)
+  end
+
+  def fixture relative
+    File.open fixture_path(relative), 'rb' do |f|
+      f.read
+    end
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: normal_map
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Colin MacKenzie IV
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Generates DOT3 bump maps, also known as normal maps, for use in 3D computing.
+email:
+- sinisterchipmunk@gmail.com
+executables:
+- normal-map
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/normal-map
+- lib/normal_map.rb
+- lib/normal_map/cli.rb
+- lib/normal_map/version.rb
+- normal_map.gemspec
+- spec/fixtures/in.png
+- spec/fixtures/out_defaults.png
+- spec/fixtures/out_diagonal.png
+- spec/fixtures/out_smooth.png
+- spec/fixtures/out_wrap.png
+- spec/lib/normal_map_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixtures.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Command line tool and Ruby library for generating normal maps.
+test_files:
+- spec/fixtures/in.png
+- spec/fixtures/out_defaults.png
+- spec/fixtures/out_diagonal.png
+- spec/fixtures/out_smooth.png
+- spec/fixtures/out_wrap.png
+- spec/lib/normal_map_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixtures.rb