chem_scanner 0.1.3

data/lib/chem_scanner/interpreter/reaction_detection/remove_separated_mol.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    using Extension
+
+    module ReactionDetection
+      # (1): A ---> C
+      #
+      # (2): B ---> D
+      #             |
+      #             |
+      #             V
+      #             E
+      # Remove C from (2)
+      def remove_separated_mol
+        dist_gap = 2.0
+
+        @reactions.each do |r|
+          arrow = @arrow_map[r.arrow_id]
+
+          %w[reactant_ids product_ids].each do |group|
+            rgroup = r.send(group)
+            next if rgroup.count < 2
+
+            # Distance map of 1 molecule to arrow
+            #   and other molecules within group
+            dist_map = distance_molecule_group(rgroup, arrow, group)
+            min_dist = dist_map.min_by { |_, value| value }.last
+
+            remove_map = dist_map.select do |k, v|
+              dist_check = v > (dist_gap * min_dist)
+              next unless dist_check
+
+              in_other = @reactions.select do |other|
+                check = (
+                  other.arrow_id != r.arrow_id &&
+                  other.molecule_ids.include?(k)
+                )
+                next unless check
+
+                oarrow = @arrow_map[other.arrow_id]
+                !arrow.parallel_to?(oarrow)
+              end
+
+              in_other.count > 0
+            end
+            remove_keys = remove_map.keys
+
+            remove_map.each_key do |k|
+              mol = @mol_map[k]
+              next if mol.nil?
+
+              (rgroup - [k]).each do |id|
+                om = @mol_map[id]
+                next if om.nil?
+
+                d = Geometry.distance(mol.polygon.center, om.polygon.center)
+
+                remove_keys.push(id) if d < (dist_gap * min_dist)
+              end
+            end
+
+            rgroup.delete_if { |x| remove_keys.include?(x) }
+          end
+        end
+      end
+
+      def distance_molecule_group(rgroup, arrow, group)
+        dist_map = {}
+        intersect_points_with_line = ->(id, line) do
+          @mol_map[id].polygon.intersection_points_with_line(line)
+        end
+
+        if group == "reactant_ids"
+          apoint = arrow.tail
+          aline = arrow.tail_segment.to_line
+        else
+          apoint = arrow.head
+          aline = arrow.head_segment.to_line
+        end
+
+        rgroup.each do |id|
+          next unless @mol_map.key?(id)
+
+          # Distance to arrow
+          inter_points = intersect_points_with_line.call(id, aline)
+          da = 9_999_999
+          inter_points.each do |point|
+            length = Geometry.distance(apoint, point)
+            da = length if length < da
+          end
+
+          # Distance to other molecule within group
+          dmols = 9_999_999
+          (rgroup - [id]).each do |mid|
+            other = @mol_map[mid]
+            next if other.nil?
+
+            intersect_points_with_line.call(mid, aline).each do |op|
+              inter_points.each do |p|
+                length = Geometry.distance(p, op)
+                dmols = length if length < dmols
+              end
+            end
+          end
+
+          dist_map[id] = [da, dmols].min
+        end
+
+        dist_map
+      end
+    end
+  end
+end

