panomosity 0.1.17 → 0.1.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 036e68c0b7e7200740b6d253cbbe095a37980d0e6bd2ca342d8ba64402334662
-  data.tar.gz: 56e5cfb0c46c144f92222b03a335fd92876c9390270d30b9d88dc9db9fd7e2df
+  metadata.gz: 9d31e6f456b80f0429a224a93939514115dd1f944e4a01c0e4b3992347d9c870
+  data.tar.gz: fc71c2b94cb75a36ed249b728a9382350fc72ac5562c3dd644f31a5289969523
 SHA512:
-  metadata.gz: 1b84047e33b34e4a6d78c27be9c5e94e659a6a7f11aa69b2891d714756c08d57f62fc01d576c66d717a5b6b676b67b664de6dace0fc5cb4a355e1d9031d5c8d3
-  data.tar.gz: 1caf1ab0ceb0e65f98a95bc4f4b9b50a19b5daef1bd414a82ce808dcc99cc6fee12a4532c8b6059ab2dbf2f66db7efe82c520c913a2618df5b688263a7174e4a
+  metadata.gz: 7b2697110bf392a3d7f15371ca57e7835a149c8dd371cc45317559a005b57ba2b8edbc696d7e87e1f12111a325567e066988eba06614cd61b8b9c1a3d9cd4dd8
+  data.tar.gz: b55224d26f9b7f0e45fbcc26478517c39e3c80482dc9f16496b811cc94352bef5dc1e62173abc784ace3dc73c4df0f0adf0cda642897a3df8eb79d10445d8b50

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    panomosity (0.1.17)
+    panomosity (0.1.18)
 
 GEM
   remote: https://rubygems.org/

data/lib/panomosity/neighborhood.rb

@@ -0,0 +1,43 @@
+require 'panomosity/utils'
+
+module Panomosity
+  class Neighborhood
+    include Panomosity::Utils
+
+    attr_accessor :center, :pair, :distance, :pair_distance, :control_points, :control_points_within_std, :prdist_avg,
+                  :prdist_std, :prx_avg, :prx_std, :pry_avg, :pry_std
+
+    def initialize(center:, pair:, distance:)
+      @center = center
+      @pair = pair
+      @distance = distance
+    end
+
+    def calculate
+      # Instead of setting a static distance use a distance that is dependent on the type of connection
+      if pair.horizontal?
+        @pair_distance = (pair.first_image.h * 0.1).round
+        @control_points = pair.control_points.select do |cp|
+          cp.x1.between?(center.x1 - distance, center.x1 + distance) && cp.y1.between?(center.y1 - pair_distance, center.y1 + pair_distance)
+        end
+      else
+        @pair_distance = (pair.first_image.w * 0.1).round
+        @control_points = pair.control_points.select do |cp|
+          cp.x1.between?(center.x1 - pair_distance, center.x1 + pair_distance) && cp.y1.between?(center.y1 - distance, center.y1 + distance)
+        end
+      end
+
+      @prdist_avg, @prdist_std = *calculate_average_and_std(values: control_points.map(&:prdist))
+      @prx_avg, @prx_std = *calculate_average_and_std(values: control_points.map(&:prx))
+      @pry_avg, @pry_std = *calculate_average_and_std(values: control_points.map(&:pry))
+
+      # add in control points that have similar distances (within std)
+      @control_points_within_std = pair.control_points.select { |c| c.prdist.between?(center.prdist - prdist_std, center.prdist + prdist_std) }
+      self
+    end
+
+    def info
+      "neighborhood: center: (#{center.x1},#{center.y1}) | prx_avg,prx_std: #{prx_avg},#{prx_std} | pry_avg,pry_std: #{pry_avg},#{pry_std} | prdist_avg,prdist_std: #{prdist_avg},#{prdist_std}"
+    end
+  end
+end

data/lib/panomosity/neighborhood_group.rb

@@ -0,0 +1,109 @@
+require 'panomosity/utils'
+
+module Panomosity
+  class NeighborhoodGroup
+    include Panomosity::Utils
+    extend Panomosity::Utils
+
+    attr_accessor :center, :total_neighborhoods, :neighborhoods, :control_points, :prdist_avg, :prdist_std, :x_avg,
+                  :y_avg
+
+    class << self
+      attr_accessor :logger
+
+      def horizontal?
+        @type == :horizontal
+      end
+
+      def vertical?
+        @type == :vertical
+      end
+
+      def horizontal
+        @horizontal_neighborhood_groups
+      end
+
+      def vertical
+        @vertical_neighborhood_groups
+      end
+
+      def neighborhoods
+        horizontal? ? @horizontal_neighborhoods : @vertical_neighborhoods
+      end
+
+      def neighborhoods=(value)
+        if horizontal?
+          @horizontal_neighborhoods = value
+        else
+          @vertical_neighborhoods = value
+        end
+      end
+
+      def neighborhood_groups
+        horizontal? ? @horizontal_neighborhood_groups : @vertical_neighborhood_groups
+      end
+
+      def neighborhood_groups=(value)
+        if horizontal?
+          @horizontal_neighborhood_groups = value
+        else
+          @vertical_neighborhood_groups = value
+        end
+      end
+
+      def parse_info(panorama)
+        @panorama = panorama
+        @logger = @panorama.logger
+      end
+    end
+
+    def self.calculate(name: :horizontal, pairs: [])
+      @type = name
+      default_count = 3
+      self.neighborhoods = pairs.map { |p| p.good_neighborhoods_within_std(count: default_count) }.flatten
+
+      if neighborhoods.empty?
+        logger.warn 'total neighborhoods came up empty, neighborhood default count to 2'
+        default_count = 2
+        self.neighborhoods = pairs.map { |p| p.good_neighborhoods_within_std(count: default_count) }.flatten
+        raise 'still could not find neighborhoods' if neighborhoods.empty?
+      end
+
+      logger.debug "twice reducing #{name} neighborhood std outliers"
+      avg, std = *calculate_average_and_std(values: neighborhoods.map(&:prdist_std))
+      neighborhoods.select! { |n| (avg - n.prdist_std).abs <= std }
+      avg, std = *calculate_average_and_std(values: neighborhoods.map(&:prdist_std))
+      neighborhoods.select! { |n| (avg - n.prdist_std).abs <= std }
+
+      self.neighborhood_groups = neighborhoods.map do |neighborhood|
+        group = NeighborhoodGroup.new(center: neighborhood, total_neighborhoods: neighborhoods)
+        group.calculate
+      end
+
+      neighborhood_groups.max_by(5) { |ng| ng.control_points.count }.each do |ng|
+        logger.debug "#{ng.prdist_avg} #{ng.prdist_std} #{ng.control_points.count} x#{ng.x_avg} y#{ng.y_avg}"
+      end
+
+      self.neighborhood_groups = neighborhood_groups.max_by(5) { |ng| ng.control_points.count }
+    end
+
+    def self.info
+
+    end
+
+    def initialize(center:, total_neighborhoods:)
+      @center = center
+      @total_neighborhoods = total_neighborhoods
+    end
+
+    def calculate
+      @neighborhoods = total_neighborhoods.select { |n| (n.prdist_avg - center.prdist_avg).abs <= center.prdist_std }
+      @control_points = neighborhoods.map(&:control_points_within_std).flatten.uniq { |cp| cp.raw }
+      @x_avg = calculate_average(values: control_points.map(&:px))
+      @y_avg = calculate_average(values: control_points.map(&:py))
+      @prdist_avg = center.prdist_avg
+      @prdist_std = center.prdist_std
+      self
+    end
+  end
+end

