panomosity 0.1.32 → 0.1.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50e125a826a4accf978aa182be59f36de59c7697254b3eabd27b6fb831fb319d
-  data.tar.gz: 4b53136c72ddba3fd1515cd5b9aea76fa747abfff344ad9e485ad2026e407209
+  metadata.gz: 55fb5d3e10b18279691fb06a4cc567ca0a1bc01098d23d1247a9469e75ffc5e4
+  data.tar.gz: f5088d9459ecbeaa7f892d14f9a9deb12c33fd5017dd11625555e29d9fd95817
 SHA512:
-  metadata.gz: 21a995367c4d62e67ccbdda9a18587cd7ddefc3399e585307bb8b47c7390276074889f8cccbc267c062eed3a46052dc55796fe0280ad9e27635642a758f0de73
-  data.tar.gz: da2f34870a506e6b32d4a2be111b614fe2056b049df905d9c5738efa13ffb64c0f45fe02ac4b86f042ee8c692b7610e032ef8f0e0e94ddc835bc925226e79728
+  metadata.gz: fe93c2b8c9acfe777523d9533ca0391a7e63964a4a7facb153e7f7f8fb34ccf8616af7b998965c724f4779bc02d94e73356ac8f3f0208b604bbac1e1e0920c8e
+  data.tar.gz: 1e69b3b9c79df369d31330188ef7ab7c3d10e6aa9d2e625cbce1fe4e3d327b27ea1d9c5df7df03d27b2cbdc4fd17a2b84ce4832efd7ef04f61ac4fbaa38b6d73

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    panomosity (0.1.32)
+    panomosity (0.1.37)
 
 GEM
   remote: https://rubygems.org/
@@ -38,4 +38,4 @@ DEPENDENCIES
   rspec (~> 3.0)
 
 BUNDLED WITH
-   1.16.1
+   1.17.3

data/lib/panomosity.rb

@@ -1,5 +1,7 @@
 require 'panomosity/control_point'
+require 'panomosity/generalized_neighborhood'
 require 'panomosity/image'
+require 'panomosity/measure'
 require 'panomosity/neighborhood'
 require 'panomosity/neighborhood_group'
 require 'panomosity/optimisation_variable'
@@ -13,6 +15,7 @@ require 'panomosity/version'
 require 'pathname'
 require 'fileutils'
 require 'optparse'
+require 'json'
 
 module Panomosity
   def self.parse(arguments)
@@ -70,6 +73,42 @@ module Panomosity
         options[:report_type] = type
       end
 
+      parser.on('--darwin', 'Sets a flag to indicate the operating system') do |type|
+        options[:darwin] = type
+      end
+
+      parser.on('--version', 'Show the installed version') do
+        puts VERSION
+        exit
+      end
+
+      parser.on('--regional-distance-similarities-count COUNT', Integer, 'Set the minimum amount of regional control point counts for determining similar neighborhoods (default: 3)') do |count|
+        options[:regional_distance_similarities_count] = count
+      end
+
+      parser.on('--max-reduction-attempts COUNT', Integer, 'Set the max reduction attempts when removing neighborhood outliers (default: 2)') do |count|
+        options[:max_reduction_attempts] = count
+      end
+
+      desc = <<~DESC
+        Set distances to use when determining neighborhood region size in pairs
+        Use JSON e.g. '{"x1": 150, "x2": 30}'
+        Defaults:
+          Vertical pair is x is 10% of image width and y is 100px 
+          Horizontal pair is x is 100px and y is 10% of image height
+      DESC
+      parser.on('--distances [DISTANCE_JSON]', desc) do |distances|
+        options[:distances] = JSON.parse(distances) rescue nil
+      end
+
+      parser.on('--distances-horizontal [DISTANCE_JSON]', 'Same as above but only affects horizontal image pairs') do |distances|
+        options[:regional_distance_similarities_count] = JSON.parse(distances) rescue nil
+      end
+
+      parser.on('--distances-vertical [DISTANCE_JSON]', 'Same as above but only affects vertical image pairs') do |distances|
+        options[:regional_distance_similarities_count] = JSON.parse(distances) rescue nil
+      end
+
       parser.on('-h', '--help', 'Display this screen') do
         puts parser
         exit

data/lib/panomosity/control_point.rb

@@ -196,8 +196,8 @@ module Panomosity
       "#{to_s.sub(/\n/, '')} dist #{dist.round(4)} pixel_dist #{px.round(4)},#{py.round(4)},#{pdist.round(4)} pixel_r_dist #{prx.round(4)},#{pry.round(4)},#{prdist.round(4)} conn_type #{conn_type}"
     end
 
-    def attributes
-      @attributes
+    def attributes(raw: false)
+      @attributes.keep_if { |k, _| raw || !%i(raw i1 i2).include?(k) }
     end
   end
 end

data/lib/panomosity/generalized_neighborhood.rb

