chem_scanner 0.1.3

data/lib/chem_scanner/extension/passthrough.rb

@@ -0,0 +1,7 @@
+module Passthrough
+  def passthrough(object)
+    object.instance_variables.each do |iv|
+      instance_variable_set(iv, object.instance_variable_get(iv))
+    end
+  end
+end

data/lib/chem_scanner/interpreter/element/arrow.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    using Extension
+
+    # Base Arrow, independent from reader
+    class Arrow
+      attr_accessor :id, :middle_points, :tail, :head, :descriptions,
+                    :text_arr, :cross, :cross_lines, :reagents_polygons,
+                    :height, :line_type
+
+      # Polyline path: tail -> middle1 -> middle2 -> ... -> head
+      def initialize(geometry)
+        @geometry = geometry
+        @id = geometry.id
+        @tail = Geometry::Point.new(geometry.tail[:x], geometry.tail[:y])
+        @head = Geometry::Point.new(geometry.head[:x], geometry.head[:y])
+
+        @middle_points = []
+        @cross = geometry.cross?
+        @line_type = geometry.line_type
+        @cross_lines = []
+        @height = 0
+        @text_arr = []
+        @reagents_polygons = []
+      end
+
+      def points
+        [@tail] + @middle_points + [@head]
+      end
+
+      def segments
+        arr = []
+        points.each_with_index do |point, idx|
+          next if idx == points.count - 1
+
+          segment = Geometry::Segment.new(point, points[idx + 1])
+          arr.push(segment)
+        end
+
+        arr
+      end
+
+      def head_segment
+        point = @middle_points.count.zero? ? @tail : @middle_points.last
+        Geometry::Segment.new(point, @head)
+      end
+
+      def head_perpen_points
+        return nil if @head.nil? || @height.zero?
+
+        tail = @middle_points.count.zero? ? @tail : @middle_points.last
+        Geometry::Segment.new(tail, @head).tail_perpen_points_dist(@height)
+      end
+
+      def head_perpen_segment
+        p1, p2 = head_perpen_points
+        Geometry::Segment.new(p1, p2)
+      end
+
+      def tail_segment
+        point = @middle_points.count.zero? ? @head : @middle_points.first
+        Geometry::Segment.new(point, @tail)
+      end
+
+      def tail_perpen_points
+        return nil if @tail.nil? || @height.zero?
+
+        head = @middle_points.count.zero? ? @head : @middle_points.first
+        Geometry::Segment.new(@tail, head).head_perpen_points_dist(@height)
+      end
+
+      def tail_perpen_segment
+        p1, p2 = tail_perpen_points
+        Geometry::Segment.new(p1, p2)
+      end
+
+      def tail_head_segment
+        Geometry::Segment.new(@tail, @head)
+      end
+
+      def add_cross_segment(other)
+        @cross_lines.push(other)
+        @cross = true
+      end
+
+      def change_head(new_head)
+        @middle_points.push(@head)
+        @head = Geometry::Point.new(new_head[:x], new_head[:y])
+      end
+
+      def change_tail(new_tail)
+        @middle_points.unshift(@tail)
+        @tail = Geometry::Point.new(new_tail.x, new_tail.y)
+      end
+
+      def update_tail(new_tail)
+        @tail = Geometry::Point.new(new_tail.x, new_tail.y)
+      end
+
+      # Polyline path: tail -> middle1 -> middle2 -> ... -> head
+      def build_polygons(height)
+        @height = height
+        @reagents_polygons = []
+
+        segments.each do |segment|
+          p1, p2 = segment.head_perpen_points_dist(height)
+          p3, p4 = segment.tail_perpen_points_dist(height)
+
+          polygon = Geometry::Polygon.new([p1, p2, p4, p3])
+          @reagents_polygons.push(polygon)
+        end
+      end
+
+      def build_polygons_on_polygons(polygons)
+        list_height = []
+        @reagents_polygons = []
+
+        segments.each do |segment|
+          p1 = segment.point1
+          p2 = segment.point2
+          hperpen = segment.to_line.perpen_line_via_point(p1)
+          tperpen = segment.to_line.perpen_line_via_point(p2)
+
+          list_points = []
+
+          polygons.each do |poly|
+            next unless segment.polygon_in_range(poly)
+
+            poly_points = poly.vertices.each_with_object([]) do |v, arr|
+              arr.push(hperpen.point_projection(v))
+              arr.push(tperpen.point_projection(v))
+            end
+            list_points.concat(poly_points).concat([p1, p2])
+          end
+
+          if list_points.empty?
+            build_polygons(0.2)
+            next
+          end
+
+          xmax = list_points.map(&:x).max + 0.5
+          xmin = list_points.map(&:x).min - 0.5
+          ymin = list_points.map(&:y).min - 0.5
+          ymax = list_points.map(&:y).max + 0.5
+
+          poly_points = [
+            Geometry::Point.new(xmin, ymin),
+            Geometry::Point.new(xmin, ymax),
+            Geometry::Point.new(xmax, ymax),
+            Geometry::Point.new(xmax, ymin),
+          ]
+          list_height.push((ymax - ymin).abs)
+
+          @reagents_polygons.push(Geometry::Polygon.new(poly_points))
+        end
+
+        @height = list_height.max || 0.1
+      end
+
+      def product_side?(point)
+        line = head_perpen_segment.to_line
+        side = line.point_side(@head) * line.point_side(point)
+
+        side.positive?
+      end
+
+      def reactant_side?(point)
+        line = tail_perpen_segment.to_line
+        side = line.point_side(@tail) * line.point_side(point)
+
+        side.positive?
+      end
+
+      def contains_point?(point)
+        segments.each do |segment|
+          ppoint = segment.to_line.point_projection(point)
+          return ppoint if segment.contains_point?(ppoint)
+        end
+
+        nil
+      end
+
+      def min_distance_to_polygon(polygon)
+        dist_arr = []
+        bbox = polygon.bounding_box
+
+        segments.each do |segment|
+          dist = segment.distance_to_boundingbox(bbox)
+          dist_arr.push(dist)
+        end
+
+        dist_arr.min
+      end
+
+      def dist_to_head(point)
+        Geometry::Segment.new(point, @head).length
+      end
+
+      def dist_to_tail(point)
+        Geometry::Segment.new(point, @tail).length
+      end
+
+      def polygon_around?(poly)
+        @reagents_polygons.each do |rpoly|
+          return true if poly.around_polygon?(rpoly)
+        end
+
+        false
+      end
+
+      def all_intersects_with_segment?(segment)
+        @reagents_polygons.each do |rpoly|
+          return false unless segment.intersects_with_polygon?(rpoly)
+        end
+
+        true
+      end
+
+      def parallel_to?(other)
+        segments.each do |seg|
+          other.segments.each do |oseg|
+            return false unless seg.parallel_to?(oseg)
+          end
+        end
+
+        true
+      end
+
+      def poly_in_middle?(poly)
+        poly_points = poly.bounding_box.points.push(poly.center)
+
+        in_middle = false
+        poly_points.each do |point|
+          in_middle |= point_in_middle(point)
+        end
+
+        in_middle
+      end
+
+      def point_in_middle(target_point)
+        in_middle = false
+
+        points.each_with_index do |point, idx|
+          next if idx.zero?
+
+          segment = Geometry::Segment.new(point, points[idx - 1])
+          ppoint = segment.to_line.point_projection(target_point)
+
+          from_head = if idx == 1 then true
+                      elsif idx == (points.size - 1) then false
+                      end
+          in_middle |= segment.point_in_range(ppoint, 4.0 / 5.0, from_head)
+        end
+
+        in_middle
+      end
+
+      def clone
+        cloned = self.class.new(@geometry)
+        cloned.id = get_tempid
+
+        cloned.tail = @tail.clone
+        cloned.head = @head.clone
+        cloned.middle_points = Marshal.load(Marshal.dump(@middle_points))
+
+        cloned.descriptions = @descriptions
+        cloned.cross = @cross
+        cloned.cross_lines = Marshal.load(Marshal.dump(@cross_lines))
+        cloned.reagents_polygons = @reagents_polygons.clone
+        cloned.height = @height
+        cloned.line_type = @line_type
+
+        cloned
+      end
+
+      def get_tempid
+        @geometry.get_tempid
+      end
+
+      def inspect
+        (
+          "#<Arrow: id=#{id}, " +
+            "reagents_polygon: #{reagents_polygons}," +
+            "tail: #{tail}, " +
+            "head: #{head}, " +
+            "middle_points: #{middle_points}, " +
+            "cross: #{cross}, " +
+            "height: #{height}, " +
+            "line_type: #{line_type}, " +
+            "cross_lines: #{cross_lines}, " +
+            "text_arr: #{text_arr} >"
+        )
+      end
+    end
+  end
+end

