chem_scanner 0.1.3

data/lib/chem_scanner/interpreter/post_process/reaction_step.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    using Extension
+
+    module ReactionDetection
+      def process_reactions_step
+        @reactions.each { |r| detect_reaction_step(r) }
+      end
+
+      def detect_reaction_step(reaction)
+        number_ref = [
+          ["1", "2", "3", "4", "5", "6", "7", "8", "9"],
+          ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"],
+          ["i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix"],
+          ["A", "B", "C", "D", "E", "F", "G", "H", "J"],
+        ]
+
+        regex_list = [
+          /(^|\A)(([1-9a-z]{0,3}) *[)\.] *(.*))($|\z)/i,
+          /(^|\A)\((([1-9a-z]{0,3}) *\) *(.*))($|\z)/i,
+        ]
+        check = false
+
+        list_matched = []
+        list_numbered = []
+        regex_list.each do |regex|
+          next if check
+
+          list_matched = reaction.description.enum_for(:scan, regex).map {
+            Regexp.last_match
+          }
+          list_numbered = list_matched.map { |x| x[3] }
+          next if list_numbered.empty?
+
+          number_ref.each do |ref|
+            check = true if ref & list_numbered == list_numbered
+          end
+        end
+
+        return unless check && list_numbered.count >= 2
+
+        flatten_ref = number_ref.flatten
+        check_temperature = false
+        check_time = false
+        list_position = list_matched.map { |x| x.begin(0) }
+
+        list_matched.each_with_index.map do |matched, idx|
+          next_pos = list_position[idx + 1] || -1
+          next_pos = next_pos.negative? ? next_pos : (next_pos - 1)
+          description = reaction.description[list_position[idx]..next_pos]
+          text_start_pos = if matched[4].empty?
+                             m2 = matched[2]
+                             description.index(m2) + m2.size
+                           else
+                             description.index(matched[4]) || 0
+                           end
+          description = description[text_start_pos..-1]
+          temperature, _, time = extract_reaction_info([description])
+
+          step = ReactionStep.new
+          step.temperature = temperature
+          step.time = time
+          step.description = description
+          step.number = (flatten_ref.index(matched[3]) % 9) + 1
+
+          check_time = !time.empty?
+          check_temperature = !temperature.empty?
+
+          reaction.reagent_abbs.each do |abb|
+            next unless description.include?(abb)
+
+            step.reagents.push(ChemScanner.get_abbreviation(abb))
+          end
+
+          reaction.steps.push(step)
+        end
+
+        reaction.time = "" if check_time
+        reaction.temperature = "" if check_temperature
+
+        # NOTE: tempo tricky assign reagents to empty step
+        return if reaction.reagents.count != 1
+
+        empty_steps = reaction.steps.select do |s|
+          s.description.empty? || s.description == "\n"
+        end
+        return if empty_steps.count != 1
+
+        empty_steps.first.reagents.push(reaction.reagents.first.cano_smiles)
+      end
+    end
+  end
+end

data/lib/chem_scanner/interpreter/post_process/reagent_label.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    using Extension
+
+    module PostProcess
+      def refine_reagents_label
+        @reactions.each do |r|
+          added_arr = []
+
+          @arrow_map[r.arrow_id].text_arr.each do |tid|
+            text = @text_map[tid]
+            bold = text.bold_text
+            next if bold.strip.empty?
+
+            mol_id = r.reagent_ids.detect { |id| @mol_map[id].label == bold }
+            next unless mol_id.nil?
+
+            min_dist = { key: 0, value: 9_999_999 }
+            r.reagent_ids.each do |rid|
+              reagent = @mol_map[rid]
+              dist = reagent.min_distance_to_point(text.polygon.center)
+              min_dist = { key: rid, value: dist } if dist < min_dist[:value]
+            end
+
+            if min_dist[:key].positive?
+              added_arr.push(text: tid, reagent: min_dist[:key])
+            end
+          end
+
+          added_arr.each do |added|
+            text = @text_map[added[:text]]
+            r.text_ids.delete(text.id)
+            @arrow_map[r.arrow_id].text_arr.delete(text.id)
+            reagent = @mol_map[added[:reagent]]
+            reagent.text_ids.push(text.id)
+            assemble_molecule_text(reagent)
+            # reagent.label = text.bold_text.strip
+            # text.remove_bold
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chem_scanner/interpreter/post_process/text_as_molecule.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module ChemScanner
+  # Interpreter of extracted/scanned information
+  module Interpreter
+    using Extension
+
+    module PostProcess
+      def refine_text_as_molecule
+        key_to_delete = []
+
+        @text_map.each do |k, text|
+          mol = @mol_map.values.detect { |m| m.text_ids.include?(k) }
+          next if mol.nil?
+
+          smi = ChemScanner.get_abbreviation(text.value)
+          next if smi.empty?
+
+          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
+
+          pos = group_pos.detect { |_, p| p == "reagents" }
+          next unless pos.nil?
+
+          pos = group_pos.detect { |_, p| %w[reactants products].include?(p) }
+          next if pos.nil?
+
+          puts "group: #{group_pos}"
+          key_to_delete.push(k)
+          mol.text_ids.delete(k)
+          @mol_map[k] = Molecule.new_from_smiles(k, smi)
+
+          pos = group_pos.first
+          reaction = @reactions.detect { |r| r.arrow_id == pos[0] }
+          group_ids = reaction.send("#{pos[1][0...-1]}_ids")
+          group_ids.push(k)
+        end
+
+        # Don't need to keep it text_map anymore
+        key_to_delete.each { |k| @text_map.delete(k) }
+      end
+    end
+  end
+end

