chem_scanner 0.1.3

data/lib/chem_scanner/chem_draw/node/bond.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module ChemDraw
+    CDX_BOND_ORDER = {
+      0x0001 => 1,
+      0x0002 => 2,
+      0x0004 => 3,
+      0x0008 => 4,
+      0x0010 => 5,
+      0x0020 => 6,
+      0x0040 => 0.5,
+      0x0080 => 1.5,
+      0x0100 => 2.5,
+      0x0200 => 3.5,
+      0x0400 => 4.5,
+      0x0800 => 5.5,
+      0x1000 => "dative",
+      0x2000 => "ionic",
+      0x4000 => "hydrogen",
+    }.freeze
+
+    CDXML_BOND_DISPLAY = {
+      "Solid" => 0,
+      "Dash" => 1,
+      "Hash" => 2,
+      "WedgedHashBegin" => 3,
+      "WedgedHashEnd" => 4,
+      "Bold" => 5,
+      "WedgeBegin" => 6,
+      "WedgeEnd" => 7,
+      "Wavy" => 8,
+      "HollowWedgeBegin" => 9,
+      "HollowWedgeEnd" => 10,
+      "WavyWedgeBegin" => 11,
+      "WavyWedgeEnd" => 12,
+      "Dot" => 13,
+      "DashDot" => 14,
+    }.freeze
+
+    # CDX Bond parser
+    class Bond < BaseNode
+      attr_accessor :begin_id, :end_id, :stereo, :order, :color
+
+      def initialize(parser, parser_type, id)
+        super(parser, parser_type, id)
+
+        @begin_id = nil
+        @end_id = nil
+        @stereo = 0
+        @order = 1
+
+        @color = 0
+      end
+
+      def parse_node(tag, _id, data)
+        case @props_ref[tag]
+        when "Bond_Begin" then @begin_id = read_value(tag, data)
+        when "Bond_End" then @end_id = read_value(tag, data)
+        when "Bond_Order" then @order = bond_order(read_value(tag, data))
+        when "Bond_Display" then @stereo = bond_display(tag, data)
+        when "ForegroundColor" then @color = read_value(tag, data)
+        else do_unhandled(tag)
+        end
+      end
+
+      def bond_order(val)
+        return val if @parser_type == "cdxml"
+
+        CDX_BOND_ORDER[val] || 0
+      end
+
+      def bond_display(tag, data)
+        return read_value(tag, data) if @parser_type == "cdx"
+
+        CDXML_BOND_DISPLAY[data.text]
+      end
+
+      def end_points
+        [@begin_id, @end_id]
+      end
+
+      def replace_endpoint(endpoint, new_point)
+        if @begin_id == endpoint
+          @begin_id = new_point
+        elsif @end_id == endpoint
+          @end_id = new_point
+        end
+      end
+
+      def other_endpoint(endpoint)
+        endpoint == @begin_id ? @end_id : @begin_id
+      end
+
+      def has_endpoint?(id)
+        [@begin_id, @end_id].include?(id)
+      end
+    end
+  end
+end

data/lib/chem_scanner/chem_draw/node/bracket_attachment.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module ChemDraw
+    # CDX Bracket parser
+    class BracketAttachment < BaseNode
+      attr_reader :graphic_id
+
+      def parse_node(tag, _id, data)
+        ref = @props_ref[tag] || @obj_ref[tag]
+        return unless ref == "Bracket_GraphicID"
+
+        @graphic_id = read_value(tag, data)
+      end
+    end
+  end
+end

data/lib/chem_scanner/chem_draw/node/bracket_group.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module ChemDraw
+    # CDX Bracket parser
+    class BracketGroup < BaseNode
+      require "chem_scanner/chem_draw/node/bracket_attachment"
+
+      attr_reader :attachments, :object_ids
+
+      def initialize(parser, parser_type, id)
+        super(parser, parser_type, id)
+
+        @attachments = []
+        @object_ids = []
+      end
+
+      def parse_node(tag, id, data)
+        if @props_ref[tag] == "BracketedObjects"
+          @object_ids = read_value(tag, data)
+          return
+        end
+
+        return do_unhandled(tag) unless @obj_ref[tag] == "BracketAttachment"
+
+        attachment = BracketAttachment.new(@parser, @parser_type, id)
+        attachment.read
+        @attachments.push(attachment)
+      end
+    end
+  end
+end