data/lib/chem_scanner/interpreter/element/atom.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    # Atom class
+    class Atom
+      attr_accessor :is_alias, :alias_text, :charge
+      attr_reader :type, :ext_type, :warning, :warning_data, :point, :is_polymer
+
+      def initialize(node, rw_mol)
+        @rw_mol = rw_mol
+
+        @node = node
+
+        @type = node.type
+        @ext_type = node.ext_type
+        @atnum = node.atnum
+        @num_hydrogens = node.num_hydrogens
+        @charge = node.charge
+        @iso = node.iso
+        @x = node.x || 0
+        @y = node.y || 0
+        @point = node.point
+
+        @is_alias = node.is_alias
+        @alias_text = node.alias_text.strip
+        @warning = node.warning
+        @warning_data = node.warning_data
+
+        @is_polymer = node.is_polymer
+      end
+
+      def process
+        # Set default to Carbon
+        @atnum.negative? && @atnum = 6
+        @rw_mol.add_atom(RDKitChem::Atom.new(@atnum), false)
+        rd_atom = @rw_mol.get_last_atom
+        @rw_mol.set_atom_bookmark(rd_atom, @node.id)
+
+        @num_hydrogens >= 0 && rd_atom.set_num_explicit_hs(@num_hydrogens)
+        rd_atom.set_formal_charge(@charge)
+        rd_atom.set_isotope(@iso)
+        conf = @rw_mol.get_conformer(0)
+        conf.set_atom_pos(rd_atom.get_idx, RDKitChem::Point3D.new(@x, @y, 0))
+
+        process_alias
+      end
+
+      def get_rd_atom
+        @rw_mol.get_atom_with_bookmark(@node.id)
+      end
+
+      def get_idx
+        get_rd_atom.get_idx
+      end
+
+      def id
+        @node.id
+      end
+
+      def inspect
+        (
+          "#<Atom: id=#{@node.id}, " +
+            "type: #{@type}, " +
+            "external_type: #{@ext_type}, " +
+            "atnum: #{@atnum}, " +
+            "num_hydrogens: #{@num_hydrogens}, " +
+            "charge: #{charge}, " +
+            "iso: #{@iso}, " +
+            "x: #{@x}, " +
+            "y: #{@y}, " +
+            "is_alias: #{is_alias}, " +
+            "is_polymer: #{is_polymer}, " +
+            "alias_text: #{alias_text}, " +
+            "warning_data: #{@warning_data}, " +
+            "warning: #{@warning} >"
+        )
+      end
+
+      def clone
+        cnode = @node.clone
+        clone = self.class.new(cnode, @rw_mol)
+        clone.process
+
+        clone
+      end
+
+      def set_2d(coord_x, coord_y)
+        @x = coord_x
+        @y = coord_y
+
+        conf = @rw_mol.get_conformer(0)
+        conf.set_atom_pos(get_idx, RDKitChem::Point3D.new(@x, @y, 0))
+      end
+
+      def set_formal_charge(charge)
+        @charge = charge
+        rd_atom = get_rd_atom
+        rd_atom.set_formal_charge(charge)
+      end
+
+      def set_polymer
+        @is_alias = true
+        @is_polymer = true
+      end
+
+      private
+
+      def process_alias
+        alias_groups = ChemScanner::Interpreter::ALIAS_GROUP
+        is_alias_group = alias_groups.include?(@alias_text)
+        if is_alias_group
+          @type = 5
+          @is_alias = true
+          @warning = false
+          @warning_data = ""
+        end
+
+        sbase = ChemScanner::Interpreter
+        @is_alias ||= begin
+          !@alias_text.empty? && sbase.rgroup_atom?(@alias_text) && @type >= 0
+        end
+
+        # Polymer handling
+        set_polymer if @ext_type === 3
+
+        return unless @is_alias
+
+        rd_atom = get_rd_atom
+        rd_atom.set_atomic_num(0)
+      end
+    end
+  end
+end