data/lib/panomosity/optimizer.rb

@@ -26,16 +26,17 @@ module Panomosity
     end
 
     def run_position_optimizer
-      panorama.calculate_neighborhoods(amount_ratio: 1.0, log: false)
-      panorama.calculate_neighborhood_groups(name: :horizontal, pairs: panorama.horizontal_pairs)
-      panorama.calculate_neighborhood_groups(name: :vertical, pairs: panorama.vertical_pairs)
+      Pair.calculate_neighborhoods(panorama)
+      Pair.calculate_neighborhood_groups
 
       ds = images.map(&:d).uniq.sort
       es = images.map(&:e).uniq.sort
 
-      # start horizontally
-      x_avg = panorama.horizontal_neighborhoods_group.first[:x_avg]
+      # get the average error for the best neighborhood group
+      x_avg = NeighborhoodGroup.horizontal.first.x_avg
+      y_avg = NeighborhoodGroup.vertical.first.y_avg
 
+      # start horizontally
       d_map = {}
       ds.each_with_index do |d, i|
         d_map[d] = d + -x_avg * i
@@ -43,16 +44,15 @@ module Panomosity
       logger.debug "created d_map #{d_map}"
 
       # vertical
-      y_avg = panorama.vertical_neighborhoods_group.first[:y_avg]
-
       e_map = {}
       es.each_with_index do |e, i|
         e_map[e] = e + -y_avg * i
       end
       logger.debug "created e_map #{e_map}"
 
-      x_avg = panorama.vertical_neighborhoods_group.first[:x_avg]
-      y_avg = panorama.horizontal_neighborhoods_group.first[:y_avg]
+      # add in the other offset
+      x_avg = NeighborhoodGroup.vertical.first.x_avg
+      y_avg = NeighborhoodGroup.horizontal.first.y_avg
 
       de_map = {}
       d_map.each_with_index do |(dk,dv),di|
@@ -77,26 +77,12 @@ module Panomosity
       r = images.map(&:r).first
       original_roll = r
       logger.debug "current roll #{r}"
-      panorama.calculate_neighborhoods(amount_ratio: 1.0, log: false)
-      panorama.calculate_neighborhood_groups(name: :horizontal, pairs: panorama.horizontal_pairs)
-      panorama.calculate_neighborhood_groups(name: :vertical, pairs: panorama.vertical_pairs)
-
       # we grab the top 5 neighborhood groups and get the average distance for them and average that
-      horizontal_distances = panorama.horizontal_neighborhoods_group[0..5].map{|g| g[:prdist_avg]}
-      vertical_distances = panorama.vertical_neighborhoods_group[0..5].map{|g| g[:prdist_avg]}
-      dist_avg = calculate_average_and_std(values: horizontal_distances + vertical_distances).first
+      dist_avg = calculate_average_distance
 
       r -= 0.05
       logger.debug "current roll #{r}"
-      panorama.images.each { |i| i.r = r }
-      panorama.control_points = ControlPoint.calculate_distances(panorama.images, panorama.variable)
-      panorama.calculate_neighborhoods(amount_ratio: 1.0, log: false)
-      panorama.calculate_neighborhood_groups(name: :horizontal, pairs: panorama.horizontal_pairs)
-      panorama.calculate_neighborhood_groups(name: :vertical, pairs: panorama.vertical_pairs)
-
-      horizontal_distances = panorama.horizontal_neighborhoods_group[0..5].map{|g| g[:prdist_avg]}
-      vertical_distances = panorama.vertical_neighborhoods_group[0..5].map{|g| g[:prdist_avg]}
-      new_dist_avg = calculate_average_and_std(values: horizontal_distances + vertical_distances).first
+      new_dist_avg = recalculate_average_distance(roll: r)
       logger.debug "avg: #{dist_avg} new_avg: #{new_dist_avg}"
 
       if new_dist_avg < dist_avg
@@ -108,30 +94,14 @@ module Panomosity
         r = original_roll
         r += 0.05
         logger.debug "current roll #{r}"
-        panorama.images.each { |i| i.r = r }
-        panorama.control_points = ControlPoint.calculate_distances(panorama.images, panorama.variable)
-        panorama.calculate_neighborhoods(amount_ratio: 1.0, log: false)
-        panorama.calculate_neighborhood_groups(name: :horizontal, pairs: panorama.horizontal_pairs)
-        panorama.calculate_neighborhood_groups(name: :vertical, pairs: panorama.vertical_pairs)
-
-        horizontal_distances = panorama.horizontal_neighborhoods_group[0..5].map{|g| g[:prdist_avg]}
-        vertical_distances = panorama.vertical_neighborhoods_group[0..5].map{|g| g[:prdist_avg]}
-        new_dist_avg = calculate_average_and_std(values: horizontal_distances + vertical_distances).first
+        new_dist_avg = recalculate_average_distance(roll: r)
       end
 
       while new_dist_avg <= dist_avg
         r = r.send(operation, 0.05)
         logger.debug "current roll #{r}"
         dist_avg = new_dist_avg
-        panorama.images.each { |i| i.r = r }
-        panorama.control_points = ControlPoint.calculate_distances(panorama.images, panorama.variable)
-        panorama.calculate_neighborhoods(amount_ratio: 1.0, log: false)
-        panorama.calculate_neighborhood_groups(name: :horizontal, pairs: panorama.horizontal_pairs)
-        panorama.calculate_neighborhood_groups(name: :vertical, pairs: panorama.vertical_pairs)
-
-        horizontal_distances = panorama.horizontal_neighborhoods_group[0..5].map{|g| g[:prdist_avg]}
-        vertical_distances = panorama.vertical_neighborhoods_group[0..5].map{|g| g[:prdist_avg]}
-        new_dist_avg = calculate_average_and_std(values: horizontal_distances + vertical_distances).first
+        new_dist_avg = recalculate_average_distance(roll: r)
         logger.debug "avg: #{dist_avg} new_avg: #{new_dist_avg}"
       end
 
@@ -139,5 +109,19 @@ module Panomosity
         image.r = r
       end
     end
