panomosity 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55acfc2af5503c105113d6f4b22464b2052915ebc265f64369f28a37733cd811
-  data.tar.gz: 7edea562a3ecd287ee4ec60bc209636d7494b52be234d2edb106b016b5d749fc
+  metadata.gz: 1e32fb89b5812b7f726cf6c322423d4e816aa103bde59bd5deef4bd6fb2279d4
+  data.tar.gz: 2aae7a094ad7bccd73af5d6042a799e29cd4ce1bd0e1bdd81d187b24e82b33f5
 SHA512:
-  metadata.gz: 227237855e4a0c4e38282837fed553b7add73ffd92d439bbf8a3678196589b0bd91b36c013e415a27e4699fc94f97fbe56fc946b3d5c94486eae1e9edf920ec5
-  data.tar.gz: 40b14486b54d7efaf753943c1886bb147a2646b6f10e6ea5e75907c575367db27ce3ad22e0a36a06178ee27160a126f4f16b0d623e2cb47a68ae465748438825
+  metadata.gz: d7d24392ffec1de2c6fb59b3ed8c4e03a59e91529ecc3a2a7c5d4bcca26383ea2a089dfd0f5e044fe2604c57b802324f6f4859532211b212808ea5a97aadc918
+  data.tar.gz: f41fae931324dc129bb4f9b8499f86d0d209dd9bcf9c396b768e988d9ab8abe62eec1032601335da697a7df69ebb9f26ae5c271b1fd040b66a6b3e8d6a021611

data/Gemfile.lock

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

data/exe/control_point_info.pl

@@ -1,4 +1,4 @@
-#!/usr/bin/env perl
+#!/usr/bin/perl
 
 use strict;
 use warnings;

data/lib/panomosity/control_point.rb

@@ -4,6 +4,7 @@
 module Panomosity
   class ControlPoint
     @@attributes = %i(n N x y X Y t)
+    @@calculated_attributes = %i(dist px py pdist conn_type)
 
     def self.parse(pto_file, cp_type: nil, compact: false)
       @control_points = pto_file.each_line.map do |line|
@@ -28,13 +29,44 @@ module Panomosity
         else
           @control_points
       end
+
+      @control_points
     end
 
     def self.get_detailed_info(pto_file_path, cp_type: nil)
-      result = `control_point_info.pl --input #{pto_file_path}`
+      exe_dir = File.expand_path('../../exe', File.dirname(__FILE__))
+      control_point_info_executable = File.join(exe_dir, 'control_point_info.pl')
+      result = `#{control_point_info_executable} --input #{pto_file_path}`
       parse(result, cp_type: cp_type, compact: true)
     end
 
+    def self.calculate_distances(images, panorama_variable)
+      @control_points.each do |cp|
+        image1 = images.find { |i| cp.n1 == i.id }
+        image2 = images.find { |i| cp.n2 == i.id }
+        point1 = image1.to_cartesian(cp.x1, cp.y1)
+        point2 = image2.to_cartesian(cp.x2, cp.y2)
+
+        angle = Math.acos(point1[0] * point2[0] + point1[1] * point2[1] + point1[2] * point2[2])
+        radius = (panorama_variable.w / 2.0) / Math.tan((panorama_variable.v * Math::PI / 180) / 2)
+
+        distance = angle * radius
+        cp.dist = distance
+
+        # Pixel distance
+        x1 = (image1.w / 2.0) - cp.x1 + image1.d
+        y1 = (image1.h / 2.0) - cp.y1 + image1.e
+        x2 = (image2.w / 2.0) - cp.x2 + image2.d
+        y2 = (image2.h / 2.0) - cp.y2 + image2.e
+
+        pixel_distance = Math.sqrt((x1 - x2)**2 + (y1 - y2)**2)
+        cp.px = x1 - x2
+        cp.py = y1 - y2
+        cp.pdist = pixel_distance
+        cp.conn_type = image1.d == image2.d ? :vertical : :horizontal
+      end
+    end
+
     def self.all
       @control_points
     end
@@ -55,11 +87,20 @@ module Panomosity
       end
     end
 
+    def self.merge(first_set_control_points, second_set_control_points)
+      @control_points = first_set_control_points.map do |cp1|
+        similar_control_point = second_set_control_points.find { |cp2| cp1 == cp2 }
+        cp1.dist = similar_control_point.dist
+        cp1
+      end
+    end
+
     def initialize(attributes)
       @attributes = attributes
       # conform data types
       @attributes.each do |key, value|
         next if %i(raw).include?(key)
+        next unless value.is_a?(String)
         if value.respond_to?(:include?) && value.include?('.')
           @attributes[key] = value.to_f
         else
@@ -76,7 +117,7 @@ module Panomosity
       @attributes[key] = value
     end
 