data/lib/chem_scanner/chem_draw/node/chem_geometry.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module ChemDraw
+    # Geometry parser
+    class ChemGeometry < BaseNode
+      attr_reader :tail, :head, :head_type, :nogo, :line_type
+
+      def initialize(parser, parser_type, id)
+        super(parser, parser_type, id)
+
+        @middle_points = []
+        @line_type = 0
+      end
+
+      # NOTE: head ----> tail (head at tail)
+      def parse_node(tag, _nid, data)
+        case @props_ref[tag]
+        when "3DTail"
+          x, y = read_value(tag, data)
+          @tail = { x: x, y: y }
+        when "3DHead"
+          x, y = read_value(tag, data)
+          @head = { x: x, y: y }
+        when "Arrow_ArrowHead_Head"
+          @arrow_head = read_type(tag, data, CDXML_ARROW_TYPE)
+        when "Arrow_NoGo" then @nogo = read_value(tag, data)
+        when "Line_Type"
+          @line_type = read_type(tag, data, CDXML_LINE_TYPE)
+        else do_unhandled(tag)
+        end
+      end
+
+      def segment
+        Geometry::Segment.new_by_arrays(
+          [@tail[:x], @tail[:y]],
+          [@head[:x], @head[:y]],
+        )
+      end
+
+      def vector
+        segment.to_vector
+      end
+
+      def line
+        segment.to_line
+      end
+
+      def headless
+        @arrow_head != 2
+      end
+
+      def cross?
+        !@nogo.nil?
+      end
+    end
+  end
+end

data/lib/chem_scanner/chem_draw/node/color_table.rb

@@ -0,0 +1,46 @@
+module ChemScanner
+  module ChemDraw
+    # ColorTable
+    class ColorTable < BaseNode
+      attr_reader :table
+
+      def initialize(parser_type, data)
+        @parser_type = parser_type
+        @data = data
+      end
+
+      def read
+        @parser_type == "cdx" ? read_cdx : read_cdxml
+      end
+
+      def read_cdx
+        @nums = read_int(@data[0, 2], true)
+        rgbs = binary_chunks(@data[2..-1], 2).map { |x| read_int(x, true) }
+
+        table = rgbs.each_slice(3).to_a.map do |x|
+          x.reduce("") do |memo, c|
+            rgb = c >> 8
+            memo << rgb.to_s(16).rjust(2, "0")
+          end
+        end
+
+        @table = %w[000000 FFFFFF] + table
+      end
+
+      def read_cdxml
+        table = @data.element_children.each_with_object([]) do |color, t|
+          next if color.name != "color"
+
+          rgb = %w[r g b].reduce("") do |memo, c|
+            ct = color.attr(c).to_i * 255
+            memo << ct.to_s(16).rjust(2, "0")
+          end
+
+          t.push(rgb)
+        end
+
+        @table = %w[000000 FFFFFF] + table
+      end
+    end
+  end
+end

data/lib/chem_scanner/chem_draw/node/font_table.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module ChemDraw
+    # CDX Graphic parser
+    class FontTable < BaseNode
+      attr_reader :table
+
+      def initialize(parser_type, data)
+        @parser_type = parser_type
+        @data = data
+      end
+
+      def read
+        @parser_type == "cdx" ? read_cdx : read_cdxml
+      end
+
+      def read_cdx
+        @table = []
+        run_count = read_int(@data[2, 2], true)
+
+        iter = 4
+        (1..run_count).each do
+          font, length = read_cdx_font_attribute(iter)
+          @table.push(font)
+          iter += 6 + length
+        end
+
+        @table
+      end
+
+      def read_cdx_font_attribute(iter)
+        id = read_int(@data[iter, 2], true)
+        charset = read_int(@data[iter + 2, 2], true)
+        length = read_int(@data[iter + 4, 2], true)
+        name = @data[iter + 6, length]
+
+        [{ id: id, charset: charset, name: name }, length]
+      end
+
+      def read_cdxml
+        @table = @data.element_children.each_with_object([]) do |font, table|
+          next if font.name != "font"
+
+          id = font.attr("id").to_i
+          charset = font.attr("charset")
+          name = font.attr("name")
+
+          table.push(id: id, charset: charset, name: name)
+        end
+      end
+    end
+  end
+end