data/lib/chem_scanner/interpreter/post_process/text_label.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module ChemScanner
+  # Interpreter of extracted/scanned information
+  module Interpreter
+    using Extension
+
+    module PostProcess
+      # text_id could be both on text_map and mol_group_map
+      # Text-as-label, e.g. "ligand = ", "amide = "
+      def refine_text_label
+        @mol_map.select { |_, m| m.text.strip[-1] == "=" }.each do |mid, mol|
+          label_text = mol.text.strip.chomp("=").strip
+          existed = false
+
+          @reactions.each do |r|
+            @arrow_map[r.arrow_id].text_arr.each do |tid|
+              text = @text_map[tid]
+              next unless text.value.include?(label_text)
+
+              existed = true
+            end
+
+            r.reagent_ids.push(mid) unless r.reagent_ids.include?(mid)
+          end
+
+          next unless existed
+
+          @reactions.each do |r|
+            %w[reactant product].each do |group|
+              group_ids = r.send("#{group}_ids")
+              group_ids.delete(mid) if group_ids.include?(mid)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    using Extension
+
+    ESTIMATED_DIST = 0.2
+
+    module PreProcess
+      # - Detect cross arrow from line map
+      # - Attach "extend" line to arrow
+      def refine_arrow
+        detect_line_fragment
+
+        # Headless arrow ~ line, part of the real arrow
+        segment_keys = @geometry_map.select { |_, g| g.headless }.keys
+        segment_keys.each do |k|
+          segment = @geometry_map.delete(k)
+          tail = Geometry::Point.new(segment.tail[:x], segment.tail[:y])
+          head = Geometry::Point.new(segment.head[:x], segment.head[:y])
+
+          @segment_map[k] = Geometry::Segment.new(tail, head)
+        end
+
+        segment_keys = @graphic_map.select { |_, g| g.line? }.keys
+        segment_keys.each do |k|
+          segment = @graphic_map.delete(k)
+          tail = Geometry::Point.new(segment.tail[:x], segment.tail[:y])
+          head = Geometry::Point.new(segment.head[:x], segment.head[:y])
+
+          @segment_map[k] = Geometry::Segment.new(tail, head)
+        end
+
+        #      |
+        # ---->|
+        #      |
+        #      V
+        arrow_graphic = @graphic_map.reject { |_, g| g.head.nil? || g.tail.nil? }
+        all_arrow = @geometry_map.merge(arrow_graphic)
+        all_arrow.each do |key, geometry|
+          arrow = Arrow.new(geometry)
+          @arrow_map[key] = arrow
+          aseg = geometry.segment
+          line = aseg.to_line
+
+          all_arrow.except(key).each do |_, other|
+            oseg = other.segment
+            next unless line.intersects_with_segment?(oseg)
+
+            point = line.intersection_points_with(oseg.to_line)
+            next unless oseg.contains_point?(point)
+
+            #     |
+            #     |
+            # ----|->
+            #     |
+            #     |
+            #     v
+            # NOTE: due to manually drawing,
+            # the intersection point may not exactly the head of the arrow
+            next if Geometry.distance(arrow.head, point) > ESTIMATED_DIST
+
+            # If it intersect with any other geometry
+            arrow.change_head(other.head)
+          end
+        end
+
+        #  \
+        # --\-->
+        #    \
+        # Same effect as "nogo" attritbue
+        try_check_cross
+
+        # -----|
+        #      |
+        #      V
+        try_extend_tail
+
+        #      |------>
+        #      |
+        # -----|
+        #      |
+        #      |------>
+        try_extend_split
+      end
+
+      # - Check text within mol
+      # - Detect if there are any "arrow" molecule, ( straight C bonds: ----- )
+      #   which people drawing to be viewed as an arrow
+      def detect_line_fragment
+        remove_keys = []
+
+        @fragment_map.each do |key, fragment|
+          # Check if user draw a molecule as an "extended" arrow
+          next unless fragment.line?
+
+          remove_keys.push(key)
+          @fragment_as_line += 1
+
+          nodes = fragment.node_map.values
+          is_vertical = nodes.map(&:y).uniq.count == 1
+          sorted_atoms = nodes.sort_by { |atom| is_vertical ? atom.y : atom.x }
+          segment = Geometry::Segment.new(sorted_atoms.first, sorted_atoms.last)
+
+          @segment_map[key] = segment
+        end
+
+        remove_keys.each { |k| @fragment_map.delete(k) }
+      end
+
+      # Try to extend base arrow if possible
+      def try_extend_tail
+        arrow_new_tail = {}
+        @segment_map.each do |key, seg|
+          @arrow_map.each_value do |arrow|
+            dist1 = Geometry.distance(seg.point1, arrow.tail)
+            dist2 = Geometry.distance(seg.point2, arrow.tail)
+            if dist1 <= dist2
+              dist = dist1
+              point = seg.point2
+            else
+              dist = dist2
+              point = seg.point1
+            end
+
+            next if dist > ESTIMATED_DIST
+
+            arrow_new_tail[arrow.id] = { skey: key, point: point }
+          end
+        end
+
+        arrow_new_tail.each do |aid, tail_info|
+          @segment_map.delete(tail_info[:skey])
+          arrow = @arrow_map[aid]
+          arrow.change_tail(tail_info[:point])
+        end
+      end
+
+      def try_extend_split
+        arrow_new_split = {}
+
+        @segment_map.each do |key, segment|
+          line = segment.to_line
+
+          @arrow_map.each_value do |arrow|
+            asegment = arrow.tail_segment
+            next unless line.intersects_with_segment?(asegment)
+
+            point = line.intersection_points_with(asegment.to_line)
+            dist1 = Geometry.distance(segment.point1, point)
+            dist2 = Geometry.distance(segment.point2, point)
+            next if [dist1, dist2].min > ESTIMATED_DIST
+
+            tail_point = dist1 < dist2 ? segment.point2 : segment.point1
+            arrow_new_split[arrow.id] = {
+              key: key,
+              point: point,
+              tpoint: tail_point,
+            }
+          end
+        end
+
+        arrow_new_split.each do |aid, split_info|
+          arrow = @arrow_map[aid]
+          arrow.update_tail(split_info[:point])
+          arrow.change_tail(split_info[:tpoint])
+
+          @segment_map.delete(split_info[:skey])
+        end
+      end
+
+      def try_check_cross
+        @arrow_map.each_value do |arrow|
+          next if arrow.cross
+
+          keys = []
+          @segment_map.each do |key, seg|
+            arrow.segments.each do |aseg|
+              next unless seg.intersects_with?(aseg)
+
+              pintersect = seg.intersection_point_with(aseg)
+              check = aseg.contains_point?(pintersect) \
+                      && seg.point_in_range(pintersect, 3.0 / 5.0)
+              next unless check
+
+              # Add to the "polyline" of arrow
+              arrow.add_cross_segment(seg)
+              keys.push(key)
+            end
+          end
+
+          keys.each { |key| @segment_map.delete(key) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module Interpreter
+    using Extension
+
+    module PreProcess
+      def find_fragment_inside_rectangle
+        # 3 = Rectangle
+        @graphic_map.select do |_, v|
+          v.type == 3 && v.bounding_box.area < 100
+        end.each do |_, graphic|
+          @fragment_map.each_value do |fragment|
+            next unless graphic.polygon.contains_polygon?(fragment.polygon)
+
+            fragment.boxed = true
+          end
+
+          @fragment_group_map.each do |_, fgroup|
+            fmap = fgroup[:fragment_map]
+            next unless fmap.values.count == 1
+
+            text = fgroup[:title]
+            next unless graphic.polygon.contains_polygon?(text.polygon)
+
+            fragment = fmap.values.first
+            fragment.boxed = true
+          end
+        end
+      end
+
+      def extract_fragment_graphic
+        @fragment_map.each_value do |fragment|
+          next if fragment.graphic_map.empty?
+
+          @graphic_map.merge!(fragment.graphic_map)
+        end
+      end
+    end
+  end
+end