@@ -0,0 +1,262 @@
+require 'panomosity/utils'
+
+module Panomosity
+  class GeneralizedNeighborhood
+    include Panomosity::Utils
+
+    CONTROL_POINT_ATTRIBUTES = [:dist_avg, :dist_std, :x_avg, :x_std, :y_avg, :y_std]
+    ATTRIBUTES = [:center, :scope, :control_points, :count] + CONTROL_POINT_ATTRIBUTES
+    DEFAULT_DISTANCE = 100
+
+    attr_reader :measure, :options
+    attr_accessor *ATTRIBUTES
+
+    class << self
+      include Panomosity::Utils
+
+      attr_accessor :options, :neighborhoods, :horizontal_similar_neighborhoods, :vertical_similar_neighborhoods, :horizontal_neighborhoods_by_similar_neighborhood, :vertical_neighborhoods_by_similar_neighborhood
+
+      def logger
+        @logger ||= Panomosity.logger
+      end
+
+      def attributes
+        { name: name }
+      end
+
+      def horizontal
+        horizontal_neighborhoods_by_similar_neighborhood
+      end
+
+      def vertical
+        vertical_neighborhoods_by_similar_neighborhood
+      end
+
+      def calculate_all(panorama:, options: {})
+        @neighborhoods = []
+        @options = options
+
+        Pair.create_pairs_from_panorama(panorama)
+        calculate_from_pairs
+        calculate_from_neighborhoods(type: :horizontal)
+        calculate_from_neighborhoods(type: :vertical)
+
+        @neighborhoods
+      end
+
+      def calculate_from_pairs
+        logger.debug 'calculating neighborhoods from pairs'
+        Pair.all.each do |pair|
+          control_points = pair.control_points.select(&:not_generated?)
+          control_points.each do |control_point|
+            base_params = { center: control_point, scope: pair, options: options }
+            position_params = { measure: { type: :position } }
+            neighborhood = calculate_neighborhood(**base_params.merge(position_params))
+            pair.generalized_neighborhoods << neighborhood
+            distance_params = { measure: { type: :distance, distances: { x1: neighborhood.dist_std } } }
+            distance_neighborhood = calculate_neighborhood(**base_params.merge(distance_params))
+            neighborhood.reference = distance_neighborhood
+            pair.generalized_neighborhoods << distance_neighborhood
+          end
+        end
+      end
+
+      def calculate_from_neighborhoods(type:)
+        count = options[:regional_distance_similarities_count] || 3
+        attempts = options[:max_reduction_attempts] || 2
+
+        # calculates similar neighborhoods based on the regional control point distances by pair
+        calculate_similar_neighborhoods(type: type, count: count)
+        if neighborhoods.empty?
+          logger.warn 'total neighborhoods came up empty, neighborhood default count to 2'
+          calculate_similar_neighborhoods(type: type, count: 2)
+          raise 'still could not find neighborhoods' if neighborhoods.empty?
+        end
+
+        std_outlier_reduction(type: type, max_reduction_attempts: attempts)
+        calculate_neighborhoods_by_similar_neighborhood(type: type)
+      end
+
+      def calculate_neighborhood(center:, scope:, options:, measure: {})
+        neighborhood = new(center: center, scope: scope, options: options)
+        neighborhood.update_measure(measure)
+        @neighborhoods << neighborhood.calculate
+        neighborhood
+      end
+
+      def similar_neighborhoods(type: :horizontal)
+        type == :horizontal ? @horizontal_similar_neighborhoods : @vertical_similar_neighborhoods
+      end
+
+      def neighborhoods_by_similar_neighborhood(type: :horizontal)
+        type == :horizontal ? @horizontal_neighborhoods_by_similar_neighborhood : @vertical_neighborhoods_by_similar_neighborhood
+      end
+
+      def calculate_similar_neighborhoods(type: :horizontal, count: 3)
+        similar_neighborhoods = neighborhoods.select(&:measure_position?).select(&:"#{type}?").select do |neighborhood|
+          neighborhood.scope.similar_neighborhoods << neighborhood if neighborhood.reference.count >= count
+        end
+        self.send(:"#{type}_similar_neighborhoods=", similar_neighborhoods)
+      end
+
+      def std_outlier_reduction(type: :horizontal, max_reduction_attempts: 2, reduction_attempts: 0)
+        return if reduction_attempts >= max_reduction_attempts
+        logger.debug "twice reducing #{type} neighborhood std outliers"
+        avg, std = *calculate_average_and_std(values: similar_neighborhoods(type: type).map(&:dist_std))
+        similar_neighborhoods(type: type).select! { |n| (avg - n.dist_std).abs <= std }
+        std_outlier_reduction(type: type, max_reduction_attempts: max_reduction_attempts, reduction_attempts: reduction_attempts + 1)
+      end
+
+      def calculate_neighborhoods_by_similar_neighborhood(type: :horizontal)
+        instance_variable_set("@#{type}_neighborhoods_by_similar_neighborhood", [])
+        similar_neighborhoods(type: type).each do |neighborhood|
+          base_params = { center: neighborhood, scope: self, options: options }
+          distance_params = { measure: { type: :distance, distances: { x1: neighborhood.dist_std } } }
+          neighborhoods_by_similar_neighborhood(type: type) << calculate_neighborhood(**base_params.merge(distance_params))
+        end
+
+        neighborhoods_by_similar_neighborhood(type: type).sort_by! { |n| -n.count }
+        neighborhoods_by_similar_neighborhood(type: type).max_by(5) { |n| n.count }.each do |n|
+          logger.debug "#{n.dist_avg} #{n.dist_std} #{n.count} x#{n.x_avg} y#{n.y_avg}"
+        end
+      end
+    end
+
+    def initialize(center:, scope:, options: {})
+      @center = center
+      @scope = scope
+      @options = options
+      @measure = Measure.new
+    end
+
+    def id
+      @id
+    end
+
+    def id=(id)
+      @id = id
+    end
+
+    def reference
+      @reference
+    end
+
+    def reference=(reference)
+      @reference = reference
+    end
+
+    def pair_scope?
+      scope.class.name == 'Panomosity::Pair'
+    end
+
+    def neighborhood_scope?
+      scope.class.name == self.class.name
+    end
+
+    def measure_position?
+      measure.position?
+    end
+
+    def measure_distance?
+      measure.distance?
+    end
+
+    def horizontal?
+      pair_scope? ? scope.horizontal? : center.horizontal?
+    end
+
+    def vertical?
+      pair_scope? ? scope.vertical? : center.vertical?
+    end
+
+    def type
+      horizontal? ? :horizontal : :vertical
+    end
+
+    def update_measure(params)
+      measure.update(params)
+      set_distance_defaults
+      set_measure_defaults
+    end
+
+    def distances_from_options(type: :horizontal)
+      if type == :both
+        options.fetch(:distances, {})
+      else
+        options[:distances]&.fetch(type, {}) || {}
+      end
+    end
+
+    def set_distance_defaults
+      return unless measure_position?
+
+      measure.update_distances(distances_from_options(type: :both))
+
+      if scope.horizontal?
+        measure.update_distances(x2: (scope.first_image.h * 0.1).round)
+        measure.update_distances(distances_from_options(type: :horizontal))
+      else
+        measure.update_distances(x1: (scope.first_image.w * 0.1).round)
+        measure.update_distances(distances_from_options(type: :vertical))
+      end
+
+      measure.distances[:x1] ||= DEFAULT_DISTANCE
+      measure.distances[:x2] ||= DEFAULT_DISTANCE
+    end
+
+    def set_measure_defaults
+      center_values = if measure_position?
+        { x1: center.x1, x2: center.y1 }
+      elsif pair_scope?
+        { x1: center.pdist }
+      else
+        { x1: center.dist_avg }
+      end
+
+      measure.update(center: center_values)
+    end
+
+    def calculate
+      if pair_scope?
+        elements = scope.control_points.select(&:not_generated?)
+
+        @control_points = if measure_position?
+          elements.select { |cp| measure.includes?(cp.x1, cp.y1) }
+        else
+          elements.select { |cp| measure.includes?(cp.pdist) }
+        end
+      else
+        @neighborhoods = scope.similar_neighborhoods(type: center.type).select { |n| measure.includes?(n.dist_avg) }
+        distance_neighborhoods = @neighborhoods.map(&:reference)
+        @control_points = distance_neighborhoods.map(&:control_points).flatten.uniq(&:raw)
+      end
+
+      @dist_avg, @dist_std = *calculate_average_and_std(values: control_points.map(&:pdist), ignore_empty: true)
+      @x_avg, @x_std = *calculate_average_and_std(values: control_points.map(&:px), ignore_empty: true)
+      @y_avg, @y_std = *calculate_average_and_std(values: control_points.map(&:py), ignore_empty: true)
+      @count = control_points.count
+
+      self
+    end
+
+    def attributes
+      attributes = CONTROL_POINT_ATTRIBUTES.reduce({}) { |h, k| h.merge!({ k => self.send(k) }) }
+      measure_attributes = measure.attributes.reduce({}) do |hash, (key, value)|
+        hash["measure_#{key}"] = value
+        hash
+      end
+      if pair_scope?
+        center_id = center[:id]
+        scope_id = [scope.control_points.first.n1, scope.control_points.first.n2]
+        scope_name = 'pair'
+      else
+        center_id = center.id
+        scope_id = nil
+        scope_name = 'neighborhood'
+      end
+      attributes.merge!(measure_attributes)
+      attributes.merge!(id: id, center: center_id, scope_id: scope_id, scope_name: scope_name, type: type, control_points: control_points.map{|c| c[:id]})
+      attributes
+    end
+  end
+end