-    (@@attributes + %i(raw dist)).each do |attr|
+    (@@attributes + @@calculated_attributes + %i(raw)).each do |attr|
       define_method(attr) do
         @attributes[attr]
       end
@@ -114,5 +155,14 @@ module Panomosity
       line_values = @@attributes.map { |attribute| "#{attribute}#{self.send(attribute)}" }
       "c #{line_values.join(' ')}\n"
     end
+
+    def ==(o)
+      n1 == o.n1 &&
+        n2 == o.n2 &&
+        x1.floor == o.x1.floor &&
+        x2.floor == o.x2.floor &&
+        y1.floor == o.y1.floor &&
+        y2.floor == o.y2.floor
+    end
   end
 end

data/lib/panomosity/image.rb

@@ -106,10 +106,10 @@ module Panomosity
       self[:TrY] * self.class.panosphere * height
     end
 
-    def to_s
+    def to_s(options = {})
       subline_values = (@@attributes - %i(Vm n)).map do |attribute|
         value = self.send(attribute)
-        if @@equaled_attributes.include?(attribute)
+        if @@equaled_attributes.include?(attribute) && !options[:without_equal_signs]
           if value == 0.0
             "#{attribute}=#{value.to_i}"
           else
@@ -139,5 +139,22 @@ module Panomosity
       self[:e] = try
       self
     end
+
+    def to_cartesian(x1, y1)
+      px = (w / 2.0) - x1 + d
+      py = (h / 2.0) - y1 + e
+      rad = (w / 2.0) / Math.tan((v * Math::PI / 180) / 2)
+      r = self.r * Math::PI / 180
+      p = self.p * Math::PI / 180
+      y = self.y * Math::PI / 180
+
+      # Derived from multiplication of standard roll, pitch, and yaw matrices by the point vector (rad, px, py)
+      point = [Math.cos(p) * Math.cos(y) * rad - Math.sin(y) * Math.cos(p) * px + Math.sin(p) * py,
+               Math.sin(r) * Math.sin(p) * Math.cos(y) * rad + Math.sin(y) * Math.cos(r) * rad - Math.sin(r) * Math.sin(p) * Math.sin(y) * px + Math.cos(r) * Math.cos(y) * px - Math.sin(r) * Math.cos(p) * py,
+               -Math.sin(p) * Math.cos(r) * Math.cos(y) * rad + Math.sin(r) * Math.sin(y) * rad + Math.sin(p) * Math.sin(y) * Math.cos(r) * px + Math.sin(r) * Math.cos(y) * px + Math.cos(r) * Math.cos(p) * py]
+      magnitude = Math.sqrt(point[0] ** 2 + point[1] ** 2 + point[2] ** 2)
+      normalized_point = [point[0] / magnitude, point[1] / magnitude, point[2] / magnitude]
+      normalized_point
+    end
   end
 end

data/lib/panomosity/panorama_variable.rb

@@ -0,0 +1,64 @@
+module Panomosity
+  class PanoramaVariable
+    @@attributes = %i(p w h f v n E R)
+
+    def self.parse(pto_file)
+      @panorama_variables = pto_file.each_line.map { |line| parse_line(line) }.compact
+    end
+
+    def self.all
+      @panorama_variables
+    end
+
+    def self.parse_line(line)
+      parts = line.split(' ')
+      if parts.first == 'p'
+        data = parts.each_with_object({}) do |part, hash|
+          attribute = @@attributes.find { |attr| part[0] == attr.to_s }
+          next unless attribute
+          hash[attribute] = part.sub(attribute.to_s, '')
+        end
+
+        data[:raw] = line
+
+        new data
+      end
+    end
+
+    def initialize(attributes)
+      @attributes = attributes
+      # conform data types
+      @attributes.each do |key, value|
+        next if %i(n raw).include?(key)
+        if value.respond_to?(:include?) && value.include?('.')
+          @attributes[key] = value.to_f
+        else
+          @attributes[key] = value.to_i
+        end
+      end
+    end
+
+    def [](key)
+      @attributes[key]
+    end
+
+    def []=(key, value)
+      @attributes[key] = value
+    end
+
+    (@@attributes + %i(raw)).each do |attr|
+      define_method(attr) do
+        @attributes[attr]
+      end
+
+      define_method(:"#{attr}=") do |value|
+        @attributes[attr] = value
+      end
+    end
+
+    def to_s
+      line_values = @@attributes.map { |attribute| "#{attribute}#{self.send(attribute)}" }
+      "p #{line_values.join(' ')}\n"
+    end
+  end
+end

data/lib/panomosity/runner.rb

@@ -33,9 +33,9 @@ module Panomosity
       @logger = Logger.new(STDOUT)
 
       if options[:verbose]
-        @logger.level = Logger::INFO
-      else
         @logger.level = Logger::DEBUG
