chem_scanner 0.1.3

data/lib/chem_scanner/interpreter/pre_process/molecule.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    using Extension
+
+    module PreProcess
+      def refine_molecules
+        process_orbital_as_polymer
+        fragment_to_molecules
+        populate_molecule_info
+
+        assemble_ionic_molecule
+      end
+
+      def process_orbital_as_polymer
+        @graphic_map.each_value do |graphic|
+          next unless graphic.orbital_type == 256 && graphic.oval_type == 3
+
+          gpoly = graphic.polygon
+          next if gpoly.nil?
+
+          @fragment_map.each_value do |fragment|
+            fragment.node_map.each_value do |node|
+              next unless gpoly.contains?(node.point)
+
+              node.set_is_polymer
+              fragment.polygon = fragment.polygon.merge_polygon(gpoly)
+            end
+          end
+        end
+      end
+
+      def fragment_to_molecules
+        @fragment_map.each do |k, fragment|
+          next if fragment.node_map.count.zero?
+
+          mol = Molecule.new(fragment)
+          mol.process
+          @mol_map[k] = mol
+        end
+
+        @fragment_group_map.each do |k, fgroup|
+          mgroup = MoleculeGroup.new
+          mgroup.title = fgroup[:title]
+
+          fgroup[:fragment_map].each do |_, fragment|
+            # NOTE: nested fragment should not contain any special type.
+            # For instance, there are some cases that
+            # DMF is implicitly converted to C-C-C with nickname D-M-F
+            node_type = fragment.node_map.detect { |_, n| n.type.positive? }
+            mgroup.add_fragment(fragment) if node_type.nil?
+          end
+
+          @mol_group_map[k] = mgroup
+        end
+      end
+
+      def populate_molecule_info
+        list_mol = @mol_map.values
+        list_mol_group = @mol_group_map.values.reduce([]) do |acc, mgroup|
+          acc.concat(mgroup.molecules)
+        end
+
+        (list_mol + list_mol_group).each(&:update_output_formats)
+      end
+
+      def assemble_ionic_molecule
+        charged_mol = @mol_map.each_with_object([]) do |(k, mol), arr|
+          charged_ids = mol.charged_atom_ids
+          next arr unless charged_ids.size == 1
+
+          aid = charged_ids.first
+          charge = mol.atom_map[aid].charge
+          arr.push(mol: mol, aid: aid, charge: charge, mid: k)
+        end
+
+        charged_group = @mol_group_map.each_with_object([]) do |(k, group), arr|
+          next arr unless group.molecules.count == 1
+
+          mol = group.molecules.first
+          charged_ids = mol.charged_atom_ids
+          next arr unless charged_ids.count == 1
+
+          aid = charged_ids.first
+          charge = mol.atom_map[aid].charge
+          arr.push(mol: mol, aid: aid, charge: charge, mid: k)
+        end
+
+        list_mol = charged_mol.concat(charged_group)
+        grouped = {}
+        list_mol.each do |charged_info|
+          mol = charged_info[:mol]
+          charge = charged_info[:charge]
+          center = mol.polygon.bounding_box.center
+
+          others = list_mol.select { |ocharged| ocharged[:charge] == -charge }
+          opposite_mol = others.each_with_object(dist: 99999) do |minfo, obj|
+            ocenter = minfo[:mol].polygon.bounding_box.center
+            dist = Geometry.distance(center, ocenter)
+
+            if dist < obj[:dist]
+              obj[:dist] = dist
+              obj.merge!(mol: minfo[:mol], mid: minfo[:mid])
+            end
+          end
+          # Estimated value, could change later
+          next if opposite_mol[:mol].nil? || opposite_mol[:dist] > 4
+
+          mid = charged_info[:mid]
+          next if grouped.key?(mid) || grouped.value?(mid)
+
+          grouped[mid] = opposite_mol[:mid]
+        end
+
+        # { a1 => b, a2 => b, a3 => c } then remove both a1 and a2
+        values = []
+        dup_hash = {}
+        grouped.each do |key, okey|
+          values.push(okey) unless values.include?(okey)
+          dup_hash[okey] = (dup_hash[okey] || []).push(key)
+        end
+        dup_keys = dup_hash.values.select { |x| x.size > 1 }.flatten
+        grouped.delete_if { |k, _| dup_keys.include?(k) }
+
+        grouped.each do |key, okey|
+          get_mol = lambda do |id|
+            if @mol_map.key?(id)
+              @mol_map[id]
+            else
+              @mol_group_map[id].molecules.first
+            end
+          end
+
+          mol = get_mol.call(key)
+          omol = get_mol.call(okey)
+
+          mol.add(omol)
+          mol.update_output_formats
+          @mol_map.delete(okey)
+          mgid = @mol_group_map.delete(okey)
+          next if mgid.nil?
+
+          tid = mgid.title.id
+          @text_map.delete(tid)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    using Extension
+
+    require "chem_scanner/interpreter/scheme_base"
+
+    module ReactionDetection
+      include ChemScanner::Interpreter::SchemeBase
+
+      def assign_to_reaction
+        undetected_molecules = {}
+
+        @arrow_map.each do |key, arrow|
+          reaction = Reaction.new
+          reaction.arrow_id = key
+          undetected = []
+
+          @mol_map.reject { |_, mol| mol.boxed }.each do |kmol, mol|
+            mpoly = mol.polygon
+
+            @arrow_map.each_value do |a|
+              dist = a.min_distance_to_polygon(mpoly)
+              a.build_polygons(mpoly.height + dist)
+            end
+
+            group = detect_position(arrow, mpoly)
+
+            case group
+            when "reagents" then reaction.reagent_ids.push(kmol)
+            when "reactants" then reaction.reactant_ids.push(kmol)
+            when "products" then reaction.product_ids.push(kmol)
+            else undetected.push(kmol)
+            end
+          end
+
+          @reactions.push(reaction)
+          undetected_molecules[key] = undetected unless undetected.empty?
+        end
+
+        # Molecules which are both reagents and reactants/products
+        # If reagent -> arrow distance in range, then consider as reagent
+        # Otherwise, consider as reactant/product
+        @reactions.each do |r|
+          reagent_ids = r.reagent_ids
+          arrow = @arrow_map[r.arrow_id]
+
+          others = @reactions.reject { |oreact| oreact.arrow_id == r.arrow_id }
+          others.each do |o|
+            common = reagent_ids & o.reactant_ids
+            common += reagent_ids & o.product_ids
+            common.each do |cid|
+              mol = @mol_map[cid]
+              dist = arrow.min_distance_to_polygon(mol.polygon)
+              target = dist > 2 ? r : o
+              target.delete_id(cid)
+            end
+          end
+        end
+
+        auto_fit_arrow_polygons
+
+        undetected_molecules.each do |rkey, ids|
+          reaction = @reactions.detect { |r| r.arrow_id == rkey }
+          arrow = @arrow_map[rkey]
+
+          ids.each do |id|
+            mol = @mol_map[id]
+            mpoly = mol.polygon
+            group = detect_position(arrow, mpoly)
+
+            case group
+            when "reagents" then reaction.reagent_ids.push(id)
+            when "reactants" then reaction.reactant_ids.push(id)
+            when "products" then reaction.product_ids.push(id)
+            end
+          end
+        end
+      end
+
+      def detect_position(arrow, mol_poly)
+        mcenter = mol_poly.center
+
+        check_pos = check_position(mol_poly, arrow)
+        return "products" if check_pos && arrow.product_side?(mcenter)
+
+        check_pos = check_position(mol_poly, arrow, false)
+        return "reactants" if check_pos && arrow.reactant_side?(mcenter)
+
+        return "reagents" if arrow.polygon_around?(mol_poly)
+
+        nil
+      end
+
+      # Check if molecule belong to reaction
+      def check_position(mol_poly, arrow, prod_side = true)
+        arrow_segment = ->(larrow) do
+          prod_side ? larrow.head_segment : larrow.tail_segment
+        end
+
+        segment = arrow_segment.call(arrow)
+        sline = segment.to_line
+        inter = sline.intersects_with_polygon?(mol_poly)
+        return false unless inter
+
+        inter_point = sline.intersection_points_with_polygon(mol_poly).first
+        inter_seg = Geometry::Segment.new(segment.point2, inter_point)
+
+        @arrow_map.except(arrow.id).each_value do |oarrow|
+          other_hseg = oarrow.head_segment
+          check_contains = (
+            other_hseg.contains_segment?(segment) ||
+            segment.contains_segment?(other_hseg)
+          )
+          next if check_contains
+
+          osegment = arrow_segment.call(oarrow)
+          check = osegment.to_line.intersects_with_polygon?(mol_poly) && \
+            oarrow.all_intersects_with_segment?(inter_seg)
+
+          return false if check
+        end
+
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  # Interpret the parsed/extracted geometry block
+  module Interpreter
+    using Extension
+
+    module ReactionDetection
+      def refine_duplicate_reagents
+        delete_info = []
+
+        @reactions.each do |r|
+          arrow = @arrow_map[r.arrow_id]
+          rremain = @reactions.reject { |other| other.arrow_id == r.arrow_id }
+
+          rremain.each do |other|
+            other_rps = other.reactant_ids + other.product_ids
+            r.reagent_ids -= other_rps
+
+            dup_ids = r.reagent_ids & other.reagent_ids
+            next if dup_ids.empty?
+
+            dup_ids.each do |id|
+              obj = @mol_map.key?(id) ? @mol_map[id] : @text_map[id]
+
+              polygon = obj.polygon
+              pcenter = polygon.center
+              apoint = arrow.contains_point?(pcenter)
+              opoint = @arrow_map[other.arrow_id].contains_point?(pcenter)
+              next if apoint.nil? || opoint.nil?
+
+              rdist = pcenter.distance_to(apoint)
+              odist = pcenter.distance_to(opoint)
+
+              if rdist > odist
+                info = OpenStruct.new(rid: r.arrow_id, id: id)
+                delete_info.push(info)
+              end
+            end
+          end
+        end
+
+        delete_info.each do |info|
+          reaction = @reactions.detect { |r| r.arrow_id == info.rid }
+          reaction.delete_id(info.id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    using Extension
+
+    module ReactionDetection
+      require "chem_scanner/interpreter/reaction_detection/text_assignment"
+
+      def assign_molecule_group
+        all_reagent_ids = @reactions.reduce([]) do |acc, r|
+          acc.concat(@arrow_map[r.arrow_id].text_arr)
+        end
+
+        auto_fit_arrow_polygons
+
+        @mol_group_map.select do |tid, mgroup|
+          (
+            !all_reagent_ids.include?(tid) &&
+            mgroup.molecules.count == 1 &&
+            !mgroup.molecules.first.boxed
+          )
+        end.each do |mkey, mgroup|
+          mol = mgroup.molecules.first
+          mmid = mol.fragment.id
+
+          mgroup_pos = {}
+          @reactions.each do |reaction|
+            rid = reaction.arrow_id
+            arrow = @arrow_map[rid]
+            group = detect_position(arrow, mgroup.title.polygon)
+            next if group.nil?
+
+            mgroup_pos[rid] = group
+          end
+
+          pos = mgroup_pos.detect { |_, p| p == "reagents" }
+          next unless pos.nil?
+
+          pos = mgroup_pos.detect { |_, p| %w[reactants products].include?(p) }
+          next if pos.nil?
+
+          # Don't need to keep it text_map anymore
+          mol.text = @text_map.delete(mkey).value unless mgroup_pos.empty?
+          mol.text_ids.delete(mkey)
+          @mol_map.each_value { |m| m.text_ids.delete(mkey) }
+
+          reaction = @reactions.detect { |r| r.arrow_id == pos[0] }
+          group_ids = reaction.send("#{pos[1][0...-1]}_ids")
+          group_ids.push(mmid)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    using Extension
+
+    module ReactionDetection
+      def multi_line_chain_reaction
+        return if check_reaction_orderring
+
+        rarray = @reactions.select do |r|
+          r.reactant_ids.count.zero? || r.product_ids.count.zero?
+        end
+
+        rcount = rarray.count
+        return if rcount.zero?
+
+        auto_fit_arrow_polygons
+
+        sorted_akey = sort_arrow_map
+
+        get_reaction = ->(id) { @reactions.detect { |r| r.arrow_id == id } }
+
+        rarray.each do |reaction|
+          rkey = sorted_akey.find_index do |key_arr|
+            key_arr.include?(reaction.arrow_id)
+          end
+          next if rkey.nil?
+
+          if reaction.reactant_ids.count.zero?
+            other_ids = sorted_akey[rkey - 1]
+            next if other_ids.nil?
+
+            other_id = other_ids.last
+            other = get_reaction.call(other_id)
+            reaction.reactant_ids.concat(other.product_ids)
+          else
+            other_ids = sorted_akey[rkey + 1]
+            next if other_ids.nil?
+
+            other_id = other_ids.first
+            other = get_reaction.call(other_id)
+            reaction.product_ids.concat(other.reactant_ids)
+          end
+        end
+      end
+
+      def check_reaction_orderring
+        return true if @arrow_map.count < 2
+
+        @arrow_map.each_value do |arrow|
+          return true if arrow.middle_points.count > 0
+          return true unless arrow.head_segment.to_line.horizontal?
+        end
+
+        false
+      end
+
+      def sort_arrow_map
+        sorted_arr = []
+        arrow_keys = @arrow_map.keys
+
+        while !arrow_keys.empty?
+          arrow = @arrow_map[arrow_keys.first]
+          aheight = arrow.height
+          min_height = arrow.head.y - aheight
+          max_height = arrow.head.y + aheight
+
+          akeys = arrow_keys.select do |ak|
+            y_head = @arrow_map[ak].head.y
+            y_head >= min_height && y_head <= max_height
+          end
+
+          sorted_arr.push(akeys)
+          arrow_keys = arrow_keys - akeys
+        end
+
+        sorted_arr.map! { |arr| arr.sort_by! { |id| @arrow_map[id].head.x } }
+        sorted_arr.sort_by! { |arr| - @arrow_map[arr.first].head.y }
+
+        sorted_arr
+      end
+    end
+  end
+end