data/lib/panomosity/image.rb

@@ -1,4 +1,4 @@
-# Exmaple of an image line
+# Example 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
@@ -167,5 +167,11 @@ module Panomosity
       return unless name =~ /c(\d+)_r(\d+)\.jpg/
       name.scan(/c(\d+)_r(\d+)\.jpg/).flatten.map(&:to_i).last
     end
+
+    def attributes
+      attributes = @attributes.keep_if { |k, _| !%i(raw).include?(k) }
+      attributes.merge!(column: column || 0, row: row || 0)
+      attributes
+    end
   end
 end

data/lib/panomosity/measure.rb

@@ -0,0 +1,56 @@
+require 'panomosity/utils'
+
+module Panomosity
+  class Measure
+    include Panomosity::Utils
+
+    ATTRIBUTES = [:type, :center, :distances]
+    DEFAULT_DISTANCE = 100
+
+    attr_reader :options
+    attr_accessor *ATTRIBUTES
+
+    def initialize(attributes = {})
+      @attributes = attributes
+      @attributes[:center] ||= {}
+      @attributes[:distances] ||= {}
+    end
+
+    def position?
+      type == :position
+    end
+
+    def distance?
+      type == :distance
+    end
+
+    def type
+      @attributes[:type]
+    end
+
+    def center
+      @attributes[:center]
+    end
+
+    def distances
+      @attributes[:distances]
+    end
+
+    def update(attributes = {})
+
+      @attributes.merge!(attributes)
+    end
+
+    def update_distances(values = {})
+      @attributes[:distances].merge!(values)
+    end
+
+    def includes?(*values)
+      center.values.zip(values, distances.values).all? { |center, value, distance| (center - value).abs <= distance }
+    end
+
+    def attributes
+      { type: type, center: center.values, distances: distances.values }
+    end
+  end
+end

