chem_scanner 0.1.3

data/lib/chem_scanner/extension/element_map.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  class ElementMap < Hash
+    def except(id)
+      reject { |key, _| key == id }
+    end
+  end
+end

data/lib/chem_scanner/extension/geometry/bounding_box.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "geometry"
+
+module ChemScanner
+  # Extension module
+  module Extension
+    include Geometry
+
+    # Monkey path BoundingBox class from ruby-geometry
+    refine Geometry::BoundingBox do
+      def lefttop
+        Point.new(leftbottom.x, righttop.y)
+      end
+
+      def rightbottom
+        Point.new(righttop.x, leftbottom.y)
+      end
+
+      def center
+        lb = leftbottom
+        rt = righttop
+
+        Point.new((lb.x + rt.x) / 2, (lb.y + rt.y) / 2)
+      end
+
+      def edges
+        [
+          Segment.new(leftbottom, lefttop),
+          Segment.new(leftbottom, rightbottom),
+          Segment.new(lefttop, righttop),
+          Segment.new(rightbottom, righttop),
+        ]
+      end
+
+      def points
+        [leftbottom, lefttop, righttop, rightbottom]
+      end
+
+      def euclid_distance_to(other)
+        distance_list = []
+
+        edges.each do |edge|
+          other.edges.each do |oedge|
+            distance_list.push(edge.euclid_distance_to(oedge))
+          end
+        end
+
+        distance_list.min
+      end
+
+      def distance_to_point(point)
+        distance_list = []
+
+        edges.each do |edge|
+          distance_list.push(edge.distance_to(point))
+        end
+
+        distance_list.min
+      end
+
+      def euclid_distance_to_point(point)
+        point.distance_to(center)
+      end
+
+      def area
+        Segment.new(leftbottom, lefttop).length *
+          Segment.new(lefttop, righttop).length
+      end
+
+      def to_gis
+        coords = points.map { |point| "(#{point.x}, #{point.y})" }.join(",")
+        "POLYGON(#{coords})"
+      end
+
+      def contains_point?(point)
+        (
+          point.x <= righttop.x && point.x >= leftbottom.x &&
+          point.y <= righttop.y && point.y >= leftbottom.y
+        )
+      end
+    end
+  end
+end

data/lib/chem_scanner/extension/geometry/line.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "geometry"
+
+module ChemScanner
+  # Monkey path Line class from ruby-geometry
+  module Extension
+    include Geometry
+
+    # Monkey patch Line class
+    refine Geometry::Line do
+      def angle
+        return 90 if vertical?
+        return 0 if horizontal?
+
+        p1, p2 = [point1, point2].sort_by(&:x)
+        delta_x = p1.x - p2.x
+        delta_y = p1.y - p2.y
+
+        arc = if point1.y > point2.y # inverted axis/origin
+                Math.atan(delta_y / delta_x)
+              else
+                Math.atan(delta_x / delta_y)
+              end
+        (arc.positive? ? arc : (2 * Math::PI + arc)) * 360 / (2 * Math::PI)
+      end
+
+      def to_segment
+        Segment.new(point1, point2)
+      end
+
+      def abc_coeff
+        a = point2.y - point1.y
+        b = point1.x - point2.x
+        c = a * point1.x + b * point1.y
+
+        [a, b, c]
+      end
+
+      # Get point belong to the line, give x or y
+      def get_point(value, is_y = false)
+        if is_y
+          x = x_from_y(value)
+          Point.new(x, Float(value))
+        end
+
+        y = y_from_x(value)
+        Point.new(Float(value), y)
+      end
+
+      def x_from_y(point_y)
+        b = point1.y - point2.y
+        return nil if b.zero?
+
+        Float(point1.x - ((point1.y - point_y) * (point1.x - point2.x) / b))
+      end
+
+      def y_from_x(point_x)
+        b = point1.x - point2.x
+        return nil if b.zero?
+
+        Float(point1.y - ((point1.x - point_x) * (point1.y - point2.y)) / b)
+      end
+
+      def intersects_with_segment?(segment)
+        segment.intersects_with_line?(self)
+      end
+
+      def intersects_with_polygon?(polygon)
+        polygon.edges.each do |edge|
+          return true if intersects_with_segment?(edge)
+        end
+
+        false
+      end
+
+      def intersection_points_with_polygon(polygon)
+        polygon.intersection_points_with_line(self)
+      end
+
+      def intersection_points_with(line)
+        return nil if parallel_to?(line)
+
+        # Ax + By = C
+        a1, b1, c1 = abc_coeff
+        a2, b2, c2 = line.abc_coeff
+
+        determinant = a1 * b2 - a2 * b1
+
+        x = (b2 * c1 - b1 * c2) / determinant
+        y = (a1 * c2 - a2 * c1) / determinant
+
+        Point.new(x, y)
+      end
+
+      # positive: same side with point2
+      # negative: same side with point1
+      def point_side(point)
+        v = Segment.new(point1, point).to_vector
+        to_segment.to_vector.cross_product(v)
+      end
+
+      def perpen_line_via_point(point)
+        if vertical?
+          Line.new(point, Point.new(point.x + 5, point.y))
+        elsif horizontal?
+          Line.new(point, Point.new(point.x, point.y + 5))
+        else
+          m2 = (-1 / slope)
+          x2 = point.x + 5
+          y2 = m2 * x2 + (point.y - m2 * point.x)
+
+          Line.new(point, Point.new(x2, y2))
+        end
+      end
+
+      def point_projection(point)
+        pline = perpen_line_via_point(point)
+        pline.intersection_points_with(self)
+      end
+    end
+  end
+end