+      else
+        @logger.level = Logger::INFO
       end
 
       @logger.formatter = proc do |severity, datetime, progname, msg|
@@ -89,7 +89,11 @@ module Panomosity
       @lines = @input_file.each_line.map do |line|
         image = images.find { |i| i.raw == line }
         if image
-          image.to_s
+          if @options[:remove_equal_signs]
+            image.to_s(without_equal_signs: true)
+          else
+            image.to_s
+          end
         else
           next line
         end
@@ -154,16 +158,16 @@ module Panomosity
       # Since all images have been cropped, we need to change d,e params to move images based on how much was cropped
       # Re-run commands that have been run at this point
       logger.info 'rerunning commands'
-      @new_input_file_path = 'project_converted_translation_cropped.pto'
+      @new_input = 'project_converted_translation_cropped.pto'
       `match-n-shift --input #{@csv} -o project_cropped.pto`
       `pto_var --opt=TrX,TrY project_cropped.pto -o project_pto_var_cropped.pto`
-      runner = Runner.new(@options.merge(input: 'project_pto_var_cropped.pto', output: @new_input_file_path))
+      runner = Runner.new(@options.merge(input: 'project_pto_var_cropped.pto', output: @new_input))
       runner.run('convert_translation_parameters')
-      `pano_modify -p 0 --fov=AUTO -o #{@new_input_file_path} #{@new_input_file_path}`
+      `pano_modify -p 0 --fov=AUTO -o #{@new_input} #{@new_input}`
 
-      logger.info "Read new #{@new_input_file_path}"
+      logger.info "Read new #{@new_input}"
       # Read new input pto file
-      @input_file = File.new(@new_input_file_path, 'r').read
+      @input_file = File.new(@new_input, 'r').read
       images = Image.parse(@input_file)
       ds = images.map(&:d).uniq.sort
       es = images.map(&:e).uniq.sort
@@ -220,7 +224,108 @@ module Panomosity
     def fix_unconnected_image_pairs
       logger.info 'fixing unconnected image pairs'
       images = Image.parse(@input_file)
+      panorama_variable = PanoramaVariable.parse(@input_file).first
+      ControlPoint.parse(@input_file)
+      control_points = ControlPoint.calculate_distances(images, panorama_variable)
+
+      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 = control_points_of_pair.map(&:pdist).reduce(:+).to_f / control_points_of_pair.count
+      logger.debug "average distance #{average_distance}"
+      dist_std = Math.sqrt(control_points_of_pair.map { |cp| (cp.pdist - average_distance) ** 2 }.reduce(:+) / (control_points_of_pair.count - 1))
+      logger.debug "dist std: #{dist_std}"
+      horizontal_control_points_of_pair = control_points_of_pair.select { |cp| (cp.pdist - average_distance).abs < dist_std }
+      logger.info "removed #{control_points_of_pair.count - horizontal_control_points_of_pair.count} outliers"
+      new_average_distance = horizontal_control_points_of_pair.map(&:pdist).reduce(:+).to_f / horizontal_control_points_of_pair.count
+      logger.info "new average #{new_average_distance}"
+
+      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 = control_points_of_pair.map(&:pdist).reduce(:+).to_f / control_points_of_pair.count
+      logger.debug "average distance #{average_distance}"
+      dist_std = Math.sqrt(control_points_of_pair.map { |cp| (cp.pdist - average_distance) ** 2 }.reduce(:+) / (control_points_of_pair.count - 1))
+      logger.debug "dist std: #{dist_std}"
+      vertical_control_points_of_pair = control_points_of_pair.select { |cp| (cp.pdist - average_distance).abs < dist_std }
+      logger.info "removed #{control_points_of_pair.count - vertical_control_points_of_pair.count} outliers"
+      new_average_distance = vertical_control_points_of_pair.map(&:pdist).reduce(:+).to_f / vertical_control_points_of_pair.count
+      logger.info "new average #{new_average_distance}"
+
+      logger.info 'finding 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
+
+      logger.info unconnected_image_pairs.map { |i| { type: i[:type], pair: i[:pair].map(&:id) } }
+
+      logger.info 'finding control points with unrealistic distances (<1)'
+      fake_control_points = control_points.select { |cp| cp.pdist <= 1.0 }
+
+      logger.info 'writing new control points'
+      control_point_lines_started = false
+      @lines = @input_file.each_line.map do |line|
+        cp = ControlPoint.parse_line(line)
+        if cp.nil?
+          # Control point lines ended
+          if control_point_lines_started
+            control_point_lines_started = false
+            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
+
+              control_point[:n] = pair[:pair].first.id
+              control_point[:N] = pair[:pair].last.id
+              logger.debug "adding control point connecting #{control_point.n1} <> #{control_point.n2}"
+              control_point.to_s
+            end + [line]
+          else
+            next line
+          end
+        else
+          control_point_lines_started = true
+          fake_control_point = fake_control_points.find { |cp| cp.raw == line }
+          if fake_control_point
+            if fake_control_point.conn_type == :horizontal
+              control_point = horizontal_control_points_of_pair.first
+            else
+              control_point = vertical_control_points_of_pair.first
+            end
+            control_point[:n] = fake_control_point[:n]
+            control_point[:N] = fake_control_point[:N]
+            logger.debug "replacing unrealistic control point connecting #{control_point.n1} <> #{control_point.n2}"
+            control_point.to_s
+          else
+            next line
+          end
+        end
+      end.compact.flatten
 