data/lib/panomosity/optimisation_variable.rb

@@ -59,12 +59,12 @@ module Panomosity
     end
 
     def to_s
-      line_values = @@attributes.map { |attribute| "#{attribute}#{self.send(attribute)}" }
-      "v #{line_values.join(' ')}\n"
+      line_values = @@attributes.map { |attribute| "#{attribute}#{self.send(attribute)}" if self.send(attribute) }
+      "v #{line_values.compact.join(' ')}\n"
     end
 
     def attributes
-      @attributes.keep_if { |k,_| !%i(raw).include?(k) }
+      @attributes.keep_if { |k, _| !%i(raw).include?(k) }
     end
   end
 end

data/lib/panomosity/optimizer.rb

@@ -30,17 +30,14 @@ module Panomosity
         logger.info "applying custom values of xh_avg: #{xh_avg}, yh_avg: #{yh_avg}, xv_avg: #{xv_avg}, yv_avg: #{yv_avg}"
       end
 
-      unless xh_avg && yh_avg && xv_avg && yv_avg
-        Pair.calculate_neighborhoods(panorama)
-        Pair.calculate_neighborhood_groups
-      end
+      panorama.calculate_neighborhoods unless xh_avg && yh_avg && xv_avg && yv_avg
 
       ds = images.map(&:d).uniq.sort
       es = images.map(&:e).uniq.sort
 
       # get the average error for the best neighborhood group
-      x_avg = xh_avg || NeighborhoodGroup.horizontal.first.rx_avg
-      y_avg = yv_avg || NeighborhoodGroup.vertical.first.ry_avg
+      x_avg = xh_avg || GeneralizedNeighborhood.horizontal.first.x_avg
+      y_avg = yv_avg || GeneralizedNeighborhood.vertical.first.y_avg
 
       # start horizontally
       d_map = {}
@@ -57,8 +54,8 @@ module Panomosity
       logger.debug "created e_map #{e_map}"
 
       # add in the other offset
-      x_avg = xv_avg || NeighborhoodGroup.vertical.first.rx_avg
-      y_avg = yh_avg || NeighborhoodGroup.horizontal.first.ry_avg
+      x_avg = xv_avg || GeneralizedNeighborhood.vertical.first.x_avg
+      y_avg = yh_avg || GeneralizedNeighborhood.horizontal.first.y_avg
 
       de_map = {}
       d_map.each_with_index do |(dk,dv),di|
@@ -142,10 +139,9 @@ module Panomosity
     end
 
     def calculate_average_distance
-      Pair.calculate_neighborhoods(panorama)
-      Pair.calculate_neighborhood_groups
-      horizontal_distances = NeighborhoodGroup.horizontal[0..4].map(&:prdist_avg)
-      vertical_distances = NeighborhoodGroup.vertical[0..4].map(&:prdist_avg)
+      panorama.calculate_neighborhoods
+      horizontal_distances = GeneralizedNeighborhood.horizontal[0..4].map(&:dist_avg)
+      vertical_distances = GeneralizedNeighborhood.vertical[0..4].map(&:dist_avg)
       calculate_average(values: horizontal_distances + vertical_distances)
     end
 
@@ -161,9 +157,8 @@ module Panomosity
       images.each do |image|
         image.r = 0.0
       end
-      Pair.calculate_neighborhoods(panorama)
-      Pair.calculate_neighborhood_groups
-      cps = NeighborhoodGroup.horizontal.first.control_points
+      panorama.calculate_neighborhoods
+      cps = GeneralizedNeighborhood.horizontal.first.control_points
       avg, std = *calculate_average_and_std(values: cps.map(&:roll))
       # 0.1 degrees of std
       while std > 0.1

data/lib/panomosity/pair.rb

@@ -5,7 +5,7 @@ module Panomosity
     include Panomosity::Utils
     extend Panomosity::Utils
 
-    attr_accessor :pair, :control_points, :neighborhoods, :type
+    attr_accessor :pair, :control_points, :neighborhoods, :type, :generalized_neighborhoods, :similar_neighborhoods
 
     class << self
       attr_accessor :panorama, :logger