data/lib/chem_scanner/extension/geometry/point.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "geometry"
+
+module ChemScanner
+  # Monkey patch Point class from ruby-geometry
+  module Extension
+    refine Geometry::Point do
+      def euclid_distance_to_polygon(polygon)
+        polygon.euclid_distance_to_point(self)
+      end
+
+      def distance_to(other)
+        Geometry.distance(self, other)
+      end
+    end
+  end
+end

data/lib/chem_scanner/extension/geometry/polygon.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "geometry"
+
+module ChemScanner
+  include Geometry
+
+  # Extension module
+  module Extension
+    # Monkey path Polygon class from ruby-geometry
+    refine Geometry::Polygon do
+      def center
+        lb = bounding_box.leftbottom
+        rt = bounding_box.righttop
+
+        Point.new((lb.x + rt.x) / 2, (lb.y + rt.y) / 2)
+      end
+
+      def height
+        lb = bounding_box.leftbottom
+        lb.distance_to(bounding_box.lefttop)
+      end
+
+      def width
+        lb = bounding_box.leftbottom
+        lb.distance_to(bounding_box.rightbottom)
+      end
+
+      def intersects_with_polygon?(other)
+        edges.each do |e1|
+          other.edges.each do |e2|
+            return true if e1.intersects_with?(e2)
+          end
+        end
+
+        false
+      end
+
+      def contains_polygon?(other)
+        other.vertices.each do |v1|
+          return false unless contains?(v1)
+        end
+
+        true
+      end
+
+      def around_polygon?(other)
+        (
+          contains_polygon?(other) || other.contains_polygon?(self) ||
+          contains?(other.center) || other.contains?(center)
+        )
+      end
+
+      def merge_polygon(another)
+        lb = bounding_box.leftbottom
+        rt = bounding_box.righttop
+
+        alb = another.bounding_box.leftbottom
+        art = another.bounding_box.righttop
+
+        left = [lb.x, alb.x].min
+        bottom = [lb.y, alb.y].min
+        right = [rt.x, art.x].max
+        top = [rt.y, art.y].max
+
+        p1 = Point.new(left, bottom)
+        p2 = Point.new(left, top)
+        p3 = Point.new(right, top)
+        p4 = Point.new(right, bottom)
+
+        Polygon.new([p1, p2, p3, p4])
+      end
+
+      def distance_to_point(point)
+        min_dist = 9_999_999
+
+        edges.each do |edge|
+          dist = edge.distance_to(point)
+          min_dist = dist if dist < min_dist
+        end
+
+        min_dist
+      end
+
+      def euclid_distance_to_point(point)
+        min_dist = 9_999_999
+
+        edges.each do |edge|
+          dist = edge.euclid_distance_to_point(point)
+          min_dist = dist if dist < min_dist
+        end
+
+        min_dist
+      end
+
+      def intersection_points_with_line(line)
+        points = []
+
+        edges.each do |edge|
+          eline = edge.to_line
+          inter_x = eline.intersect_x(line)
+          next if inter_x.nil?
+
+          inter_y = line.y_from_x(inter_x)
+          inter_y = edge.to_line.y_from_x(inter_x) if inter_y.nil?
+
+          point = Point.new(inter_x, inter_y)
+          points.push(point) if edge.contains_point?(point)
+        end
+
+        points
+      end
+    end
+  end
+end