+      save_file
     end
 
     def generate_border_line_control_points
@@ -348,19 +453,40 @@ module Panomosity
     end
 
     def get_detailed_control_point_info
-      logger.info 'removing long lines'
+      logger.info 'getting detailed control point info'
 
       images = Image.parse(@input_file)
-      control_points = ControlPoint.get_detailed_info(@input, cp_type: :normal)
+      panorama_variable = PanoramaVariable.parse(@input_file).first
+      first_set_control_points = ControlPoint.parse(@input_file)
+
+      @new_input = 'project_remove_equal_signs.pto'
+      runner = Runner.new(@options.merge(input: @input, output: @new_input, remove_equal_signs: true))
+      runner.run('convert_equaled_image_parameters')
+      @input_file = File.new(@new_input, 'r').read
+
+      second_set_control_points = ControlPoint.get_detailed_info(@new_input)
+      control_points = ControlPoint.merge(first_set_control_points, second_set_control_points)
       control_points.each do |cp|
         image1 = images.find { |i| cp.n1 == i.id }
         image2 = images.find { |i| cp.n2 == i.id }
-        # dist = ((image1.normal_x + cp.x1) - (image2.normal_x + cp.x2)) ** 2 + ((image1.normal_y + cp.y1) - (image2.normal_y + cp.y2)) ** 2
-        dx = (image1.d - cp.x1) - (image2.d - cp.x2)
-        dy = (image1.e - cp.y1) - (image2.e - cp.y2)
-        logger.debug "#{cp.to_s} distrt #{Math.sqrt(dx**2+dy**2)} iy1 #{image1.normal_y} iy2 #{image2.normal_y}"
+        point1 = image1.to_cartesian(cp.x1, cp.y1)
+        point2 = image2.to_cartesian(cp.x2, cp.y2)
+
+        angle = Math.acos(point1[0] * point2[0] + point1[1] * point2[1] + point1[2] * point2[2])
+        radius = (panorama_variable.w / 2.0) / Math.tan((panorama_variable.v * Math::PI / 180) / 2)
+
+        x1 = (image1.w / 2.0) - cp.x1 + image1.d
+        y1 = (image1.h / 2.0) - cp.y1 + image1.e
+        x2 = (image2.w / 2.0) - cp.x2 + image2.d
+        y2 = (image2.h / 2.0) - cp.y2 + image2.e
+
+        dist = Math.sqrt((x1 - x2)**2 + (y1 - y2)**2)
+
+        dr = angle * radius
+
+        type = image1.d == image2.d ? :vertical : :horizontal
+        logger.debug "#{cp.to_s.sub(/\n/, '')} dist #{dr} pixel_dist #{x1-x2},#{y1-y2},#{dist} type #{type}"
       end
-      logger.debug "avg #{control_points.map(&:dist).reduce(:+)/control_points.count.to_f}"
     end
 
     def merge_image_parameters

data/lib/panomosity/version.rb

@@ -1,3 +1,3 @@
 module Panomosity
-  VERSION = '0.1.2'
+  VERSION = '0.1.4'
 end

data/lib/panomosity.rb

@@ -1,6 +1,7 @@
 require 'panomosity/control_point'
 require 'panomosity/image'
 require 'panomosity/optimisation_variable'
+require 'panomosity/panorama_variable'
 require 'panomosity/runner'
 require 'panomosity/version'
 require 'pathname'
@@ -35,6 +36,10 @@ module Panomosity
         options[:without_cropping] = wc
       end
 
+      parser.on('--remove-equal-signs', 'Do not crop when running "crop_centers" (usually when the original run failed)') do |eq|
+        options[:remove_equal_signs] = eq
+      end
+
       parser.on('-v', '--[no-]verbose', 'Run verbosely') do |v|
         options[:verbose] = v
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: panomosity
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Oliver Garcia
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-22 00:00:00.000000000 Z
+date: 2018-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -78,6 +78,7 @@ files:
 - lib/panomosity/control_point.rb
 - lib/panomosity/image.rb
 - lib/panomosity/optimisation_variable.rb
+- lib/panomosity/panorama_variable.rb
 - lib/panomosity/runner.rb
 - lib/panomosity/version.rb
 - panomosity.gemspec