@@ -22,8 +22,8 @@ module Panomosity
         @pairs
       end
 
-      def good_control_points_to_keep(count: 3)
-        @pairs.map { |pair| pair.good_control_points_to_keep(count: count) }.flatten.uniq(&:raw)
+      def select_control_points_with_regional_distance_similarities
+        @pairs.map(&:select_control_points_with_regional_distance_similarities).flatten.uniq(&:raw)
       end
 
       def unconnected
@@ -44,6 +44,9 @@ module Panomosity
       rows = images.map(&:row).uniq.sort
 
       @pairs = []
+      @horizontal_pairs = []
+      @vertical_pairs = []
+      
       # horizontal pair creation
       rows.each do |row|
         columns.each do |column|
@@ -52,7 +55,9 @@ module Panomosity
           image_2 = images.find { |i| i.row == row && i.column == column.next }
           next if @panorama.calibration? && (image_1.nil? || image_2.nil?)
           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)
+          pair = Pair.new([image_1, image_2].sort_by(&:id), control_points: control_points, type: :horizontal)
+          @pairs << pair
+          @horizontal_pairs << pair
         end
       end
 
@@ -64,7 +69,9 @@ module Panomosity
           image_2 = images.find { |i| i.column == column && i.row == row.next }
           next if @panorama.calibration? && (image_1.nil? || image_2.nil?)
           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)
+          pair = Pair.new([image_1, image_2].sort_by(&:id), control_points: control_points, type: :vertical)
+          @pairs << pair
+          @vertical_pairs << pair
         end
       end
     end
@@ -150,6 +157,8 @@ module Panomosity
       @pair = pair
       @control_points = control_points
       @neighborhoods = []
+      @generalized_neighborhoods = []
+      @similar_neighborhoods = []
       @type = type
     end
 
@@ -157,6 +166,10 @@ module Panomosity
       pair.map(&:id).to_s.gsub(' ', '')
     end
 
+    def ==(other)
+      to_s == other.to_s
+    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
@@ -218,6 +231,27 @@ module Panomosity
       end
     end
 
+    # Distance neighborhoods
+    def similar_control_points
+      @similar_control_points ||= similar_neighborhoods.map(&:reference).map(&:control_points).flatten.uniq(&:raw)
+    end
+
+    def select_control_points_with_regional_distance_similarities
+      # Keep all our control points if we have less than 10
+      if control_points.count >= 10
+        ratio = similar_control_points.count.to_f / control_points.count
+        if ratio < 0.2
+          Panomosity.logger.warn "#{to_s} keeping less than 20% (#{(ratio * 100).round(4)}%) of #{control_points.count} control points. Reverting and keeping all control points"
+          control_points
+        else
+          similar_control_points
+        end
+      else
+        Panomosity.logger.debug "Skipping pair #{to_s} since it has fewer than 10 control points"
+        control_points
+      end
+    end
+
     def best_neighborhood
       @best_neighborhood ||= @neighborhoods.max_by { |n| n.control_points.count }
     end
@@ -225,5 +259,17 @@ module Panomosity
     def control_points_of_best_neighborhood
       best_neighborhood ? best_neighborhood.control_points : []
     end
+
+    def attributes
+      x_avg, x_std = *calculate_average_and_std(values: control_points.map(&:px), ignore_empty: true)
+      y_avg, y_std = *calculate_average_and_std(values: control_points.map(&:py), ignore_empty: true)
+      dist_avg, dist_std = *calculate_average_and_std(values: control_points.map(&:pdist), ignore_empty: true)
+      i1 = control_points.first.n1
+      i2 = control_points.first.n2
+      {
+        id: [i1, i2], n: i1, N: i2, count: control_points.count, type: type,
+        x_avg: x_avg, x_std: x_std, y_avg: y_avg, y_std: y_std, dist_avg: dist_avg, dist_std: dist_std
+      }
+    end
   end
 end

data/lib/panomosity/panorama.rb

@@ -18,22 +18,25 @@ module Panomosity
       @logger = Panomosity.logger
     end
 
+    def calculate_neighborhoods
+      GeneralizedNeighborhood.calculate_all(panorama: self, options: options)
+    end
+
     def clean_control_points
-      if calibration?
-        Pair.calculate_neighborhoods(self, distance: 30)
-      else
-        Pair.calculate_neighborhoods(self, distance: 100)
-      end
-      control_points_to_keep = Pair.good_control_points_to_keep(count: 2)
+      options.merge!(distances: { x1: 30, x2: 30 }) if calibration? && !options[:distances].nil?
+      options.merge!(regional_distance_similarities_count: 2) unless options[:regional_distance_similarities_count]
+      calculate_neighborhoods
+
+      control_points_to_keep = Pair.select_control_points_with_regional_distance_similarities
       bad_control_points = control_points.reject { |cp| control_points_to_keep.map(&:raw).include?(cp.raw) }
       # far_control_points = control_points.select { |cp| cp.prdist > 50 }
       control_points_to_clean = bad_control_points.uniq(&:raw)
 
       # log warnings
       control_point_ratio = control_points_to_clean.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
+      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
+      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
 
       control_points_to_clean
     end