data/lib/chem_scanner/chem_draw/node/fragment.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module ChemScanner
+  module ChemDraw
+    # CDX Fragment parser
+    class Fragment < BaseNode
+      require "chem_scanner/chem_draw/node/fragment_node"
+      require "chem_scanner/chem_draw/node/bond"
+
+      attr_accessor :boxed, # indicate if fragment is boxed within an rectangle
+                    :polygon, :node_map, :bond_map, :graphic_map
+
+      def initialize(parser, parser_type, id)
+        super(parser, parser_type, id)
+        @boxed = false
+
+        @node_map = {}
+        @bond_map = {}
+
+        @graphic_map = {}
+      end
+
+      def parse_node(tag, nid, _data)
+        case @props_ref.key?(tag) || @obj_ref[tag]
+        when "Node" then create_node(nid)
+        when "Bond" then create_bond(nid)
+        when "Graphic"
+          graphic = Graphic.new(@parser, @parser_type, id)
+          graphic.read
+          @graphic_map[id] = graphic
+        # when "BoundingBox" then @polygon = read_value(tag, data)
+
+        # NOTE: Indicates that this object represents some properties
+        # in some other objects.
+        # when "RepresentsProperty" then @represent = true
+        else do_unhandled(tag)
+        end
+      end
+
+      def post_parse_node
+        return if !@polygon.nil? || @node_map.count.zero?
+
+        rebuild_polygon
+      end
+
+      def rebuild_polygon
+        fn = @node_map.first[1]
+        lb = Geometry::Point.new(fn.x, fn.y)
+        rt = Geometry::Point.new(fn.x, fn.y)
+
+        @node_map.each_value do |node|
+          # next if node.x.nil? || node.y.nil?
+          next if node.has_nil_coord?
+
+          nlb = node.leftbottom
+          nrt = node.righttop
+
+          lb.x = nlb.x if nlb.x < lb.x
+          lb.y = nlb.y if nlb.y < lb.y
+
+          rt.x = nrt.x if nrt.x > rt.x
+          rt.y = nrt.y if nrt.y > rt.y
+        end
+
+        points = [
+          Geometry::Point.new(lb.x, lb.y),
+          Geometry::Point.new(lb.x, rt.y),
+          Geometry::Point.new(rt.x, rt.y),
+          Geometry::Point.new(rt.x, lb.y),
+        ]
+        @polygon = Geometry::Polygon.new(points)
+      end
+
+      def create_node(id)
+        node = FragmentNode.new(@parser, @parser_type, id)
+        node.read
+        @node_map[id] = node
+      end
+
+      def create_bond(id)
+        bond = Bond.new(@parser, @parser_type, id)
+        bond.read
+        @bond_map[id] = bond
+      end
+
+      def get_node_with_type(type)
+        @node_map.select { |_, v| v.type == type }
+      end
+
+      # Check if fragment has ExternalConnectionPoint node
+      def get_external_point
+        get_node_with_type(12)
+      end
+
+      # Get the internal id for Fragment node
+      def get_internal_nids
+        ext_node = get_external_point
+        return [] if ext_node.count.zero?
+
+        ext_ids = ext_node.keys
+        internal_ids = []
+        ext_ids.each do |ext_id|
+          hbond = bond_has_endpoint(ext_id)
+          _, bond = hbond
+
+          internal_ids.push(bond.other_endpoint(ext_id))
+        end
+        [ext_ids, internal_ids]
+      end
+
+      def bond_has_endpoint(endpoint)
+        @bond_map.detect { |_, b| b.end_points.include?(endpoint) }
+      end
+
+      def clone
+        cloned = self.class.new(@parser, @parser_type, @id)
+        cloned.boxed = @boxed
+        cloned.clone_node_map(@node_map)
+        cloned.clone_bond_map(@bond_map)
+
+        cloned
+      end
+
+      def clone_node_map(node_map)
+        @node_map = {}
+        node_map.each do |k, v|
+          @node_map[k] = v
+        end
+      end
+
+      def clone_bond_map(bond_map)
+        @bond_map = {}
+        bond_map.each do |k, v|
+          @bond_map[k] = v
+        end
+      end
+
+      def set_new_id
+        new_id = @parser.get_tempid
+        set_id(new_id)
+        new_id
+      end
+
+      def set_id(new_id)
+        @id = new_id
+      end
+    end
+  end
+end