+
+    def calculate_average_distance
+      Pair.calculate_neighborhoods(panorama)
+      Pair.calculate_neighborhood_groups
+      horizontal_distances = NeighborhoodGroup.horizontal.map(&:prdist_avg)
+      vertical_distances = NeighborhoodGroup.vertical.map(&:prdist_avg)
+      calculate_average(values: horizontal_distances + vertical_distances)
+    end
+
+    def recalculate_average_distance(roll:)
+      panorama.images.each { |i| i.r = roll }
+      panorama.control_points = ControlPoint.calculate_distances(panorama.images, panorama.variable)
+      calculate_average_distance
+    end
   end
 end

data/lib/panomosity/pair.rb

@@ -0,0 +1,208 @@
+require 'panomosity/utils'
+
+module Panomosity
+  class Pair
+    include Panomosity::Utils
+    extend Panomosity::Utils
+
+    attr_accessor :pair, :control_points, :neighborhoods, :type
+
+    class << self
+      attr_accessor :logger
+
+      def horizontal
+        @horizontal_pairs
+      end
+
+      def vertical
+        @vertical_pairs
+      end
+
+      def all
+        @pairs
+      end
+
+      def good_control_points_to_keep
+        @pairs.map(&:good_control_points_to_keep).flatten.uniq { |cp| cp.raw }
+      end
+
+      def unconnected
+        @pairs.select(&:unconnected?).sort_by(&:to_s)
+      end
+
+      def without_enough_control_points(ignore_connected: false)
+        @pairs.select { |pair| (ignore_connected || pair.connected?) && pair.control_points.count < 3 }
+      end
+    end
+
+    def self.create_pairs_from_panorama(panorama)
+      @panorama = panorama
+      @logger = @panorama.logger
+
+      images = @panorama.images
+      columns = images.map(&:column).uniq.sort
+      rows = images.map(&:row).uniq.sort
+
+      @pairs = []
+      # horizontal pair creation
+      rows.each do |row|
+        columns.each do |column|
+          next if column == columns.last
+          image_1 = images.find { |i| i.row == row && i.column == column }
+          image_2 = images.find { |i| i.row == row && i.column == column.next }
+          control_points = @panorama.control_points.select { |cp| [cp.n1, cp.n2].sort == [image_1.id, image_2.id].sort }
+          @pairs << Pair.new([image_1, image_2].sort_by(&:id), control_points: control_points, type: :horizontal)
+        end
+      end
+
+      # vertical pair creation
+      columns.each do |column|
+        rows.each do |row|
+          next if row == rows.last
+          image_1 = images.find { |i| i.column == column && i.row == row }
+          image_2 = images.find { |i| i.column == column && i.row == row.next }
+          control_points = @panorama.control_points.select { |cp| [cp.n1, cp.n2].sort == [image_1.id, image_2.id].sort }
+          @pairs << Pair.new([image_1, image_2].sort_by(&:id), control_points: control_points, type: :vertical)
+        end
+      end
+    end
+
+    def self.calculate_neighborhoods(panorama, distance: 30)
+      create_pairs_from_panorama(panorama)
+      @pairs.each { |pair| pair.calculate_neighborhoods(distance: distance) }
+
+      # separate out into horizontal and vertical pairs
+      @horizontal_pairs = @pairs.select(&:horizontal?)
+      @vertical_pairs = @pairs.select(&:vertical?)
+
+      # sort pairs by average distance first and number of control points descending second
+      @horizontal_pairs = @horizontal_pairs.sort_by { |pair| [pair.average_distance, -pair.control_points.count] }
+      @vertical_pairs = @vertical_pairs.sort_by { |pair| [pair.average_distance, -pair.control_points.count] }
+
+      log_detailed_neighborhood_info(name: :horizontal, pairs: @horizontal_pairs)
+      log_detailed_neighborhood_info(name: :vertical, pairs: @vertical_pairs)
+    end
+
+    def self.log_detailed_neighborhood_info(name: :horizontal, pairs: [])
+      return unless @panorama.options[:very_verbose]
+      logger.debug "showing #{name} pair information"
+      pair = pairs.max_by { |p| p.control_points_of_best_neighborhood.count }
+      logger.debug "best #{name} pair #{pair.to_s} found #{pair.control_points_of_best_neighborhood.count} control points"
+      pairs.each do |p|
+        logger.debug "#{name} pair #{p.to_s} found #{p.control_points_of_best_neighborhood.count} control points"
+        p.neighborhoods.each do |n|
+          logger.debug "neighborhood centered at #{n.center.x1},#{n.center.y1}: #{n.control_points.count} control points"
+          logger.debug "neighborhood centered at #{n.center.x1},#{n.center.y1}: prdist #{n.prdist_avg},#{n.prdist_std} prx #{n.prx_avg},#{n.prx_std} pry #{n.pry_avg},#{n.pry_std}"
+          n.control_points.each { |point| logger.debug point.detailed_info }
+        end
+      end
+    end
+
+    def self.calculate_neighborhood_groups
+      NeighborhoodGroup.parse_info(@panorama)
+      NeighborhoodGroup.calculate(name: :horizontal, pairs: @horizontal_pairs)
+      NeighborhoodGroup.calculate(name: :vertical, pairs: @vertical_pairs)
+    end
+
+    def self.info
+      logger.debug "total number of control points: #{@pairs.map(&:control_points).flatten.count}"
+      logger.debug 'displaying horizontal pair info'
+      logger.debug "total number of horizontal control points: #{@horizontal_pairs.map(&:control_points).flatten.count}"
+      @horizontal_pairs.each do |pair|
+        logger.debug pair.info
+        logger.debug "total number of control points: #{pair.control_points.count}"
+        x_dist, x_std = *calculate_average_and_std(values: pair.control_points.map(&:prx))
+        y_dist, y_std = *calculate_average_and_std(values: pair.control_points.map(&:pry))
+        dist, std = *calculate_average_and_std(values: pair.control_points.map(&:prdist))
+        logger.debug "control points: x_dist,x_std: #{x_dist},#{x_std} | y_dist,y_std: #{y_dist},#{y_std} | dist,std: #{dist},#{std}"
+        logger.debug "total number of neighborhoods: #{pair.neighborhoods.count}"
+        logger.debug "total number single cp neighborhoods: #{pair.neighborhoods.select{|n| n.control_points.count == 1}.count}"
+        pair.neighborhoods.each do |neighborhood|
+          logger.debug neighborhood.info
+          logger.debug "neighborhood: distance,pair_distance: #{neighborhood.distance},#{neighborhood.pair_distance} | total number of control points: #{neighborhood.control_points.count}"
+          logger.debug "neighborhood: center prdist: #{neighborhood.center.prdist} | total number of control points within std: #{neighborhood.control_points_within_std.count}"
+        end
+      end
+    end
+
+    def initialize(pair, control_points: [], type: nil)
+      @pair = pair
+      @control_points = control_points
+      @neighborhoods = []
+      @type = type
+    end
+
+    def to_s
+      pair.map(&:id)
+    end
+
+    def info
+      "#{to_s}(#{type}) image_1 d,e: #{pair.first.d},#{pair.first.e} | image_2 d,e: #{pair.last.d},#{pair.last.e}"
+    end
+
+    def horizontal?
+      @type == :horizontal || (control_points.first && control_points.first.conn_type == :horizontal)
+    end
+
+    def vertical?
+      @type == :vertical || (control_points.first && control_points.first.conn_type == :vertical)
+    end
+
+    def connected?
+      !unconnected?
+    end
+
+    def unconnected?
+      control_points.empty?
+    end
+
+    def first_image
+      pair.first
+    end
+
+    def last_image
+      pair.last
+    end
+
+    def average_distance
+      calculate_average(values: control_points.map(&:prdist), ignore_empty: true)
+    end
+
+    def calculate_neighborhoods(distance: 30)
+      @neighborhoods = control_points.map do |cp|
+        neighborhood = Neighborhood.new(center: cp, pair: self, distance: distance)
+        neighborhood.calculate
+      end
+    end
+
+    # gets all control points for neighborhoods with a good std of distance
+    def good_neighborhoods_within_std(count: 3)
+      @neighborhoods.select { |n| n.control_points_within_std.count >= count }
+    end
+
+    def good_control_points_to_keep(count: 3)
+      control_points_to_keep = good_neighborhoods_within_std(count: count).map(&:control_points_within_std).flatten.uniq { |cp| cp.raw }
+
+      # Keep all our control points if we have less than 10
+      if control_points.count >= 10
+        ratio = control_points_to_keep.count.to_f / control_points.count
+        if ratio < 0.5
+          Panomosity.logger.warn "#{to_s} keeping less than 50% (#{(ratio*100).round(4)}%) of #{control_points.count} control points. Reverting and keeping all control points"
+          control_points
+        else
+          control_points_to_keep
+        end
+      else
+        control_points
+      end
+    end
+
+    def best_neighborhood
+      @best_neighborhood ||= @neighborhoods.max_by { |n| n.control_points.count }
+    end
+
+    def control_points_of_best_neighborhood
+      best_neighborhood ? best_neighborhood.control_points : []
+    end
+  end
+end