@@ -41,12 +44,8 @@ module Panomosity
     def fix_unconnected_image_pairs
       logger.info 'finding unconnected image pairs'
 
-      if calibration?
-        Pair.calculate_neighborhoods(self, distance: 30)
-      else
-        Pair.calculate_neighborhoods(self, distance: 100)
-      end
-      Pair.calculate_neighborhood_groups
+      options.merge!(distances: { x1: 30, x2: 30 }) if calibration? && !options[:distances].nil?
+      calculate_neighborhoods
 
       unconnected_image_pairs = Pair.unconnected
       logger.debug unconnected_image_pairs.map { |i| { type: i.type, pair: i.pair.map(&:id) } }
@@ -92,19 +91,19 @@ module Panomosity
     def generate_control_points(pair: nil, bad_control_point: nil, message: '')
       if pair
         if pair.horizontal?
-          group = NeighborhoodGroup.horizontal.first
+          group = GeneralizedNeighborhood.horizontal.first
         else
-          group = NeighborhoodGroup.vertical.first
+          group = GeneralizedNeighborhood.vertical.first
         end
       else
         if bad_control_point.conn_type == :horizontal
-          group = NeighborhoodGroup.horizontal.first
+          group = GeneralizedNeighborhood.horizontal.first
         else
-          group = NeighborhoodGroup.vertical.first
+          group = GeneralizedNeighborhood.vertical.first
         end
       end
 
-      control_point = ControlPoint.new(group.center.center.attributes)
+      control_point = ControlPoint.new(group.center.center.attributes(raw: true))
 
       if pair
         control_point[:n] = pair.first_image.id
@@ -153,8 +152,7 @@ module Panomosity
     end
 
     def diagnose
-      Pair.calculate_neighborhoods(self)
-      Pair.calculate_neighborhood_groups
+      calculate_neighborhoods
 
       recommendations = []
       messages = []
@@ -184,7 +182,7 @@ module Panomosity
       end
 
       # neighborhood group tests
-      group_count = NeighborhoodGroup.horizontal.count
+      group_count = GeneralizedNeighborhood.horizontal.count
       if group_count < 5
         message = <<~MESSAGE
           Total number of horizontal neighborhood groups is #{group_count} which is very low.
@@ -194,7 +192,7 @@ module Panomosity
         messages << message
       end
 
-      group_std_avg = calculate_average(values: NeighborhoodGroup.horizontal[0..4].map(&:prdist_std))
+      group_std_avg = calculate_average(values: GeneralizedNeighborhood.horizontal[0..4].map(&:dist_std))
       if group_std_avg > 1.0
         message = <<~MESSAGE
           The standard deviation of distances in the top 5 horizontal neighborhood groups is #{group_std_avg} which is high.
@@ -207,7 +205,7 @@ module Panomosity
         messages << message
       end
 
-      group_control_points = NeighborhoodGroup.horizontal.first.control_points.count
+      group_control_points = GeneralizedNeighborhood.horizontal.first.control_points.count
       total_control_points = Pair.horizontal.map(&:control_points).flatten.uniq(&:raw).count
       group_control_point_ratio = group_control_points.to_f / total_control_points
       if group_control_point_ratio < 0.2
@@ -222,7 +220,7 @@ module Panomosity
         recommendations << 'horizontal'
       end
 
-      group_count = NeighborhoodGroup.vertical.count
+      group_count = GeneralizedNeighborhood.vertical.count
       if group_count < 5
         message = <<~MESSAGE
           Total number of vertical neighborhood groups is #{group_count} which is very low.
@@ -232,7 +230,7 @@ module Panomosity
         messages << message
       end
 
-      group_std_avg = calculate_average(values: NeighborhoodGroup.vertical[0..4].map(&:prdist_std))
+      group_std_avg = calculate_average(values: GeneralizedNeighborhood.vertical[0..4].map(&:dist_std))
       if group_std_avg > 1.0
         message = <<~MESSAGE
           The standard deviation of distances in the top 5 vertical neighborhood groups is #{group_std_avg} which is high.
@@ -245,7 +243,7 @@ module Panomosity
         messages << message
       end
 
-      group_control_points = NeighborhoodGroup.vertical.first.control_points.count
+      group_control_points = GeneralizedNeighborhood.vertical.first.control_points.count
       total_control_points = Pair.vertical.map(&:control_points).flatten.uniq(&:raw).count
       group_control_point_ratio = group_control_points.to_f / total_control_points
       if group_control_point_ratio < 0.2
@@ -274,11 +272,24 @@ module Panomosity
           delta_d: delta_d,
           delta_e: delta_e,
           roll: roll,
-          horizontal: NeighborhoodGroup.horizontal.first.serialize,
-          vertical: NeighborhoodGroup.vertical.first.serialize
+          horizontal: GeneralizedNeighborhood.horizontal.first.attributes,
+          vertical: GeneralizedNeighborhood.vertical.first.attributes
         }
       }
+    rescue => error
+      message = "Got error #{error.message} when calculating neighborhoods. Recommending fallback"
 
