#!/usr/bin/env ruby

# This script creates a 512x512 image with individual pixels set to white
#
# The `points` array is a list of points I was testing to see if they intersect
# in the output `hough_line`

require "ruby-vips"
require "pp"

# Check points at different orientations to each other
#
# Only rendering two points at at time for simplicity
points = [
  # Corner pixels to test boundaries
  #[1, 1],
  #[1, 512],
  #[512, 1],
  #[512, 512],

  # horizontal line
  #[128, 256],
  #[384, 256],

  # vertical line
  #[256, 128],
  #[256, 384],

  # Points where no intersection is found `Vips::Image#hough_line`
  # points that would produce theta > 135; no intersection is found
  #[118, 128],
  #[274, 384],

  # Pixels at the right edge of the image that would cause theta to be near 180
  [511, 1],
  [512, 512],
]


# Build the image as an array of zeros
image_array = [[0]] * 512
image_array = [image_array] * 512

# Change the points to 255 (white)
points.each do |(x, y)|
  row_index = x - 1
  column_index = y - 1

  row = image_array[column_index].dup
  row[row_index] = [255]
  image_array[column_index] = row
end

image = Vips::Image.new_from_array(image_array)
image.write_to_file("test-hough-source.jpeg")

# Using a large number of theta steps to ensure pixels overlap in the Hough
# space overlap
theta_segments = 1800
# Using dimensions of the image times 2 to make sure I understand what the
# values of rho mean in the output of `hough_line`
rho_segments = 1024

#
## VIPS CALCULATION
#
hough_image = image.hough_line(width: theta_segments, height: rho_segments)

#
## MANUAL CALCULATION
#
# Manually find the Hough space for the image using an updated calculation for
# rho
hough_space_array = []
rho_segments.times do
  hough_space_array << [0] * theta_segments
end

sine_values = (0...theta_segments * 2).map { Math.sin(2 * Math::PI * _1 / (2 * theta_segments)) }

# Store this as a variable for debugging the calculation of `rho_step`
_points_sinusoids = points.map do |x, y|
  # This part of the calculation in `vips_hough_line_vote` needs to be updated
  # too
  x_normalized = x / Math.sqrt(2 * 512 ** 2)
  y_normalized = y / Math.sqrt(2 * 512 ** 2)

  (0...theta_segments).map do |theta_step|
    rho_normalized = x_normalized * sine_values[theta_step + theta_segments / 2] + y_normalized * sine_values[theta_step]

    # Compact and shift `rho_step` to fit in `rho_segments`
    #
    # For theta 0 - 180, the lower 15% of `rho_segments` will never have a value
    #
    # Calculating the Hough space for 0 - 360 would populate these values
    rho_step = (rho_normalized * rho_segments).to_i / 2 + (rho_segments / 2)

    hough_space_array[rho_step][theta_step] += 1

    rho_step
  end
end

hough_space_buffer = "".encode("BINARY")
hough_space_array.each do |row|
  hough_space_buffer << row.pack("C*")
end

hough_adjusted_image = Vips::Image.new_from_memory(hough_space_buffer, theta_segments, rho_segments, 1, "uchar")

[["default", hough_image], ["adjusted", hough_adjusted_image]].each do |name, image|
  image_any_votes = image > 0
  image_any_votes.write_to_file("test-hough-pixels-#{name}.jpeg")

  image_intersections = image > 1
  image_intersections.write_to_file("test-hough-intersections-#{name}.jpeg")

  # Outputting 5 values because the high resolution for theta means there can be
  # more than one intersection in Hough space for one line
  $stderr.puts "#{name}:"
  $stderr.puts image_intersections.max(size: 5, x_array: true, y_array: true, out_array: true).inspect
end