data/lib/panomosity/panorama.rb

@@ -2,368 +2,43 @@ module Panomosity
   class Panorama
     include Panomosity::Utils
 
-    attr_accessor :images, :control_points, :variable, :optimisation_variables, :logger, :horizontal_pairs,
-                  :vertical_pairs, :horizontal_neighborhoods_group, :vertical_neighborhoods_group
+    attr_accessor :images, :control_points, :variable, :optimisation_variables, :logger, :options
 
-    def initialize(input, logger = nil)
+    def initialize(input, options = {})
       @input = input
+      @options = options
       @images = Image.parse(@input)
       @variable = PanoramaVariable.parse(@input).first
       ControlPoint.parse(@input)
       @control_points = ControlPoint.calculate_distances(@images, @variable)
       @optimisation_variables = OptimisationVariable.parse(@input)
-
-      if logger
-        @logger = logger
-      else
-        @logger = Logger.new(STDOUT)
-        @logger.level = Logger::DEBUG
-        @logger.formatter = proc do |severity, datetime, progname, msg|
-          "[#{datetime}][#{severity}] #{msg}\n"
-        end
-      end
+      @logger = Panomosity.logger
     end
 
-    def calculate_neighborhoods(distance: 30, amount_ratio: 0.2, log: true)
-      pairs = control_points.group_by { |cp| [cp.n1, cp.n2] }
-      amount = (amount_ratio * (images.count)).floor
-
-      # separate out into horizontal and vertical pairs
-      horizontal_pairs = pairs.select { |_,cps| cps.first.conn_type == :horizontal }
-      vertical_pairs = pairs.select { |_,cps| cps.first.conn_type == :vertical }
-
-      # sort pairs by average distance first and number of control points descending second
-      horizontal_pairs = horizontal_pairs.sort_by { |_, cps|  [calculate_average_and_std(values: cps.map(&:prdist)).first, -cps.count] }
-      vertical_pairs = vertical_pairs.sort_by { |_, cps|  [calculate_average_and_std(values: cps.map(&:prdist)).first, -cps.count] }
-
-      # select a set amount
-      horizontal_pairs = horizontal_pairs[0..(amount-1)]
-      vertical_pairs = vertical_pairs[0..(amount-1)]
-
-      # looks for the highest concentration of points with similar distances within the neighborhood (30px) of the average
-      # group cps that are close in distance to each other
-      # start with horizontal pairs
-      @horizontal_pairs = calculate_neighborhood_info(pairs: horizontal_pairs, distance: distance)
-      log_detailed_neighborhood_info(name: :horizontal, pairs: @horizontal_pairs) if log
-
-      # vertical pairs
-      @vertical_pairs = calculate_neighborhood_info(pairs: vertical_pairs, distance: distance)
-      log_detailed_neighborhood_info(name: :vertical, pairs: @vertical_pairs) if log
-
-      { horizontal_pairs: @horizontal_pairs, vertical_pairs: @vertical_pairs }
-    end
-
-    def calculate_neighborhood_info(pairs: [], distance: 30)
-      pairs.map do |pair, cps|
-        neighborhoods = cps.map do |cp|
-          neighborhood = cps.select { |c| c.x1.between?(cp.x1 - distance, cp.x1 + distance) && c.y1.between?(cp.y1 - distance, cp.y1 + distance) }
-          if neighborhood.count > 1
-            prdist_avg, prdist_std = *calculate_average_and_std(values: neighborhood.map(&:prdist))
-            prx_avg, prx_std = *calculate_average_and_std(values: neighborhood.map(&:prx))
-            pry_avg, pry_std = *calculate_average_and_std(values: neighborhood.map(&:pry))
-
-            # add in control points that have similar distances (within std)
-            neighborhood_within_std = cps.select { |c| c.prdist.between?(cp.prdist - prdist_std, cp.prdist + prdist_std) }
-            {
-              cp: cp,
-              prdist_avg: prdist_avg,
-              prdist_std: prdist_std,
-              prx_avg: prx_avg,
-              prx_std: prx_std,
-              pry_avg: pry_avg,
-              pry_std: pry_std,
-              neighborhood: neighborhood,
-              neighborhood_within_std: neighborhood_within_std
-            }
-          else
-            nil
-          end
-        end.compact
-        # gets all control points for neighborhoods with a good std of distance
-        control_points_within_a_std = neighborhoods.select { |n| n[:neighborhood_within_std].count >= 3 }.flatten
-
-        best_neighborhood = neighborhoods.sort_by { |n| -n[:neighborhood].count }.first
-        {
-          pair: pair,
-          control_points: cps,
-          neighborhoods: neighborhoods,
-          best_neighborhood: best_neighborhood,
-          control_points_within_a_std: control_points_within_a_std
-        }
-      end
-    end
-
-    # get all neighborhoods based on how many control points are within the std of the distance
-    def calculate_neighborhood_groups(name: :horizontal, pairs: [])
-      neighborhood_default = 3
-      total_neighborhoods = pairs.map { |p| p[:neighborhoods].select { |n| n[:neighborhood_within_std].count >= neighborhood_default }}.flatten
-
-      if total_neighborhoods.map { |n| n[:prdist_std] }.empty?
-        logger.warn 'total_neighborhoods came up empty, neighborhood default count to 2'
-        neighborhood_default = 2
-        total_neighborhoods = pairs.map { |p| p[:neighborhoods].select { |n| n[:neighborhood_within_std].count >= neighborhood_default }}.flatten
-        raise 'still could not find neighborhoods' if total_neighborhoods.map { |n| n[:prdist_std] }.empty?
-      end
-
-      logger.debug "twice reducing #{name} neighborhood std outliers"
-      avg, std = *calculate_average_and_std(values: total_neighborhoods.map { |n| n[:prdist_std] })
-      total_neighborhoods.select! { |n| (avg - n[:prdist_std]).abs <= std }
-      avg, std = *calculate_average_and_std(values: total_neighborhoods.map { |n| n[:prdist_std] })
-      total_neighborhoods.select! { |n| (avg - n[:prdist_std]).abs <= std }
-      neighborhood_group = total_neighborhoods.map do |neighborhood|
-        ns_total = total_neighborhoods.select { |n| (n[:prdist_avg] - neighborhood[:prdist_avg]).abs < neighborhood[:prdist_std] }
-        cps_total = ns_total.map { |n| n[:neighborhood_within_std].count }.reduce(:+)
-        x_avg, _ = *calculate_average_and_std(values: ns_total.map { |n| n[:neighborhood_within_std] }.flatten.map(&:px))
-        y_avg, _ = *calculate_average_and_std(values: ns_total.map { |n| n[:neighborhood_within_std] }.flatten.map(&:py))
-        {
-          neighborhood: neighborhood,
-          total_neighboorhoods: ns_total,
-          total_control_points: cps_total,
-          prdist_avg: neighborhood[:prdist_avg],
-          prdist_std: neighborhood[:prdist_std],
-          x_avg: x_avg,
-          y_avg: y_avg
-        }
-      end
-      neighborhood_group.sort_by { |n| -n[:total_control_points] }[0..5].each do |ng|
-        logger.debug "#{ng[:prdist_avg]} #{ng[:prdist_std]} #{ng[:total_control_points]} x#{ng[:x_avg]} y#{ng[:y_avg]}"
-      end
-
-      if name == :horizontal
-        @horizontal_neighborhoods_group = neighborhood_group.sort_by { |n| -n[:total_control_points] }
-      else
-        @vertical_neighborhoods_group = neighborhood_group.sort_by { |n| -n[:total_control_points] }
-      end
-    end
-
-    def log_detailed_neighborhood_info(name: :horizontal, pairs: [])
-      logger.debug "showing #{name} pair information"
-      pair = pairs.sort_by{|pair| pair[:best_neighborhood] ? -pair[:best_neighborhood][:neighborhood].count : 0}.first
-      pairs.each do |p|
-        logger.debug "#{name} pair #{p[:pair]} found #{p[:best_neighborhood] ? p[:best_neighborhood][:neighborhood].count : 0} control points"
-        p[:neighborhoods].each do |neighborhood|
-          logger.debug "neighborhood centered at #{neighborhood[:cp].x1},#{neighborhood[:cp].y1}: #{neighborhood[:neighborhood].count} control points"
-          logger.debug "neighborhood centered at #{neighborhood[:cp].x1},#{neighborhood[:cp].y1}: prdist #{neighborhood[:prdist_avg]},#{neighborhood[:prdist_std]} prx #{neighborhood[:prx_avg]},#{neighborhood[:prx_std]} pry #{neighborhood[:pry_avg]},#{neighborhood[:pry_std]}"
-          neighborhood[:neighborhood].each do |point|
-            logger.debug point.detailed_info
-          end
-        end
-      end
-      pairs.each do |p|
-        logger.debug "#{name} pair #{p[:pair]} found #{p[:best_neighborhood] ? p[:best_neighborhood][:neighborhood].count : 0} control points"
-      end
-      #logger.debug "#{name} pair #{pair[:pair]} found #{pair[:best_neighborhood] ? pair[:best_neighborhood][:neighborhood].count : 0} control points"
-    end
-
-    def clean_control_points(options = {})
-      bad_control_points = []
-      min_control_points = 5
-      control_points.group_by { |cp| [cp.n1, cp.n2] }.select { |_, cps| cps.count > min_control_points }.each do |pair, cps|
-        logger.debug "cleaning pair #{pair.first} <> #{pair.last}"
-        average_x, x_std = *calculate_average_and_std(name: :x, values: cps.map(&:px), logger: logger)
-        average_y, y_std = *calculate_average_and_std(name: :y, values: cps.map(&:py), logger: logger)
-
-        max_removal = ((options[:max_removal] || 0.2) * cps.count).floor
-        min_cps = 8
-        max_iterations = 10
-        iterations = 0
-        bad_cps = cps.select { |cp| (cp.px - average_x).abs >= x_std || (cp.py - average_y).abs >= y_std }
-        while bad_cps.count > max_removal && (cps.count - bad_cps.count) >= min_cps && iterations <= max_iterations
-          x_std *= 1.1
-          y_std *= 1.1
-          iterations += 1
-          bad_cps = cps.select { |cp| (cp.px - average_x).abs >= x_std || (cp.py - average_y).abs >= y_std }
-        end
-
-        logger.info "found #{bad_cps.count} outliers"
-        bad_control_points << bad_cps if bad_cps.count <= max_removal
-      end
-      bad_control_points.flatten!
-    end
-
-    def clean_control_points_neighborhoods(options = {})
-      calculate_neighborhoods(amount_ratio: 1.0)
-      control_points = (@horizontal_pairs.map { |pair| pair[:control_points_within_a_std].map { |n| n[:neighborhood_within_std] } } +
-                        @vertical_pairs.map { |pair| pair[:control_points_within_a_std].map { |n| n[:neighborhood_within_std] } }).flatten.uniq { |cp| cp.raw }
-      bad_control_points = @control_points.reject { |cp| control_points.map(&:raw).include?(cp.raw) }
+    def clean_control_points
+      Pair.calculate_neighborhoods(self)
+      control_points_to_keep = Pair.good_control_points_to_keep
+      bad_control_points = control_points.reject { |cp| control_points_to_keep.map(&:raw).include?(cp.raw) }
+      control_point_ratio = bad_control_points.count.to_f / control_points.count
+      logger.warn "Removing more than 30% (#{(control_point_ratio*100).round(4)}%) of control points. May potentially cause issues." if control_point_ratio >= 0.3
+      control_point_pair_ratio = Pair.without_enough_control_points(ignore_connected: true).count.to_f / Pair.all.count
+      logger.warn "More than 50% (#{(control_point_pair_ratio*100).round(4)}%) of pairs have fewer than 3 control points. May potentially cause issues." if control_point_pair_ratio >= 0.5
+      bad_control_points
     end
 
     def fix_unconnected_image_pairs