+      logger.error message
+      error.backtrace.each { |line| logger.error line }
+
+      recommendations = %w(horizontal vertical)
+
+      diagnostic_report = {
+        messages: messages,
+        recommendations: recommendations,
+        data: {}
+      }
+    ensure
       File.open('diagnostic_report.json', 'w+') { |f| f.puts diagnostic_report.to_json }
 
       if recommendations.empty?
@@ -301,17 +312,13 @@ module Panomosity
       calibration_report = JSON.parse(File.read(filename))
 
       if @options[:report_type] == 'position'
-        if calibration?
-          Pair.calculate_neighborhoods(self, distance: 30)
-        else
-          Pair.calculate_neighborhoods(self, distance: 100)
-        end
-        Pair.calculate_neighborhood_groups
+        options.merge!(distances: { x1: 30, x2: 30 }) if calibration? && !options[:distances].nil?
+        calculate_neighborhoods
 
-        xh_avg = NeighborhoodGroup.horizontal.first.x_avg
-        yh_avg = NeighborhoodGroup.horizontal.first.y_avg
-        xv_avg = NeighborhoodGroup.vertical.first.x_avg
-        yv_avg = NeighborhoodGroup.vertical.first.y_avg
+        xh_avg = GeneralizedNeighborhood.horizontal.first.x_avg
+        yh_avg = GeneralizedNeighborhood.horizontal.first.y_avg
+        xv_avg = GeneralizedNeighborhood.vertical.first.x_avg
+        yv_avg = GeneralizedNeighborhood.vertical.first.y_avg
         calibration_report['position'] = {
           xh_avg: xh_avg,
           yh_avg: yh_avg,
@@ -327,7 +334,39 @@ module Panomosity
     end
 
     def calibration?
-      !!@input.split(/\n/).find { |line| '#panomosity calibration true' }
+      !!@input.split(/\n/).find { |line| line == '#panomosity calibration true' }
+    end
+
+    def save_file(filename)
+      logger.info "saving file #{filename}"
+
+      lines = @input.each_line.map do |line|
+        objects = [images, variable, control_points, optimisation_variables].flatten
+        object = objects.find { |object| object.raw == line }
+        object&.to_s || line
+      end.compact
+
+      File.open(filename, 'w') { |f| lines.each { |line| f.puts line } }
+    end
+
+    def attributes
+      calculate_neighborhoods
+      control_points = self.control_points.dup
+      control_points.each_with_index { |cp, i| cp[:id] = i }
+      neighborhoods = GeneralizedNeighborhood.neighborhoods.dup
+      neighborhoods.each_with_index { |n, i| n.id = i }
+      types = %i(horizontal vertical)
+      similar_neighborhoods = types.map { |type| GeneralizedNeighborhood.similar_neighborhoods(type: type) }.flatten
+      neighborhoods_by_similar_neighborhood = types.map { |type| GeneralizedNeighborhood.neighborhoods_by_similar_neighborhood(type: type) }.flatten
+      {
+        images: images.map(&:attributes),
+        variable: variable.attributes,
+        control_points: control_points.map(&:attributes),
+        optimisation_variables: optimisation_variables.map(&:attributes),
+        pairs: Pair.all.map(&:attributes),
+        similar_neighborhoods: similar_neighborhoods.map(&:attributes),
+        neighborhoods_by_similar_neighborhood: neighborhoods_by_similar_neighborhood.map(&:attributes)
+      }
     end
   end
 end

data/lib/panomosity/panorama_variable.rb

@@ -60,5 +60,9 @@ module Panomosity
       line_values = @@attributes.map { |attribute| "#{attribute}#{self.send(attribute)}" }
       "p #{line_values.join(' ')}\n"
     end
+
+    def attributes
+      @attributes.keep_if { |k, _| !%i(raw).include?(k) }
+    end
   end
 end

data/lib/panomosity/runner.rb

@@ -1,5 +1,6 @@
 require 'logger'
 require 'json'
+require 'csv'
 
 module Panomosity
   class Runner
@@ -18,12 +19,15 @@ module Panomosity
       create_calibration_report
       crop_centers
       diagnose
+      export_control_point_csv
       fix_conversion_errors
       fix_unconnected_image_pairs
       generate_border_line_control_points
       get_columns_and_rows
       get_control_point_info
       get_neighborhood_info
+      get_panorama_attributes
+      import_control_point_csv
       merge_image_parameters
       nona_grid
       optimize
@@ -73,7 +77,7 @@ module Panomosity
       optimizer = Optimizer.new(panorama)
       calibration_report = JSON.parse(@report_file)
 
-      if calibration_report.fetch('position')
+      if calibration_report.fetch('position', nil)
         logger.info 'calibration_report.json included position, applying position values'
         optimizer.run_position_optimizer(xh_avg: calibration_report['position']['xh_avg'],
                                          yh_avg: calibration_report['position']['yh_avg'],
@@ -81,7 +85,7 @@ module Panomosity
                                          yv_avg: calibration_report['position']['yv_avg'])
       end
 
-      if calibration_report.fetch('roll')
+      if calibration_report.fetch('roll', nil)
         logger.info 'calibration_report.json included roll, applying roll values'
         optimizer.run_roll_optimizer(apply_roll: calibration_report.fetch('roll'))
       end
@@ -289,6 +293,25 @@ module Panomosity
       panorama.diagnose
     end
 
+    def export_control_point_csv
+      logger.info 'exporting control point csv'
+      panorama = Panorama.new(@input_file, @options)
+      panorama.calculate_neighborhoods
+
+      filename = 'control_points.csv'
+      headers = %w(image_1_name image_2_name image_1_id image_2_id type width height d1 e1 d2 e2 x1 y1 x2 y2 rx ry r)
+      CSV.open(filename, 'w+') do |csv|
+        csv << headers
+        panorama.control_points.each do |cp|
+          pair = Pair.all.find { |p| p.control_points.include?(cp) }
+          csv << [cp.i1.name, cp.i2.name, cp.i1.id, cp.i2.id, pair.type, cp.i1.w, cp.i1.h, cp.i1.d, cp.i1.e,
+                  cp.i2.d, cp.i2.e, cp.x1, cp.y1, cp.x2, cp.y2, cp.px, cp.py, cp.pdist]
+        end
+      end
+
+      logger.info 'Done. Check for control_points.csv'
+    end
+
     def fix_conversion_errors
       logger.info 'fixing conversion errors'
       @lines = @input_file.each_line.map do |line|
@@ -459,6 +482,41 @@ module Panomosity
       panorama.get_neighborhood_info
     end
 
+    def get_panorama_attributes
+      # for printing out the JSON
+      logger.level = Logger::UNKNOWN
+      logger.info 'getting panorama attributes'
+      panorama = Panorama.new(@input_file, @options)
+      puts panorama.attributes.to_json
+    end
+
+    def import_control_point_csv
+      logger.info 'importing control point csv'
+      panorama = Panorama.new(@input_file, @options)
+
+      filename = @csv || 'control_points.csv'
+      csv = CSV.read(filename)
+      headers = csv.first
+      csv = csv[1..(csv.length - 1)]
+      data = csv.map { |s| Hash[headers.zip(s)] }
+
+      @lines = @input_file.each_line.map do |line|
+        cp = panorama.control_points.find { |c| c.raw == line }
+        if cp
+          kept_cp = data.find do |d|
+            cp.i1.id == d['image_1_id'].to_i && cp.i2.id == d['image_2_id'].to_i &&
+            cp.x1.round(4) == d['x1'].to_f.round(4) && cp.x2.round(4) == d['x2'].to_f.round(4) &&
+            cp.y1.round(4) == d['y1'].to_f.round(4) && cp.y2.round(4) == d['y2'].to_f.round(4)
+          end
+          cp.to_s if kept_cp
+        else
+          next line
+        end
+      end.compact
+
+      save_file
+    end
+
     def merge_image_parameters
       logger.info 'merging image parameters'
       control_points = ControlPoint.parse(@compare_file)
@@ -501,7 +559,7 @@ module Panomosity
       images = Image.parse(@input_file)
       res = @options[:res] || 'low'
       columns = images.map(&:column).uniq.sort
-      columns.each do |column|
+      commands = columns.map do |column|
         @output = "project_nona_c#{column}.pto"
         @output_file = File.new(@output, 'w')
         logger.debug "creating file #{@output}"
@@ -515,9 +573,19 @@ module Panomosity
         end.compact
         save_file
         logger.debug "running nona #{@output}"
-        output = `nona --save-intermediate-images --intermediate-suffix=intermediate -v -m TIFF_m --seam=blend #{@output} -o #{res}_res_stitch_section_c#{column.to_s.rjust(5, '0')}_`
+        output = "nona --save-intermediate-images --intermediate-suffix=intermediate -v -m TIFF_m --seam=blend #{@output} -o #{res}_res_stitch_section_c#{column.to_s.rjust(5, '0')}_"
         logger.debug output
+        output
+      end
+
+      logger.debug 'parallelizing'
+      if @options[:darwin]
+        parallel_command = "cat <<'EOF' |  parallel \n#{commands.join("\n")}\nEOF"
+      else
+        parallel_command = "cat <<'EOF' |  parallel -j $(fgrep -c processor /proc/cpuinfo) \n#{commands.join("\n")}\nEOF"
       end
+
+      `#{parallel_command}`
     end
 
     def optimize

data/lib/panomosity/version.rb

@@ -1,3 +1,3 @@
 module Panomosity
-  VERSION = '0.1.32'
+  VERSION = '0.1.37'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: panomosity
 version: !ruby/object:Gem::Version
-  version: 0.1.32
+  version: 0.1.37
 platform: ruby
 authors:
 - Oliver Garcia
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-19 00:00:00.000000000 Z
+date: 2020-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -77,7 +77,9 @@ files:
 - exe/panomosity
 - lib/panomosity.rb
 - lib/panomosity/control_point.rb
+- lib/panomosity/generalized_neighborhood.rb
 - lib/panomosity/image.rb
+- lib/panomosity/measure.rb
 - lib/panomosity/neighborhood.rb
 - lib/panomosity/neighborhood_group.rb
 - lib/panomosity/optimisation_variable.rb
@@ -108,8 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Wrapper for the PTO file parsing needed for PanoTools.