data/lib/chem_scanner/interpreter/element/fragment.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    # Molecule class
+    class Fragment
+      extend Forwardable
+
+      def_delegators :@fragment, :id, :parser, :parser_type,
+                     :polygon, :polygon=, :boxed, :boxed=,
+                     :node_map, :node_map=, :bond_map, :bond_map=, :graphic_map
+
+      def initialize(chemdraw_fragment)
+        @fragment = chemdraw_fragment
+      end
+
+      def add(other)
+        @fragment.boxed |= other.boxed
+
+        @fragment.node_map.merge!(other.node_map)
+        @fragment.bond_map.merge!(other.bond_map)
+
+        @fragment.rebuild_polygon
+      end
+
+      def clone
+        cfrag = @fragment.clone
+        cfrag.set_new_id
+        cloned = self.class.new(cfrag)
+        cloned.boxed = @fragment.boxed
+        cloned.node_map = @fragment.node_map
+        cloned.bond_map = @fragment.bond_map
+
+        cloned
+      end
+
+      def set_id(new_id)
+        @fragment.id = new_id
+      end
+
+      def line?
+        node_map = @fragment.node_map
+        return false if node_map.count < 3
+
+        points = []
+        node_map.values.each_with_index do |node, i|
+          points << node.point
+          next if i < 2
+
+          seg1 = Geometry::Segment.new(points[i - 3], points[i - 2])
+          seg2 = Geometry::Segment.new(points[i - 2], points[i - 1])
+          return false unless seg1.lies_on_one_line_with?(seg2)
+        end
+
+        true
+      end
+    end
+  end
+end