-      horizontal_control_points, vertical_control_points = *control_points.partition { |cp| cp.conn_type == :horizontal }
-      control_points_of_pair = horizontal_control_points.group_by { |cp| [cp.n1, cp.n2] }.sort_by { |_, members| members.count }.last.last
-      logger.debug "found horizontal pair #{control_points_of_pair.first.n1} <> #{control_points_of_pair.first.n2} with #{control_points_of_pair.count} connections"
-      average_distance, distance_std = *calculate_average_and_std(name: :distance, values: control_points_of_pair.map(&:pdist), logger: logger)
-      horizontal_control_points_of_pair = control_points_of_pair.select { |cp| (cp.pdist - average_distance).abs < distance_std }
-      logger.info "removed #{control_points_of_pair.count - horizontal_control_points_of_pair.count} outliers"
-      # For logging
-      calculate_average_and_std(name: :distance, values: horizontal_control_points_of_pair.map(&:pdist), logger: logger)
-
-      control_points_of_pair = vertical_control_points.group_by { |cp| [cp.n1, cp.n2] }.sort_by { |_, members| members.count }.last.last
-      logger.debug "found vertical pair #{control_points_of_pair.first.n1} <> #{control_points_of_pair.first.n2} with #{control_points_of_pair.count} connections"
-      average_distance, distance_std = *calculate_average_and_std(name: :distance, values: control_points_of_pair.map(&:pdist), logger: logger)
-      vertical_control_points_of_pair = control_points_of_pair.select { |cp| (cp.pdist - average_distance).abs < distance_std }
-      logger.info "removed #{control_points_of_pair.count - vertical_control_points_of_pair.count} outliers"
-      # For logging
-      calculate_average_and_std(name: :distance, values: vertical_control_points_of_pair.map(&:pdist), logger: logger)
-
       logger.info 'finding unconnected image pairs'