data/lib/chem_scanner/interpreter/reaction_detection/text_assignment.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    using Extension
+
+    module ReactionDetection
+      # Attach/bind text to molecule or arrow
+      def assign_text
+        tgroup_ids = @mol_group_map.keys
+        text_as_mol_ids = []
+
+        @text_map.each do |k, text|
+          group = try_detect_label_position(text)
+          center = text.polygon.center
+
+          min_mol = nearest_molecule(center)
+          min_arrow = nearest_arrow(text)
+          arrow = @arrow_map[min_arrow.key]
+
+          if arrow.nil?
+            mol_key = min_mol.key
+
+            if group.nil?
+              @mol_map[mol_key].text_ids.push(k)
+            else
+              text_as_mol_ids.push(id: k, mol: mol_key, group: group)
+            end
+
+            next
+          end
+
+          if min_mol.key.zero?
+            arrow.text_arr.push(min_arrow.key)
+            next
+          end
+
+          to_arrow = (
+            min_arrow.value < min_mol.value * 2.5 &&
+            text_around_arrow?(arrow, text, min_arrow.value)
+          )
+
+          if to_arrow
+            arrow.text_arr.push(k)
+            next
+          end
+
+          # Do not add a molecule-group text to molecule as description
+          @mol_map[min_mol.key].text_ids.push(k) unless tgroup_ids.include?(k)
+        end
+
+        text_as_mol_ids.each do |tinfo|
+          tid = tinfo[:id]
+          text = @text_map[tid]
+          mid = tinfo[:mol]
+          mol = @mol_map.values.detect { |m| m.label == text.bold_text }
+
+          if mol.nil?
+            @mol_map[mid].text_ids.push(tid)
+          else
+            rid = tinfo[:group].keys.first
+            group = tinfo[:group][rid]
+            reaction = @reactions.detect { |r| r.arrow_id == rid }
+            rgroup = reaction.send("#{group[0..-2]}_ids")
+            rgroup.push(mol.id).uniq!
+          end
+        end
+
+        @mol_map.each_value { |mol| assemble_molecule_text(mol) }
+      end
+
+      def try_detect_label_position(text)
+        return nil if text.value != text.bold_text
+
+        group_pos = {}
+        @reactions.each do |reaction|
+          rid = reaction.arrow_id
+          arrow = @arrow_map[rid]
+          group = detect_position(arrow, text.polygon)
+          next if group.nil?
+
+          group_pos[rid] = group
+        end
+
+        return nil unless group_pos.size == 1
+
+        pos = group_pos.values.first
+        return nil unless %w[reactants products].include?(pos)
+
+        group_pos
+      end
+
+      def nearest_molecule(point)
+        min_mol = OpenStruct.new(key: 0, value: 9_999_999)
+
+        @mol_map.each do |okey, mol|
+          dist = mol.min_distance_to_point(point)
+
+          if dist < min_mol.value
+            min_mol.key = okey
+            min_mol.value = dist
+          end
+        end
+
+        min_mol
+      end
+
+      def nearest_arrow(text)
+        min_arrow = OpenStruct.new(key: 0, value: 9_999_999)
+        tpoly = text.polygon
+
+        @arrow_map.each do |okey, arrow|
+          arrow.segments.each do |segment|
+            ppoint = segment.to_line.point_projection(tpoly.center)
+            seg_contains = segment.contains_point?(ppoint)
+            next unless seg_contains
+
+            dist = segment.distance_to_boundingbox(tpoly)
+
+            if dist < min_arrow.value
+              min_arrow.key = okey
+              min_arrow.value = dist
+            end
+          end
+        end
+
+        min_arrow
+      end
+
+      def text_around_arrow?(arrow, text, dist)
+        tpoly = text.polygon
+        is_middle = arrow.poly_in_middle?(text.polygon)
+        return false unless is_middle
+
+        pheight = [tpoly.width, tpoly.height].max
+        arrow.build_polygons(pheight + dist)
+        cur_height = arrow.height
+        arrow.build_polygons(cur_height)
+
+        tcenter = tpoly.center
+        reaction = @reactions.detect { |r| r.arrow_id == arrow.id }
+        arrow.segments.each do |aseg|
+          pseg = aseg.perpen_segment_via_point(tcenter)
+          check_contains = (
+            aseg.contains_point?(pseg.point1) ||
+            aseg.contains_point?(pseg.point2)
+          )
+          mol_ids = molecules_intersects_with_segment(pseg)
+          mol_ids = mol_ids - reaction.reagent_ids
+          return true if mol_ids.empty? && check_contains
+        end
+
+        false
+      end
+
+      def molecules_intersects_with_segment(segment)
+        ids = []
+        @mol_map.each do |key, mol|
+          ids.push(key) if segment.intersects_with_polygon?(mol.polygon)
+        end
+
+        ids
+      end
+    end
+  end
+end

data/lib/chem_scanner/interpreter/scheme.rb

