panomosity 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8a24ffd1b51c93f06e28be5531393d9ef4fa2390dfabc1a3a0cebd92e0fe8ea2
+  data.tar.gz: 6f01ff9088ce77b29b1d0b75c7ecc419962fa81b988d3b8c41b4f13a4ff29d61
+SHA512:
+  metadata.gz: d8ce529cfbcfc347df7ff571a585d4f081ed35cc0c7ac7890f613a0d7e83a0da58d2c6cf5656571690eef8d793f65eb50277fd886763fbad34bc74f4e50c7ec9
+  data.tar.gz: 43f8377b355628dc3b896deec813be6c56ca6969d1c9f7731e774ca08abe01bd5694d66ac87e4a63ceefde84e787e262e50624fea73574312e92336492a9a38b

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+# RubyMine
+/.idea/

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

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/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at ogarci5@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    panomosity (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    method_source (0.9.0)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  panomosity!
+  pry
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Oliver Garcia
+
+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,43 @@
+# Panomosity
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/panomosity`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'panomosity'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install panomosity
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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 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/[USERNAME]/panomosity. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Panomosity project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/panomosity/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'panomosity'
+
+# 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.
+
+require 'pry'
+Pry.start

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/exe/panomosity

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'panomosity'
+Panomosity.parse(ARGV)

data/lib/panomosity/control_point.rb

@@ -0,0 +1,118 @@
+# Example of a control point line
+# c n26 N26 x887.4 y1056.72 X1128.12 Y1077.12 t2
+
+module Panomosity
+  class ControlPoint
+    @@attributes = %i(n N x y X Y t)
+
+    def self.parse(pto_file, cp_type: nil, compact: false)
+      @control_points = pto_file.each_line.map do |line|
+        if compact
+          cp_data = line.split(',').map { |part| part.split(' ') }.flatten
+          n1, x1, y1, n2, x2, y2, type, dist = *cp_data.to_a.map(&:to_f)
+          new(n: n1, N: n2, x: x1, y: y1, X: x2, Y: y2, t: type, dist: dist, raw: line)
+        else
+          parse_line(line)
+        end
+      end.compact
+
+      case cp_type
+        when :line
+          @control_points.select!(&:line?)
+        when :normal
+          @control_points.select!(&:normal?)
+        when :vertical
+          @control_points.select!(&:vertical?)
+        when :horizontal
+          @control_points.select!(&:horizontal?)
+        else
+          @control_points
+      end
+    end
+
+    def self.get_detailed_info(pto_file_path, cp_type: nil)
+      result = `perl control_point_info.pl --input #{pto_file_path}`
+      parse(result, cp_type: cp_type, compact: true)
+    end
+
+    def self.all
+      @control_points
+    end
+
+    def self.parse_line(line)
+      parts = line.split(' ')
+      if parts.first == 'c'
+        data = parts.each_with_object({}) do |part, hash|
+          attribute = @@attributes.find { |attr| part[0] == attr.to_s }
+          next unless attribute
+          hash[attribute] = part.sub(attribute.to_s, '')
+        end
+
+        data[:raw] = line
+        data[:dist] = nil
+
+        new data
+      end
+    end
+
+    def initialize(attributes)
+      @attributes = attributes
+      # conform data types
+      @attributes.each do |key, value|
+        next if %i(raw).include?(key)
+        if value.respond_to?(:include?) && value.include?('.')
+          @attributes[key] = value.to_f
+        else
+          @attributes[key] = value.to_i
+        end
+      end
+    end
+
+    def [](key)
+      @attributes[key]
+    end
+
+    def []=(key, value)
+      @attributes[key] = value
+    end
+
+    (@@attributes + %i(raw dist)).each do |attr|
+      define_method(attr) do
+        @attributes[attr]
+      end
+
+      define_method(:"#{attr}=") do |value|
+        @attributes[attr] = value
+      end
+    end
+
+    alias_method :type, :t
+    alias_method :n1, :n
+    alias_method :n2, :N
+    alias_method :x1, :x
+    alias_method :x2, :X
+    alias_method :y1, :y
+    alias_method :y2, :Y
+
+    def normal?
+      type == 0
+    end
+
+    def vertical?
+      type == 1
+    end
+
+    def horizontal?
+      type == 2
+    end
+
+    def line?
+      vertical? || horizontal?
+    end
+
+    def to_s
+      line_values = @@attributes.map { |attribute| "#{attribute}#{self.send(attribute)}" }
+      "c #{line_values.join(' ')}\n"
+    end
+  end
+end

data/lib/panomosity/image.rb

@@ -0,0 +1,143 @@
+# Exmaple of an image line
+# i w2448 h3264 f0 v=0 Ra=0 Rb=0 Rc=0 Rd=0 Re=0 Eev6.433 Er1 Eb1 r0 p0 y0 TrX0.88957152 TrY0.79560269 TrZ1 Tpy0 Tpp0 j0 a=0 b=0 c=0 d=0 e=0 g0 t0 Va=0 Vb=0 Vc=0 Vd=0 Vx=0 Vy=0  Vm5 n"WZ8ppTx9PtcxASB3hbeeuS6Z"\n
+
+module Panomosity
+  class Image
+    @@attributes = %i(w h f v Ra Rb Rc Rd Re Eev Er Eb r p y TrX TrY TrZ Tpy Tpp j a b c d e g t Va Vb Vc Vd Vx Vy Vm n)
+    @@equaled_attributes = %i(v Ra Rb Rc Rd Re a b c d e Va Vb Vc Vd Vx Vy)
+
+    def self.parse(pto_file)
+      id = 0
+      @images = pto_file.each_line.map do |line|
+        image = parse_line(line, id)
+        if image
+          id += 1
+          image
+        end
+      end.compact
+
+      calculate_dimensions
+      @images
+    end
+
+    def self.calculate_dimensions(fov = nil)
+      @fov = fov || 45.2
+      lam = (90 - (@fov / 2.0)) * (Math::PI / 180.0)
+      @panosphere = (Math.tan(lam) * 0.5 * 0.5)
+      _, @x_offset = @images.map(&:TrX).minmax
+      _, @y_offset = @images.map(&:TrY).minmax
+    end
+
+    def self.all
+      @images
+    end
+
+    def self.panosphere
+      @panosphere
+    end
+
+    def self.x_offset
+      @x_offset
+    end
+
+    def self.y_offset
+      @y_offset
+    end
+
+    def self.parse_line(line, id = 0)
+      parts = line.split(' ')
+      if parts.first == 'i'
+        data = parts.each_with_object({}) do |part, hash|
+          attribute = @@attributes.find { |attr| part[0..(attr.to_s.length-1)] == attr.to_s }
+          next unless attribute
+          hash[attribute] = part.sub(attribute.to_s, '')
+        end
+
+        # Sanitization
+        data.each { |key, value| data[key] = value.sub(/\A=/, '') }
+        data[:n] = data[:n].gsub('"', '')
+        data[:id] = id
+        data[:raw] = line
+
+        new data
+      end
+    end
+
+    def initialize(attributes)
+      @attributes = attributes
+      # conform data types
+      @attributes.each do |key, value|
+        next if %i(n id raw).include?(key)
+        if value.respond_to?(:include?) && value.include?('.')
+          @attributes[key] = value.to_f
+        else
+          @attributes[key] = value.to_i
+        end
+      end
+    end
+
+    def [](key)
+      @attributes[key]
+    end
+
+    def []=(key, value)
+      @attributes[key] = value
+    end
+
+    (@@attributes + %i(raw id)).each do |attr|
+      define_method(attr) do
+        @attributes[attr]
+      end
+
+      define_method(:"#{attr}=") do |value|
+        @attributes[attr] = value
+      end
+    end
+
+    alias_method :width, :w
+    alias_method :height, :h
+    alias_method :name, :n
+
+    def normal_x
+      self[:TrX] * self.class.panosphere * width
+    end
+
+    def normal_y
+      self[:TrY] * self.class.panosphere * height
+    end
+
+    def to_s
+      subline_values = (@@attributes - %i(Vm n)).map do |attribute|
+        value = self.send(attribute)
+        if @@equaled_attributes.include?(attribute)
+          if value == 0.0
+            "#{attribute}=#{value.to_i}"
+          else
+            "#{attribute}#{value}"
+          end
+        else
+          "#{attribute}#{value}"
+        end
+      end
+      %Q(i #{subline_values.join(' ')}  Vm#{self[:Vm]} n"#{self[:n]}"\n)
+    end
+
+    # Gets the value of TrX and TrY and sets them as d and e
+    def convert_position!
+      trx = self[:TrX]
+      try = self[:TrY]
+
+      self[:TrX] = 0
+      self[:TrY] = 0
+      self[:TrZ] = 0
+
+      # To fix an issue with pto reading files ignoring attributes that have a =0
+      trx = '0.0' if trx == 0.0
+      try = '0.0' if try == 0.0
+
+      self[:d] = trx
+      self[:e] = try
+      self
+    end
+  end
+end

data/lib/panomosity/optimisation_variable.rb

@@ -0,0 +1,64 @@
+module Panomosity
+  class OptimisationVariable
+    @@attributes = %i(w h f v Ra Rb Rc Rd Re Eev Er Eb r p y TrX TrY TrZ Tpy Tpp j a b c d e g t Va Vb Vc Vd Vx Vy Vm n)
+
+    def self.parse(pto_file)
+      @optimization_variables = pto_file.each_line.map { |line| parse_line(line) }.compact
+    end
+
+    def self.all
+      @optimization_variables
+    end
+
+    def self.parse_line(line)
+      parts = line.split(' ')
+      if parts.first == 'v'
+        data = parts.each_with_object({}) do |part, hash|
+          attribute = @@attributes.find { |attr| part[0] == attr.to_s }
+          next unless attribute
+          hash[attribute] = part.sub(attribute.to_s, '')
+        end
+
+        data[:raw] = line
+
+        new data
+      end
+    end
+
+    def initialize(attributes)
+      @attributes = attributes
+      # conform data types
+      @attributes.each do |key, value|
+        next if %i(raw).include?(key)
+        if value.respond_to?(:include?) && value.include?('.')
+          @attributes[key] = value.to_f
+        else
+          @attributes[key] = value.to_i
+        end
+      end
+    end
+
+    def [](key)
+      @attributes[key]
+    end
+
+    def []=(key, value)
+      @attributes[key] = value
+    end
+
+    (@@attributes + %i(raw)).each do |attr|
+      define_method(attr) do
+        @attributes[attr]
+      end
+
+      define_method(:"#{attr}=") do |value|
+        @attributes[attr] = value
+      end
+    end
+
+    def to_s
+      line_values = @@attributes.map { |attribute| "#{attribute}#{self.send(attribute)}" }
+      "v #{line_values.join(' ')}\n"
+    end
+  end
+end

data/lib/panomosity/runner.rb

@@ -0,0 +1,477 @@
+require 'logger'
+
+module Panomosity
+  class Runner
+    attr_reader :logger
+
+    AVAILABLE_COMMANDS = %w(
+      check_position_changes
+      convert_equaled_image_parameters
+      convert_horizontal_lines
+      convert_translation_parameters
+      crop_centers
+      fix_conversion_errors
+      generate_border_line_control_points
+      merge_image_parameters
+      prepare_for_pr0ntools
+      remove_long_lines
+      remove_anchor_variables
+      standardize_roll
+    )
+
+    def initialize(options)
+      @options = options
+      @input = options[:input]
+      @output = options[:output]
+      @csv = options[:csv]
+      @compare = options[:compare]
+      @input_file = File.new(@input, 'r').read rescue puts('You must have at least one argument')
+      @output_file = File.new(@output, 'w') if @output
+      @csv_file = File.new(@csv, 'r').read if @csv
+      @compare_file = File.new(@compare, 'r').read if @compare
+      @logger = Logger.new(STDOUT)
+
+      if options[:verbose]
+        @logger.level = Logger::INFO
+      else
+        @logger.level = Logger::DEBUG
+      end
+
+      @logger.formatter = proc do |severity, datetime, progname, msg|
+        "[#{datetime}][#{severity}] #{msg}\n"
+      end
+    end
+
+    def run(command)
+      if AVAILABLE_COMMANDS.include?(command)
+        send(command)
+      else
+        logger.info "commands include:\n#{AVAILABLE_COMMANDS.join("\n")}"
+      end
+    end
+
+    def check_position_changes
+      logger.info 'checking position changes'
+      original_images = Image.parse(@input_file)
+      changed_images = Image.parse(@compare_file)
+      threshold = 0.10
+      images = original_images.zip(changed_images)
+      changes_x = images.select do |original, changed|
+        ratio_x = original.d / changed.d
+        changed_x = (1 - ratio_x.abs).abs
+        changed_x > threshold
+      end
+      changes_y = images.select do |original, changed|
+        ratio_y = original.e / changed.e
+        changed_y = (1 - ratio_y.abs).abs
+        changed_y > threshold
+      end
+
+      @lines = @input_file.each_line.map do |line|
+        variable = OptimisationVariable.parse_line(line)
+        next line unless variable
+        if variable.d && changes_x.find { |original, _| original.id.to_s == variable.d }
+          logger.debug "Removing #{variable.to_s}"
+        elsif variable.e && changes_y.find { |original, _| original.id.to_s == variable.e }
+          logger.debug "Removing #{variable.to_s}"
+        else
+          next line
+        end
+      end
+
+      save_file
+    end
+
+    def convert_equaled_image_parameters
+      logger.info 'converting equaled image parameters'
+      images = Image.parse(@input_file)
+      @lines = @input_file.each_line.map do |line|
+        image = images.find { |i| i.raw == line }
+        if image
+          image.to_s
+        else
+          next line
+        end
+      end.compact
+
+      save_file
+    end
+
+    def convert_horizontal_lines
+      logger.info 'converting horizontal lines'
+      @lines = @input_file.each_line.map do |line|
+        cp = ControlPoint.parse_line(line)
+        if cp && cp.vertical?
+          cp.t = 2
+          cp.to_s
+        else
+          next line
+        end
+      end.compact
+
+      save_file
+    end
+
+    def convert_translation_parameters
+      logger.info 'converting translation parameters'
+      images = Image.parse(@input_file)
+
+      @lines = @input_file.each_line.map do |line|
+        image = images.find { |i| i.raw == line }
+        next if line[0] == 'v'
+        next line unless image
+        image.convert_position!
+        if image.id == images.sort_by(&:id).last.id
+          image.to_s +
+            "\n" +
+            "# Variable lines\n" +
+            images.map { |i| i.id == 0 ? nil : "v d#{i.id} e#{i.id}\n" }.compact.join +
+            "v\n" +
+            "\n"
+        else
+          image.to_s
+        end
+
+      end.compact
+
+      save_file
+    end
+
+    # Uses image magick to crop centers
+    def crop_centers
+      logger.info 'cropping centers'
+      unless @options[:without_cropping]
+        images = Image.parse(@input_file)
+        images.each do |image|
+          geometry = `identify -verbose #{image.name} | grep Geometry`.strip
+          _, width, height = *geometry.match(/(\d{2,5})x(\d{2,5})(\+|\-)\d{1,5}(\+|\-)\d{1,5}/)
+          logger.debug "cropping #{image.name}"
+          `convert #{image.name} -crop "50%x50%+#{(width.to_f/4).round}+#{(height.to_f/4).round}" #{image.name}`
+        end
+      end
+
+      # Since all images have been cropped, we need to change d,e params to move images based on how much was cropped
+      # Re-run commands that have been run at this point
+      logger.info 'rerunning commands'
+      @new_input_file_path = 'project_converted_translation_cropped.pto'
+      `match-n-shift --input #{@csv} -o project_cropped.pto`
+      `pto_var --opt=TrX,TrY project_cropped.pto -o project_pto_var_cropped.pto`
+      runner = Runner.new(@options.merge(input: 'project_pto_var_cropped.pto', output: @new_input_file_path))
+      runner.run('convert_translation_parameters')
+      `pano_modify -p 0 --fov=AUTO -o #{@new_input_file_path} #{@new_input_file_path}`
+
+      logger.info "Read new #{@new_input_file_path}"
+      # Read new input pto file
+      @input_file = File.new(@new_input_file_path, 'r').read
+      images = Image.parse(@input_file)
+      ds = images.map(&:d).uniq.sort
+      es = images.map(&:e).uniq.sort
+
+      d_diffs = []
+      ds.each_with_index do |_, i|
+        next if i == 0
+        d_diffs.push((ds[i] - ds[i-1]).abs / 2)
+      end
+
+      e_diffs = []
+      es.each_with_index do |_, i|
+        next if i == 0
+        e_diffs.push((es[i] - es[i-1]).abs / 2)
+      end
+
+      d_map = Hash[ds.map.with_index { |d, i| i == 0 ? [d, d] : [d, d - d_diffs[0..(i-1)].reduce(:+)] }]
+      e_map = Hash[es.map.with_index { |e, i|  i == 0 ? [e, e] : [e, e - e_diffs[0..(i-1)].reduce(:+)] }]
+
+      d_min, d_max = d_map.values.minmax
+      e_min, e_max = e_map.values.minmax
+      d_offset = ((d_max - d_min) / 2.0) + d_min
+      e_offset = ((e_max - e_min) / 2.0) + e_min
+
+      logger.info 'saving new d,e values'
+      @lines = @input_file.each_line.map do |line|
+        image = images.find { |i| i.raw == line }
+        if image
+          image.d = (d_map[image.d] - d_offset).round(8).to_s
+          image.e = (e_map[image.e] - e_offset).round(8).to_s
+          image.to_s
+        else
+          next line
+        end
+      end.compact
+
+      save_file
+    end
+
+    def fix_conversion_errors
+      logger.info 'fixing conversion errors'
+      @lines = @input_file.each_line.map do |line|
+        cp = ControlPoint.parse_line(line)
+        if cp && cp.horizontal?
+          cp.to_s
+        else
+          next line
+        end
+      end.compact
+
+      save_file
+    end
+
+    def generate_border_line_control_points
+      logger.info 'generating border line control points'
+      images = Image.parse(@input_file)
+      line_control_points = ControlPoint.parse(@input_file, cp_type: :line)
+
+      # Set vertical and horizontal control points for each image
+      images.each do |image|
+        vertical_control_points = line_control_points.select { |cp| cp[:n] == image[:id] && cp[:N] == image[:id] && cp[:t] == 1 }
+        horizontal_control_points = line_control_points.select { |cp| cp[:n] == image[:id] && cp[:N] == image[:id] && cp[:t] == 2 }
+        image[:vertical_control_points] = vertical_control_points
+        image[:horizontal_control_points] = horizontal_control_points
+      end
+
+      # Iterate through the edges to create vertical control points across overlapping images
+      logger.info 'finding common vertical control points'
+      vertical_edges, horizontal_edges = images.map { |image| image[:d] }.minmax, images.map { |image| image[:e] }.minmax
+      vertical_control_points = []
+      vertical_edges.each do |edge|
+        edge_images = images.select { |image| image[:d] == edge }.sort_by { |image| image[:e] }
+        edge_images.each_with_index do |image, index|
+          next if index == edge_images.length - 1
+          next_image = edge_images[index+1]
+
+          control_points = image[:vertical_control_points].map do |control_point|
+            average_x = (control_point[:x] + control_point[:X]) / 2.0
+            next_found_control_point = next_image[:vertical_control_points].find do |next_control_point|
+              next_average_x = (next_control_point[:x] + next_control_point[:X]) / 2.0
+              next_average_x.between?(average_x * 0.98, average_x * 1.02)
+            end
+            [control_point, next_found_control_point] if next_found_control_point
+          end.compact
+
+          # Special logic for anchor image
+          if image[:id] == 0
+            control_points = next_image[:vertical_control_points].map do |next_control_point|
+              next_average_x = (next_control_point[:x] + next_control_point[:X]) / 2.0
+              [{n: 0, x: next_average_x, y: (image[:h]/2.0).round }, next_control_point]
+            end
+          elsif next_image[:id] == 0
+            control_points = image[:vertical_control_points].map do |next_control_point|
+              next_average_x = (next_control_point[:x] + next_control_point[:X]) / 2.0
+              [{n: 0, x: next_average_x, y: (image[:h]/2.0).round }, next_control_point]
+            end
+          end
+
+          control_points.each do |current_control_point, next_control_point|
+            vertical_control_points << ControlPoint.new({
+                                                          n: current_control_point[:n],
+                                                          N: next_control_point[:n],
+                                                          x: current_control_point[:x],
+                                                          y: current_control_point[:y],
+                                                          X: next_control_point[:X],
+                                                          Y: next_control_point[:Y],
+                                                          t: 1
+                                                        })
+          end
+        end
+      end
+
+      # Iterate through the edges to create horizontal control points across overlapping images
+      logger.info 'finding common horizontal control points'
+      horizontal_control_points = []
+      horizontal_edges.each do |edge|
+        edge_images = images.select { |image| image[:e] == edge }.sort_by { |image| image[:d] }
+        edge_images.each_with_index do |image, index|
+          next if index == edge_images.length - 1
+          next_image = edge_images[index+1]
+
+          control_points = image[:horizontal_control_points].map do |control_point|
+            average_y = (control_point[:y] + control_point[:Y]) / 2.0
+            next_found_control_point = next_image[:horizontal_control_points].find do |next_control_point|
+              next_average_y = (next_control_point[:y] + next_control_point[:Y]) / 2.0
+              next_average_y.between?(average_y * 0.98, average_y * 1.02)
+            end
+            [control_point, next_found_control_point] if next_found_control_point
+          end.compact
+
+          # Special logic for anchor image
+          if image[:id] == 0
+            control_points = next_image[:horizontal_control_points].map do |next_control_point|
+              next_average_y = (next_control_point[:y] + next_control_point[:Y]) / 2.0
+              [{n: 0, x: (image[:w]/2.0).round, y: next_average_y }, next_control_point]
+            end
+          end
+
+          control_points.each do |current_control_point, next_control_point|
+            horizontal_control_points << ControlPoint.new({
+                                                            n: current_control_point[:n],
+                                                            N: next_control_point[:n],
+                                                            x: current_control_point[:x],
+                                                            y: current_control_point[:y],
+                                                            X: next_control_point[:X],
+                                                            Y: next_control_point[:Y],
+                                                            t: 2
+                                                          })
+          end
+        end
+      end
+
+      logger.info "writing #{vertical_control_points.count} vertical control points"
+      logger.info "writing #{horizontal_control_points.count} horizontal control points"
+      control_point_lines_started = false
+      @lines = @input_file.each_line.map do |line|
+        cp = ControlPoint.parse_line(line)
+        if cp.nil?
+          # Control point lines ended
+          if control_point_lines_started
+            control_point_lines_started = false
+            (vertical_control_points + horizontal_control_points).map do |control_point|
+              logger.debug "image #{control_point[:n]} <> #{control_point[:N]} #{control_point[:t] == 1 ? 'vertical' : 'horizontal'} control point"
+              control_point.to_s
+            end + [line]
+          else
+            next line
+          end
+        else
+          control_point_lines_started = true
+          next line
+        end
+      end.compact.flatten
+
+      save_file
+    end
+
+    def merge_image_parameters
+      logger.info 'merging image parameters'
+      control_points = ControlPoint.parse(@compare_file)
+      v_lines_started = false
+      @lines = @input_file.each_line.map do |line|
+        if line[0] == 'v'
+          v_lines_started = true
+          next line
+        elsif v_lines_started
+          v_lines_started = false
+          control_points.map(&:to_s).join
+        else
+          next line
+        end
+      end.compact
+
+      save_file
+    end
+
+    def prepare_for_pr0ntools
+      logger.info 'preparing for pr0ntools'
+
+      images = Image.parse(@input_file)
+      ds = images.map(&:d).uniq.sort
+      es = images.map(&:e).uniq.sort
+      fov = images.map(&:v).uniq.find { |v| v != 0.0 }
+      images.each do |i|
+        i[:original_n] = i.n
+        i.n = "c#{ds.reverse.index(i.d)}_r#{es.reverse.index(i.e)}.jpg"
+        i.v = fov
+      end
+      images = images.sort_by(&:n)
+
+      index = -1
+      @lines = @input_file.each_line.map do |line|
+        image = images.find { |i| i.raw == line }
+        next line unless image
+        index += 1
+        images[index].to_s
+      end.compact
+
+      dir = '/pr0ntools/'
+      logger.info "creating #{dir}"
+      new_dir = Pathname.new(@output).dirname.to_s + dir
+      FileUtils.mkdir_p(new_dir)
+
+      logger.info 'renaming files to format cX_rY.jpg'
+      images.each { |image| FileUtils.cp(image[:original_n], new_dir + image.n) }
+
+      logger.info 'creating scan.json'
+      image_first_col = images.find { |image| image.n == 'c0_r0.jpg' }
+      image_second_col = images.find { |image| image.n == 'c1_r0.jpg' }
+      overlap = ((image_second_col.d - image_first_col.d).abs / image_first_col.w.to_f).round(4)
+      File.open(new_dir+'scan.json', 'w') { |f| f.puts %Q({"overlap":#{overlap}}) }
+
+      save_file(dir: dir)
+    end
+
+    def remove_anchor_variables
+      logger.info 'removing anchor variables'
+      variables = OptimisationVariable.parse(@input_file)
+
+      @lines = @input_file.each_line.map do |line|
+        variable = variables.find { |v| v.raw == line }
+        if variable && (variable.d == 0 || variable.e == 0)
+          next
+        else
+          next line
+        end
+      end.compact
+
+      save_file
+    end
+
+    def remove_long_lines
+      logger.info 'removing long lines'
+
+      images = Image.parse(@input_file)
+      control_points = ControlPoint.get_detailed_info(@input, cp_type: :normal)
+      control_points.each do |cp|
+        image1 = images.find { |i| cp.n1 == i.id }
+        image2 = images.find { |i| cp.n2 == i.id }
+        # dist = ((image1.normal_x + cp.x1) - (image2.normal_x + cp.x2)) ** 2 + ((image1.normal_y + cp.y1) - (image2.normal_y + cp.y2)) ** 2
+        dx = (image1.d - cp.x1) - (image2.d - cp.x2)
+        dy = (image1.e - cp.y1) - (image2.e - cp.y2)
+        logger.debug "#{cp.to_s} distrt #{Math.sqrt(dx**2+dy**2)} iy1 #{image1.normal_y} iy2 #{image2.normal_y}"
+      end
+      logger.debug "avg #{control_points.map(&:dist).reduce(:+)/control_points.count.to_f}"
+    end
+
+    def standardize_roll
+      logger.info 'standardizing roll'
+      images = Image.parse(@input_file)
+      rolls = images.map(&:r)
+      average_roll = rolls.reduce(:+).to_f / rolls.count
+      logger.debug "average roll: #{average_roll}"
+      roll_std = Math.sqrt(rolls.map { |r| (r - average_roll) ** 2 }.reduce(:+) / (rolls.count - 1))
+      logger.debug "roll std: #{roll_std}"
+      new_rolls = rolls.select { |r| (r - average_roll).abs < roll_std }
+      logger.info "removed #{rolls.count - new_rolls.count} outliers"
+      new_average_roll = new_rolls.reduce(:+).to_f / new_rolls.count
+      logger.info "converting all rolls to #{new_average_roll}"
+
+      @lines = @input_file.each_line.map do |line|
+        image = images.find { |i| i.raw == line }
+        if image
+          image.r = new_average_roll
+          image.to_s
+        else
+          next line
+        end
+      end.compact
+
+      save_file
+    end
+
+    private
+
+    def save_file(dir: nil)
+      logger.info 'saving file'
+      if dir
+        new_dir = Pathname.new(@output).dirname.to_s + dir
+        FileUtils.mkdir_p(new_dir)
+        @output = new_dir + Pathname.new(@output).basename.to_s
+        @output_file = File.new(@output, 'w')
+      end
+
+      @lines.each do |good_line|
+        @output_file.write good_line
+      end
+
+      @output_file.close
+    end
+  end
+end

data/lib/panomosity/version.rb

@@ -0,0 +1,3 @@
+module Panomosity
+  VERSION = '0.1.1'
+end

data/lib/panomosity.rb

@@ -0,0 +1,53 @@
+require 'panomosity/control_point'
+require 'panomosity/image'
+require 'panomosity/optimisation_variable'
+require 'panomosity/runner'
+require 'panomosity/version'
+require 'pathname'
+require 'fileutils'
+require 'optparse'
+
+module Panomosity
+  def self.parse(arguments)
+    options = {}
+    OptionParser.new do |parser|
+      parser.banner = 'Usage: panomosity command [options]'
+      parser.separator ''
+      parser.separator 'Specific options:'
+
+      parser.on('-i', '--input PTO', 'Input PTO file') do |pto|
+        options[:input] = pto
+      end
+
+      parser.on('-o', '--output PTO', 'Output PTO file') do |pto|
+        options[:output] = pto
+      end
+
+      parser.on('-c', '--csv [CSV]', 'CSV file for reference') do |csv|
+        options[:csv] = csv
+      end
+
+      parser.on('-k', '--compare [PTO]', 'Compare PTO file for reference') do |pto|
+        options[:compare] = pto
+      end
+
+      parser.on('--without-cropping', 'Do not crop when running "crop_centers" (usually when the original run failed)') do |wc|
+        options[:without_cropping] = wc
+      end
+
+      parser.on('-v', '--[no-]verbose', 'Run verbosely') do |v|
+        options[:verbose] = v
+      end
+
+      parser.on('-h', '--help', 'Display this screen') do
+        puts parser
+        exit
+      end
+
+      parser.parse!(arguments)
+    end
+
+    runner = Runner.new(options)
+    runner.run(ARGV[0])
+  end
+end

data/panomosity.gemspec

@@ -0,0 +1,27 @@
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'panomosity/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'panomosity'
+  spec.version       = Panomosity::VERSION
+  spec.authors       = ['Oliver Garcia']
+  spec.email         = ['ogarci5@gmail.com']
+
+  spec.summary       = %q{Wrapper for the PTO file parsing needed for PanoTools.}
+  spec.description   = %q{Custom scripts to help with PTO parsing and different strategies.}
+  spec.homepage      = 'https://github.com/elevatesystems/panomosity'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = %w(lib)
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: panomosity
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Oliver Garcia
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Custom scripts to help with PTO parsing and different strategies.
+email:
+- ogarci5@gmail.com
+executables:
+- panomosity
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/panomosity
+- lib/panomosity.rb
+- lib/panomosity/control_point.rb
+- lib/panomosity/image.rb
+- lib/panomosity/optimisation_variable.rb
+- lib/panomosity/runner.rb
+- lib/panomosity/version.rb
+- panomosity.gemspec
+homepage: https://github.com/elevatesystems/panomosity
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Wrapper for the PTO file parsing needed for PanoTools.
+test_files: []