-      unconnected_image_pairs = find_unconnected_image_pairs
 
-      logger.info unconnected_image_pairs.map { |i| { type: i[:type], pair: i[:pair].map(&:id) } }
+      Pair.calculate_neighborhoods(self)
+      Pair.calculate_neighborhood_groups
 
-      logger.info 'finding control points with unrealistic distances (<1)'
-      bad_control_points = control_points.select { |cp| cp.pdist <= 1.0 }
-      logger.info 'adding pairs that have do not have enough control points (<3)'
-      changing_control_points_pairs = control_points.group_by { |cp| [cp.n1, cp.n2] }.select { |_, cps| cps.count < 3 }
-      changed_pairs = []
-
-      logger.info 'writing new control points'
-      control_point_lines_started = false
-      @lines = @input.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
-            unconnected_image_pairs.map do |pair|
-              if pair[:type] == :horizontal
-                control_point = horizontal_control_points_of_pair.first
-              else
-                control_point = vertical_control_points_of_pair.first
-              end
-
-              x_diff = control_point.x2 - control_point.x1
-              y_diff = control_point.y2 - control_point.y1
-
-              x1 = x_diff <= 0 ? -x_diff + 15 : 0
-              y1 = y_diff <= 0 ? -y_diff + 15 : 0
-
-              control_point[:n] = pair[:pair].first.id
-              control_point[:N] = pair[:pair].last.id
-              control_point[:x] = x1
-              control_point[:X] = x1 + x_diff
-              control_point[:y] = y1
-              control_point[:Y] = y1 + y_diff
-
-              logger.debug "adding control points connecting #{control_point.n1} <> #{control_point.n2}"
-              i = images.first
-              3.times.map do
-                if control_point.conn_type == :horizontal
-                  control_point[:x] += 5
-                  control_point[:X] += 5
-                  control_point[:y] += i.h * 0.25
-                  control_point[:Y] += i.h * 0.25
-                else
-                  control_point[:x] += i.w * 0.25
-                  control_point[:X] += i.w * 0.25
-                  control_point[:y] += 5
-                  control_point[:Y] += 5
-                end
-                control_point.to_s
-              end.join
-            end + [line]
-          else
-            next line
-          end
-        else
-          control_point_lines_started = true
-          bad_control_point = bad_control_points.find { |cp| cp.raw == line }
-          changing_control_point_pair = changing_control_points_pairs.find { |_, cps| cps.find { |cp| cp.raw == line } }
-
-          if bad_control_point
-            if bad_control_point.conn_type == :horizontal
-              control_point = horizontal_control_points_of_pair.first
-            else
-              control_point = vertical_control_points_of_pair.first
-            end
-
-            x_diff = control_point.x2 - control_point.x1
-            y_diff = control_point.y2 - control_point.y1
-
-            x1 = x_diff <= 0 ? -x_diff + 15 : 0
-            y1 = y_diff <= 0 ? -y_diff + 15 : 0
-
-            control_point[:n] = bad_control_point[:n]
-            control_point[:N] = bad_control_point[:N]
-            control_point[:x] = x1
-            control_point[:X] = x1 + x_diff
-            control_point[:y] = y1
-            control_point[:Y] = y1 + y_diff
-
-            logger.debug "replacing unrealistic control point connecting #{control_point.n1} <> #{control_point.n2}"
-            i = images.first
-            3.times.map do
-              if control_point.conn_type == :horizontal
-                control_point[:x] += 5
-                control_point[:X] += 5
-                control_point[:y] += i.h * 0.25
-                control_point[:Y] += i.h * 0.25
-              else
-                control_point[:x] += i.w * 0.25
-                control_point[:X] += i.w * 0.25
-                control_point[:y] += 5
-                control_point[:Y] += 5
-              end
-              control_point.to_s
-            end.join
-          elsif changing_control_point_pair && !changed_pairs.include?(changing_control_point_pair.first)
-            changed_pairs << changing_control_point_pair.first
-            bad_control_point = changing_control_point_pair.last.first
-            if bad_control_point.conn_type == :horizontal
-              control_point = horizontal_control_points_of_pair.first
-            else
-              control_point = vertical_control_points_of_pair.first
-            end
-
-            x_diff = control_point.x2 - control_point.x1
-            y_diff = control_point.y2 - control_point.y1
-
-            x1 = x_diff <= 0 ? -x_diff + 15 : 0
-            y1 = y_diff <= 0 ? -y_diff + 15 : 0
-
-            control_point[:n] = bad_control_point[:n]
-            control_point[:N] = bad_control_point[:N]
-            control_point[:x] = x1
-            control_point[:X] = x1 + x_diff
-            control_point[:y] = y1
-            control_point[:Y] = y1 + y_diff
-
-            logger.debug "adding control points connecting #{control_point.n1} <> #{control_point.n2}"
-            i = images.first
-            3.times.map do
-              if control_point.conn_type == :horizontal
-                control_point[:x] += 5
-                control_point[:X] += 5
-                control_point[:y] += i.h * 0.25
-                control_point[:Y] += i.h * 0.25
-              else
-                control_point[:x] += i.w * 0.25
-                control_point[:X] += i.w * 0.25
-                control_point[:y] += 5
-                control_point[:Y] += 5
-              end
-              control_point.to_s
-            end.join
-          else
-            next line
-          end
-        end
-      end.compact.flatten
-    end
-
-    def fix_unconnected_image_pairs_neighborhoods
-      calculate_neighborhoods(amount_ratio: 1.0)
-      calculate_neighborhood_groups(name: :horizontal, pairs: @horizontal_pairs)
-      calculate_neighborhood_groups(name: :vertical, pairs: @vertical_pairs)
-
-      logger.info 'finding unconnected image pairs'
-      unconnected_image_pairs = find_unconnected_image_pairs
-      logger.info unconnected_image_pairs.map { |i| { type: i[:type], pair: i[:pair].map(&:id) } }
+      unconnected_image_pairs = Pair.unconnected
+      logger.debug unconnected_image_pairs.map { |i| { type: i.type, pair: i.pair.map(&:id) } }
 
       logger.info 'finding control points with unrealistic distances (<1)'
       bad_control_points = control_points.select { |cp| cp.pdist <= 1.0 }
       logger.info 'adding pairs that have do not have enough control points (<3)'