data/lib/chem_scanner/extension/geometry/segment.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "geometry"
+
+module ChemScanner
+  include Geometry
+
+  # Monkey patch ruby-geometry class
+  module Extension
+    # Monkey patch Segment class
+    refine Geometry::Segment do
+      def points
+        [point1, point2]
+      end
+
+      def contains_point?(point)
+        l1 = Geometry.distance(point1, point)
+        l2 = Geometry.distance(point, point2)
+
+        length.round(2) === (l1 + l2).round(2)
+      end
+
+      def contains_segment?(other)
+        contains_point?(other.point1) && contains_point?(other.point2)
+      end
+
+      def center
+        Point.new((point1.x + point2.x) / 2, (point1.y + point2.y) / 2)
+      end
+
+      def to_line
+        Line.new(point1, point2)
+      end
+
+      def intersects_with_polygon?(polygon)
+        count = 0
+        polygon.edges.each do |edge|
+          count += 1 if edge.intersects_with?(self)
+        end
+
+        count > 1
+      end
+
+      def intersects_with_line?(line)
+        sline = to_line
+        inter_x = sline.intersect_x(line)
+        return false if inter_x.nil?
+
+        inter_y = line.y_from_x(inter_x)
+        inter_y = to_line.y_from_x(inter_x) if inter_y.nil?
+        return false if inter_y.nil?
+
+        point = Point.new(inter_x, inter_y)
+        contains_point?(point)
+      end
+
+      def head_perpen_points_dist(distance)
+        dx = point2.x - point1.x
+        dy = point2.y - point1.y
+        dist = Math.sqrt((dx * dx) + (dy * dy))
+        dx /= dist
+        dy /= dist
+        x3 = point2.x + (distance * dy)
+        y3 = point2.y - (distance * dx)
+        x4 = point2.x - (distance * dy)
+        y4 = point2.y + (distance * dx)
+        [Point.new(x3, y3), Point.new(x4, y4)]
+      end
+
+      def tail_perpen_points_dist(distance)
+        dx = point1.x - point2.x
+        dy = point1.y - point2.y
+        dist = Math.sqrt((dx * dx) + (dy * dy))
+        dx /= dist
+        dy /= dist
+        x3 = point1.x + (distance * dy)
+        y3 = point1.y - (distance * dx)
+        x4 = point1.x - (distance * dy)
+        y4 = point1.y + (distance * dx)
+        [Point.new(x4, y4), Point.new(x3, y3)]
+      end
+
+      def parallel_at(point)
+        x4 = point.x + point2.x - point1.x
+        y4 = point.y + point2.y - point1.y
+        Point.new(x4, y4)
+      end
+
+      def euclid_distance_to(other)
+        l1 = point1.distance_to(other.point1)
+        l2 = point2.distance_to(other.point1)
+        l3 = point1.distance_to(other.point2)
+        l4 = point2.distance_to(other.point2)
+
+        [l1, l2, l3, l4].min
+      end
+
+      def euclid_distance_to_point(point)
+        l1 = point1.distance_to(point)
+        l2 = point2.distance_to(point)
+
+        [l1, l2].min
+      end
+
+      def euclid_distance_to_polygon(poly)
+        dist = []
+
+        poly.bounding_box.edges.each do |edge|
+          min_dist = euclid_distance_to(edge)
+          dist.push(min_dist)
+        end
+
+        dist.min
+      end
+
+      def distance_to_boundingbox(bbox)
+        dists = []
+
+        bbox.edges.each do |edge|
+          dist = distance_to_segment(edge)
+          dists.push(dist)
+        end
+
+        dists.min
+      end
+
+      def distance_to_segment(other)
+        [
+          other.distance_to(point1),
+          other.distance_to(point2),
+          distance_to(other.point1),
+          distance_to(other.point2),
+        ].min
+      end
+
+      def perpen_segment_via_point(point)
+        sline = to_line
+        pline = sline.perpen_line_via_point(point)
+
+        inter_point = pline.intersection_points_with(sline)
+        return nil if inter_point.nil?
+
+        Segment.new(point, inter_point)
+      end
+
+      def point_in_range(point, range, from_head = nil)
+        return false unless contains_point?(point)
+
+        dist1 = point1.distance_to(point)
+        dist2 = point2.distance_to(point)
+
+        dist = case from_head
+               when true then dist1
+               when false then dist2
+               when nil then [dist1, dist2].max
+               else return false
+               end
+
+        (dist / length) < range
+      end
+
+      def polygon_in_range(polygon)
+        line = to_line
+
+        polygon.vertices.each do |vertex|
+          ppoint = line.point_projection(vertex)
+          return true if contains_point?(ppoint)
+        end
+
+        false
+      end
+
+      def slice_to_many_points(num)
+        return [] if num < 2
+
+        delta_x = (point1.x - point2.x).abs
+        delta_y = (point1.y - point2.y).abs
+
+        avg_x = delta_x / (num + 1)
+        avg_y = delta_y / (num + 1)
+        default = OpenStruct.new(
+          x: [point1.x, point2.x].min, y: [point1.y, point2.y].min,
+        )
+
+        (1..num).to_a.reduce([]) do |arr, _|
+          prev = arr.last || default
+          arr.push(Point.new(prev.x + avg_x, prev.y + avg_y))
+        end
+      end
+
+      def to_gis
+        "SEGMENT((#{point1.x}, #{point1.y}), (#{point2.x}, #{point2.y}))"
+      end
+    end
+  end
+end