@@ -0,0 +1,173 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    Gem.find_files("chem_scanner/interpreter/*/*.rb").each { |f| require f }
+
+    using Extension
+
+    # General scheme, contains all graphics (molecules, text, arrows ...)
+    class Scheme
+      attr_reader :mol_map, :text_map, :bracket_map, :reactions,
+                  :n_atoms, :fragment_as_line
+
+      include PreProcess
+      include ReactionDetection
+      include PostProcess
+
+      def initialize(parser)
+        fragment_map = parser.fragment_map.map { |k, v| [k, Fragment.new(v)] }
+        @fragment_map = fragment_map.to_h
+        @fragment_group_map = parser.fragment_group_map
+
+        @geometry_map = parser.geometry_map
+        @graphic_map = parser.graphic_map
+
+        @text_map = parser.text_map
+        @bracket_map = parser.bracket_map
+
+        @mol_map = ElementMap.new
+        @mol_group_map = ElementMap.new
+
+        @arrow_map = ElementMap.new
+        # Segment or headless arrow
+        @segment_map = ElementMap.new
+
+        @mol_substitutes = {}
+        @reaction_substitutes = {}
+
+        @fragment_as_line = 0
+
+        @reactions = []
+      end
+
+      def interpret
+        pre_process
+        reaction_detection
+        post_process
+
+        tgi = TextGroupInterpreter.new(self)
+        # Detect if molecule has any n-atom, save those infos
+        tgi.retrieve_n_atoms_info
+
+        @n_atoms = tgi.n_atoms
+
+        # Retrieve rgroups, alias-groups of molecules
+        tgi.retrieve_alias_info
+
+        # - Find R-groups ("R1", "R2", "R", ...)
+        # - Find alias-groups ("X", "Y", "Ar", "M")
+        # - Detect label set ("2a,b" "3-6" ...)
+        # tgi.retrieve_labels_and_groups
+
+        # - Combine corresponding addition info detected molecule/reaction text
+        #   e.g., "3: m = 1, R = H"
+        # - Interpret previouse retrieved data
+        # - Save those infos to generate molecules/reactions later
+        # interpret_labels_and_groups
+
+        # Try generate new molecules/reactions
+        #   based on R-groups, alias-groups, n-atoms ...
+        tgi.generate_elements
+
+        @mol_group_map.each do |_, mgroup|
+          mgroup.molecules.each do |m|
+            @mol_map[m.id] = m unless @mol_map.key?(m.id)
+          end
+        end
+      end
+
+      def molecules
+        @mol_map.values
+      end
+
+      private
+
+      def pre_process
+        # Retrieve fragments which are covered by a rectangle
+        find_fragment_inside_rectangle
+
+        # - Attach detected above to arrow
+        # - Try to detect cross arrow ( --//-->  or --X--> )
+        #
+        # -----|
+        #      |
+        #      V
+        # - Extend arrows if possible
+        #
+        #      |------>
+        #      |
+        # -----|
+        #      |
+        #      |------>
+        # - Split extend arrows if possible
+        refine_arrow
+
+        extract_fragment_graphic
+        refine_molecules
+      end
+
+      def reaction_detection
+        # Adding molecules based on molecules and arrow position
+        assign_to_reaction
+
+        # (1): A ---> C
+        #
+        # (2): B ---> D
+        #             |
+        #             |
+        #             V
+        #             E
+        # Remove C from (2)
+        #
+        # Remove if one molecule is seperated against other in the same group
+        # If it is too far, will consider it not a part of the reaction
+        remove_separated_mol
+
+        # Following current algorithm, reagents could belongs to multiple
+        # reactions. Only take the nearest one
+        refine_duplicate_reagents
+
+        # Attach text to molecule or arrow
+        # Process molecule label
+        assign_text
+
+        # Text can also be reactants/products.
+        # Process these ONLY IF text does not belong to any reaction or molecule
+        assign_molecule_group
+
+        # NOTE: Handle some specific scenario from here
+
+        # A -> B ->
+        # C- > D -> E
+        # For this case, we will have an extra implicit reaction: B -> C
+        # For now, only deal with this case if all arrows are horizontal
+        multi_line_chain_reaction
+      end
+
+      def post_process
+        # Check if there is any label inside reagents
+        # which is not assigned to any molecule
+        refine_reagents_label
+
+        # Label usually present a molecule, process those in reagents text
+        replace_label_by_molecule
+
+        # Text-as-label, e.g. "ligand = ", "amide = "
+        refine_text_label
+
+        refine_text_as_molecule
+
+        # From id => molecule
+        assemble_reaction
+
+        # - Extract reaction-related information: temperature, time, yield
+        # - Try interpret abbreviations
+        @reactions.each { |r| process_reaction_info(r) }
+
+        process_reactions_step
+      end
+    end
+  end
+end