-      changing_control_points_pairs = control_points.group_by { |cp| [cp.n1, cp.n2] }.select { |_, cps| cps.count < 3 }
+      changing_control_points_pairs = Pair.without_enough_control_points
       changed_pairs = []
 
       logger.info 'writing new control points'
@@ -382,14 +57,14 @@ module Panomosity
           end
         else
           control_point_lines_started = true
-          bad_control_point = bad_control_points.find { |cp| cp.raw == line }
-          changing_control_point_pair = changing_control_points_pairs.find { |_, cps| cps.find { |cp| cp.raw == line } }
+          bad_control_point = bad_control_points.find { |c| c.raw == line }
+          changing_control_point_pair = changing_control_points_pairs.find { |pair| pair.control_points.find { |c| c.raw == line } }
 
           if bad_control_point
             generate_control_points(bad_control_point: bad_control_point, message: 'replacing unrealistic control point connecting')
-          elsif changing_control_point_pair && !changed_pairs.include?(changing_control_point_pair.first)
-            changed_pairs << changing_control_point_pair.first
-            bad_control_point = changing_control_point_pair.last.first
+          elsif changing_control_point_pair && !changed_pairs.include?(changing_control_point_pair.to_s)
+            changed_pairs << changing_control_point_pair.to_s
+            bad_control_point = changing_control_point_pair.control_points.first
             generate_control_points(bad_control_point: bad_control_point, message: 'adding control points connecting')
           else
             next line
@@ -398,56 +73,26 @@ module Panomosity
       end.compact.flatten
     end
 
-    def find_unconnected_image_pairs
-      ds = images.map(&:d).uniq.sort
-      es = images.map(&:e).uniq.sort
-
-      unconnected_image_pairs = []
-      # horizontal connection checking
-      es.each do |e|
-        ds.each_with_index do |d, index|
-          next if index == (ds.count - 1)
-          image_1 = images.find { |i| i.e == e && i.d == d }
-          image_2 = images.find { |i| i.e == e && i.d == ds[index+1] }
-          connected = control_points.any? { |cp| (cp.n1 == image_1.id && cp.n2 == image_2.id) || (cp.n1 == image_2.id && cp.n2 == image_1.id) }
-          unconnected_image_pairs <<  { type: :horizontal, pair: [image_1, image_2].sort_by(&:id) } unless connected
-        end
-      end
-
-      # vertical connection checking
-      ds.each do |d|
-        es.each_with_index do |e, index|
-          next if index == (es.count - 1)
-          image_1 = images.find { |i| i.d == d && i.e == e }
-          image_2 = images.find { |i| i.d == d && i.e == es[index+1] }
-          connected = control_points.any? { |cp| (cp.n1 == image_1.id && cp.n2 == image_2.id) || (cp.n1 == image_2.id && cp.n2 == image_1.id) }
-          unconnected_image_pairs << { type: :vertical, pair: [image_1, image_2].sort_by(&:id) } unless connected
-        end
-      end
-
-      unconnected_image_pairs
-    end
-
     def generate_control_points(pair: nil, bad_control_point: nil, message: '')
       if pair
-        if pair[:type] == :horizontal
-          group = @horizontal_neighborhoods_group.first
+        if pair.horizontal?
+          group = NeighborhoodGroup.horizontal.first
         else
-          group = @vertical_neighborhoods_group.first
+          group = NeighborhoodGroup.vertical.first
         end
       else
         if bad_control_point.conn_type == :horizontal
-          group = @horizontal_neighborhoods_group.first
+          group = NeighborhoodGroup.horizontal.first
         else
-          group = @vertical_neighborhoods_group.first
+          group = NeighborhoodGroup.vertical.first
         end
       end
 
-      control_point = ControlPoint.new(group[:neighborhood][:cp].attributes)
+      control_point = ControlPoint.new(group.center.center.attributes)
 
       if pair
-        control_point[:n] = pair[:pair].first.id
-        control_point[:N] = pair[:pair].last.id
+        control_point[:n] = pair.first_image.id
+        control_point[:N] = pair.last_image.id
       else
         control_point[:n] = bad_control_point[:n]
         control_point[:N] = bad_control_point[:N]
@@ -456,8 +101,8 @@ module Panomosity
       image_1 = images.find { |i| i.id == control_point[:n] }
       image_2 = images.find { |i| i.id == control_point[:N] }
 
-      x_diff = group[:x_avg] + (image_2.d - image_1.d)
-      y_diff = group[:y_avg] + (image_2.e - image_1.e)
+      x_diff = group.x_avg + (image_2.d - image_1.d)
+      y_diff = group.y_avg + (image_2.e - image_1.e)
 
       x1 = x_diff <= 0 ? -x_diff + 15 : 0
       y1 = y_diff <= 0 ? -y_diff + 15 : 0
@@ -467,22 +112,25 @@ module Panomosity
       control_point[:y] = y1
       control_point[:Y] = y1 + y_diff
 
-      logger.debug "#{message} #{control_point.n1} <> #{control_point.n2}"
+      logger.info "#{message} #{control_point.n1} <> #{control_point.n2}"
       i = images.first
       3.times.map do
         if control_point.conn_type == :horizontal
-          control_point[:x] += 5
-          control_point[:X] += 5
           control_point[:y] += i.h * 0.25
           control_point[:Y] += i.h * 0.25
         else
           control_point[:x] += i.w * 0.25
           control_point[:X] += i.w * 0.25
-          control_point[:y] += 5
-          control_point[:Y] += 5
         end
         control_point.to_s
       end.join
     end
+
+    def get_neigborhood_info
+      Pair.calculate_neighborhoods(self)
+      Pair.calculate_neighborhood_groups
+      Pair.info
+      NeighborhoodGroup.info
+    end
   end
 end

data/lib/panomosity/runner.rb

@@ -17,7 +17,8 @@ module Panomosity
       fix_unconnected_image_pairs
       generate_border_line_control_points
       get_columns_and_rows
-      get_detailed_control_point_info
+      get_control_point_info
+      get_neigborhood_info
       merge_image_parameters
       nona_grid
       optimize
@@ -36,17 +37,13 @@ module Panomosity
       @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)
+      @logger = Panomosity.logger
 
-      if options[:verbose]
+      if options[:verbose] || options[:very_verbose]
         @logger.level = Logger::DEBUG
       else
         @logger.level = Logger::INFO
       end
-
-      @logger.formatter = proc do |severity, datetime, progname, msg|
-        "[#{datetime}][#{severity}] #{msg}\n"
-      end
     end
 
     def run(command)
@@ -92,8 +89,8 @@ module Panomosity
     def clean_control_points
       logger.info 'cleaning control points'
       # Since this is very exact, having many outliers in control points distances will cause errors
-      panorama = Panorama.new(@input_file, logger)
-      bad_control_points = panorama.clean_control_points_neighborhoods(@options)
+      panorama = Panorama.new(@input_file, @options)
+      bad_control_points = panorama.clean_control_points
 
       logger.info "removing #{bad_control_points.count} control points"
       @lines = @input_file.each_line.map do |line|
@@ -252,8 +249,8 @@ module Panomosity
 
     def fix_unconnected_image_pairs
       logger.info 'fixing unconnected image pairs'
-      panorama = Panorama.new(@input_file, logger)
-      @lines = panorama.fix_unconnected_image_pairs_neighborhoods
+      panorama = Panorama.new(@input_file)
+      @lines = panorama.fix_unconnected_image_pairs
       save_file
     end
 
@@ -388,7 +385,7 @@ module Panomosity
       puts "#{columns},#{rows}"
     end
 
-    def get_detailed_control_point_info
+    def get_control_point_info
       logger.info 'getting detailed control point info'
       images = Image.parse(@input_file)
       panorama_variable = PanoramaVariable.parse(@input_file).first
@@ -400,6 +397,12 @@ module Panomosity
       end
     end
 
+    def get_neigborhood_info
+      logger.info 'getting detailed neighborhood info'
+      panorama = Panorama.new(@input_file, @options)
+      panorama.get_neigborhood_info
+    end
+
     def merge_image_parameters
       logger.info 'merging image parameters'
       control_points = ControlPoint.parse(@compare_file)
@@ -463,7 +466,7 @@ module Panomosity
 
     def optimize
       logger.info 'optimizing'
-      panorama = Panorama.new(@input_file, logger)
+      panorama = Panorama.new(@input_file)
       optimizer = Optimizer.new(panorama)
       optimizer.run
 

data/lib/panomosity/utils.rb

@@ -1,15 +1,24 @@
 module Panomosity
   module Utils
-    def calculate_average_and_std(name: 'value', values: [], logger: nil)
-      average_value = values.reduce(:+).to_f / values.count
-      logger.debug "average #{name}: #{average_value}" if logger
+    def calculate_average_and_std(name: 'value', values: [], logger: nil, ignore_empty: false)
+      return [0, 0] if ignore_empty && values.empty?
+      average_value = calculate_average(name: name, values: values, logger: logger, ignore_empty: ignore_empty)
+
       if values.count == 1
         value_std = 0.0
       else
         value_std = Math.sqrt(values.map { |v| (v - average_value) ** 2 }.reduce(:+) / (values.count - 1))
       end
       logger.debug "#{name} std: #{value_std}" if logger
+
       [average_value, value_std]
     end
+
+    def calculate_average(name: 'value', values: [], logger: nil, ignore_empty: false)
+      return 0 if ignore_empty && values.empty?
+      average_value = values.reduce(:+).to_f / values.count
+      logger.debug "average #{name}: #{average_value}" if logger
+      average_value
+    end
   end
 end

data/lib/panomosity/version.rb

@@ -1,3 +1,3 @@
 module Panomosity
-  VERSION = '0.1.17'
+  VERSION = '0.1.19'
 end

data/lib/panomosity.rb

@@ -1,7 +1,10 @@
 require 'panomosity/control_point'
 require 'panomosity/image'
+require 'panomosity/neighborhood'
+require 'panomosity/neighborhood_group'
 require 'panomosity/optimisation_variable'
 require 'panomosity/optimizer'
+require 'panomosity/pair'
 require 'panomosity/panorama'
 require 'panomosity/panorama_variable'
 require 'panomosity/runner'
@@ -55,6 +58,10 @@ module Panomosity
         options[:verbose] = v
       end
 
+      parser.on('-v', '--vverbose', 'Run very verbosely') do |v|
+        options[:very_verbose] = v
+      end
+
       parser.on('-h', '--help', 'Display this screen') do
         puts parser
         exit
@@ -66,4 +73,15 @@ module Panomosity
     runner = Runner.new(options)
     runner.run(ARGV[0])
   end
+
+  def self.logger
+    if @logger.nil?
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::DEBUG
+      @logger.formatter = proc do |severity, datetime, progname, msg|
+        "[#{datetime}][#{severity}] #{msg}\n"
+      end
+    end
+    @logger
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: panomosity
 version: !ruby/object:Gem::Version
-  version: 0.1.17
+  version: 0.1.19
 platform: ruby
 authors:
 - Oliver Garcia
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-05 00:00:00.000000000 Z
+date: 2018-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,8 +76,11 @@ files:
 - lib/panomosity.rb
 - lib/panomosity/control_point.rb
 - lib/panomosity/image.rb
+- lib/panomosity/neighborhood.rb
+- lib/panomosity/neighborhood_group.rb
 - lib/panomosity/optimisation_variable.rb
 - lib/panomosity/optimizer.rb
+- lib/panomosity/pair.rb
 - lib/panomosity/panorama.rb
 - lib/panomosity/panorama_variable.rb
 - lib/panomosity/runner.rb