dxf_io 0.1.0

data/lib/dxf_io/entity/support.rb

@@ -0,0 +1,9 @@
+module DxfIO
+  module Entity
+    module Support
+      extend ActiveSupport::Autoload
+
+      autoload :Point
+    end
+  end
+end

data/lib/dxf_io/entity/support/point.rb

@@ -0,0 +1,114 @@
+module DxfIO
+  module Entity
+    module Support
+      class Point
+
+        START_POINT_GROUP_NUMS = DxfIO::Constants::START_POINT_GROUP_NUMS
+        END_POINT_GROUP_NUMS = DxfIO::Constants::END_POINT_GROUP_NUMS
+        TYPES = %i(start end).freeze
+
+        attr_reader :x, :y, :type
+
+        def initialize(x, y, options = {})
+          @x, @y = x, y
+          @type = TYPES.include?(options[:type]) ? options[:type] : TYPES.first
+        end
+
+        def start?
+          @type == :start
+        end
+
+        def end?
+          @type == :end
+        end
+
+        def to_a
+          [@x, @y]
+        end
+
+        def to_h
+          {x: @x, y: @y}
+        end
+
+        def to_dxf_array
+          if start?
+            [{START_POINT_GROUP_NUMS.first => @x}, {START_POINT_GROUP_NUMS.last => @y}]
+          elsif end?
+            [{END_POINT_GROUP_NUMS.first => @x}, {END_POINT_GROUP_NUMS.last => @y}]
+          end
+        end
+
+        # eq operations
+
+        def ==(point)
+          to_a == point.to_a
+        end
+
+        # math operations
+
+        # unary
+
+        def -@
+          self.class.new(-@x, -@y, type: @type)
+        end
+
+        # binary
+
+        def +(point)
+          if point.is_a? self.class
+            self.class.new(@x + point.x,
+                           @y + point.y,
+                           type: @type == point.type ? @type : :start)
+          elsif point.is_a? Array
+            self.class.new(@x + point[0],
+                           @y + point[1],
+                           type: @type)
+          else
+            raise ArgumentError, 'point must be an Array or a DxfIO::Entity::Support::Point'
+          end
+        end
+
+        def -(point)
+          if point.is_a? self.class
+            self - point
+          elsif point.is_a? Array
+            self + point.map(&:-@)
+          else
+            raise ArgumentError, 'point must be an Array or a DxfIO::Entity::Support::Point'
+          end
+        end
+
+        def *(num)
+          if num.is_a? Numeric
+            self.class.new(@x * num,
+                           @y * num,
+                           type: @type)
+          else
+            raise ArgumentError, 'argument must be Numeric'
+          end
+        end
+
+        def /(num)
+          if num.is_a? Numeric
+            self.class.new(@x / num,
+                           @y / num,
+                           type: @type)
+          else
+            raise ArgumentError, 'argument must be Numeric'
+          end
+        end
+
+        # geometrical operation (supposed what point is a vector from zero)
+
+        def rotate_90
+          self.class.new(@y, -@x, type: @type)
+        end
+
+        def rotate_180
+          -self
+        end
+
+      end
+    end
+  end
+end

data/lib/dxf_io/entity/text.rb

@@ -0,0 +1,14 @@
+module DxfIO
+  module Entity
+    class Text < Other
+
+    protected
+
+      def initialize(groups, representation_hash)
+        @representation_hash = representation_hash
+        super(groups)
+      end
+
+    end
+  end
+end

data/lib/dxf_io/reader.rb

@@ -0,0 +1,139 @@
+module DxfIO
+  # based on DXF AutoCAD 2008 documentation (http://images.autodesk.com/adsk/files/acad_dxf0.pdf)
+  class Reader
+
+    SECTIONS_LIST = DxfIO::Constants::SECTIONS_LIST
+    HEADER_NAME = DxfIO::Constants::HEADER_NAME
+
+    def initialize(options)
+      if options.is_a? String
+        @filename = options
+      elsif options.is_a? Hash
+        if options[:path].present?
+          @filename = options[:path]
+        else
+          raise ArgumentError, 'options must contain a :path key'
+        end
+        @encoding = options[:encoding] || 'Windows-1251'
+      end
+    end
+
+    class << self
+      def open(options)
+        self.new(options).tap do |reader_instance|
+          if block_given?
+            yield reader_instance
+          end
+        end
+      end
+    end
+
+    ([HEADER_NAME] + SECTIONS_LIST).each do |method|
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{method.downcase}       # def classes
+          run['#{method}']           #   run['CLASSES']
+        end                          # end
+      EOT
+    end
+
+    def run
+      @result_hash ||= parse
+    end
+
+    alias to_hash run
+    alias to_h run
+
+    def rerun
+      @result_hash = parse
+    end
+
+    def parse(filename = @filename, encoding = @encoding)
+      read_flag = "r:#{encoding}:UTF-8"
+      fp = File.open(filename, read_flag)
+      dxf = {HEADER_NAME => {}}
+      SECTIONS_LIST.each do |section_name|
+        dxf[section_name] = []
+      end
+      #
+      # main loop
+      #
+      begin
+        while true
+          c, v = read_codes(fp)
+          break if v == 'EOF'
+          if v == 'SECTION'
+            c, v = read_codes(fp)
+            if v == HEADER_NAME
+              hdr = dxf[HEADER_NAME]
+              while true
+                c, v = read_codes(fp)
+                break if v == 'ENDSEC' # or v == "BLOCKS" or v == "ENTITIES" or v == "EOF"
+                if c == 9
+                  key = v
+                  hdr[key] = {}
+                else
+                  add_att(hdr[key], c, v)
+                end
+              end # while
+            elsif SECTIONS_LIST.include?(v)
+              section = dxf[v]
+              parse_entities(section, fp)
+            end
+          end # if in SECTION
+        end # main loop
+      ensure
+        fp.close unless fp.nil?
+      end
+
+      dxf
+    end
+
+  private
+
+    def parse_entities(section, fp)
+      while true
+        c, v = read_codes(fp)
+        break if v == 'ENDSEC' || v == 'EOF'
+        next if c == 999
+
+        if c == 0
+          section << [c => v]
+        else
+          section[-1] << {c => v}
+        end
+      end # while
+    end
+
+    def read_codes(fp)
+      c = fp.gets
+      return [0, 'EOF'] if c.nil?
+      v = fp.gets
+      return [0, 'EOF'] if v.nil?
+      c = c.to_i
+      v.strip!
+      v.upcase! if c == 0
+      case c
+        when 10..59, 110..119, 120..129, 130..139, 140..149, 140..147, 210..239, 460..469, 1010..1059
+          v = v.to_f
+        when 60..79, 90..99, 170..175, 280..289, 370..379, 380..389, 400..409, 420..429, 440..449, 450..459, 500..409, 1060..1070, 1071
+          v = v.to_i
+      end
+
+      [c, v]
+    end
+
+    def add_att(ent, code, value)
+      if ent[code].nil?
+        ent[code] = value
+      elsif ent[code].is_a? Array
+        ent[code] << value
+      else
+        t = ent[code]
+        ent[code] = []
+        ent[code] << t
+        ent[code] << value
+      end
+    end
+
+  end
+end

data/lib/dxf_io/version.rb

@@ -0,0 +1,3 @@
+module DxfIO
+  VERSION = '0.1.0'
+end

data/lib/dxf_io/wrapper.rb

@@ -0,0 +1,45 @@
+module DxfIO
+  class Wrapper
+
+    SECTIONS_LIST = DxfIO::Constants::SECTIONS_LIST
+    HEADER_NAME = DxfIO::Constants::HEADER_NAME
+    ENTITIES_TYPE_NAME_VALUE_MAPPING = DxfIO::Constants::ENTITIES_TYPE_NAME_VALUE_MAPPING
+
+    def initialize(options)
+      if options.is_a? Hash
+        if options[:dxf_hash].nil?
+          @dxf_hash = options
+        else
+          @dxf_hash = options[:dxf_hash]
+        end
+      else
+        raise ArgumentError, 'options must be a Hash'
+      end
+    end
+
+    SECTIONS_LIST.each do |method|
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{method.downcase}                  # def classes
+          fetch_entities('#{method}')           #   fetch_entities('CLASSES')
+        end                                     # end
+      EOT
+    end
+
+    def fetch_entities(group_name)
+      @dxf_hash[group_name.upcase].collect do |entity_groups|
+        to_proper_class(DxfIO::Entity::Other.new(entity_groups))
+      end
+    end
+
+  private
+
+    def to_proper_class(entity)
+      type_name = ENTITIES_TYPE_NAME_VALUE_MAPPING.invert[entity.type.upcase]
+      if type_name.nil? || !DxfIO::Entity.constants.include?(type_name.capitalize.to_sym)
+        entity
+      else
+        entity.public_send("to_#{type_name}")
+      end
+    end
+  end
+end

data/lib/dxf_io/writer.rb

@@ -0,0 +1,215 @@
+module DxfIO
+  class Writer
+    require 'fileutils'
+
+    SECTIONS_LIST = DxfIO::Constants::SECTIONS_LIST
+    HEADER_NAME = DxfIO::Constants::HEADER_NAME
+    STRATEGY = DxfIO::Constants::WRITER_STRATEGY
+
+    def initialize(options)
+      # TODO: replace instance variables to hash with options
+      # default options
+      @encoding = 'Windows-1251'
+      @delimiter = "\r\n"
+      @strategy = STRATEGY.first
+      @dxf_hash = {}
+
+      if options.is_a? String
+        @filename = options
+      elsif options.is_a? Hash
+        @dxf_hash = options[:dxf_hash] if options.has_key? :dxf_hash
+        @filename = options[:path] if options.has_key? :path
+        @encoding = options[:encoding] if options.has_key? :encoding
+        @delimiter = options[:delimiter] if options.has_key? :delimiter
+        @strategy = options[:strategy] if options.has_key? :strategy && STRATEGY.include?(options[:strategy])
+      else
+        raise ArgumentError, 'options must be String or Hash with :path key'
+      end
+    end
+
+    class << self
+      def open(options)
+        self.new(options).tap do |writer_instance|
+          if block_given?
+            yield writer_instance
+          end
+        end
+      end
+    end
+
+    # construct dxf content in memory and write all in file at once
+    def write_through_memory(dxf_hash = @dxf_hash)
+      file_stream do |fp|
+        fp.write(
+            file_content do
+              dxf_hash.inject('') do |sections_content, (section_name, section_content)|
+                sections_content << section_wrapper_content(section_name) do
+                  if header_section?(section_name)
+                    header_content(section_content)
+                  else
+                    other_section_content(section_content)
+                  end
+                end
+              end
+            end
+        )
+      end
+    end
+
+    # write dxf file directly on disk without temporary usage of memory for content
+    def write_through_disk(dxf_hash = @dxf_hash)
+      file_stream do |fp|
+        file_wrap(fp) do
+          dxf_hash.each_pair do |section_name, section_content|
+            section_wrap(fp, section_name) do
+              if header_section?(section_name)
+                header_wrap(fp, section_content)
+              else
+                other_section_wrap(fp, section_content)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def run(dxf_hash = @dxf_hash)
+      if @strategy == :memory
+        write_through_memory(dxf_hash)
+      elsif @strategy == :disk
+        write_through_disk(dxf_hash)
+      else
+        raise ArgumentError, ':strategy has invalid value; allowed only [:memory, :disk]'
+      end
+    end
+
+    alias write_hash run
+
+  private
+
+    # work with file
+
+    def file_stream(&block)
+      folder_path = @filename.split('/')[0..-2].join('/')
+      FileUtils.mkdir_p(folder_path)
+      fp = File.open(@filename, "w:#{@encoding}")
+      begin
+        block.call(fp)
+      ensure
+        fp.close unless fp.nil?
+      end
+    end
+
+    # helpers
+
+    def header_section?(section_name)
+      section_name.upcase == HEADER_NAME
+    end
+
+    # wrappers
+
+    # file format:
+    #   ... file content ...
+    #   0
+    #   EOF
+    def file_wrap(fp, &block)
+      file_end = "0#{@delimiter}EOF#{@delimiter}"
+
+      block.call
+      fp.write(file_end)
+    end
+
+    # section format:
+    #   0
+    #   SECTION
+    #   2
+    #   <section_name>
+    #   ... section content ...
+    #   0
+    #   ENDSEC
+    def section_wrap(fp, section_name, &block)
+      section_begin = "0#{@delimiter}SECTION#{@delimiter}2#{@delimiter}#{section_name.upcase}#{@delimiter}"
+      section_end = "0#{@delimiter}ENDSEC#{@delimiter}"
+
+      fp.write(section_begin)
+      block.call
+      fp.write(section_end)
+    end
+
+    # header format:
+    #   9
+    #   $<variable>
+    #   <group code>
+    #   <value>
+    def header_wrap(fp, variables)
+      variables.each_pair do |variable, groups|
+        fp.write("9#{@delimiter}#{'$' if variable[0] != '$'}#{variable}#{@delimiter}")
+        groups.each_pair do |group_code, value|
+          fp.write("#{group_code}#{@delimiter}#{try_to_upcase_exponent(value)}#{@delimiter}")
+        end
+      end
+    end
+
+    # other section format:
+    #   <group code>
+    #   <value>
+    def other_section_wrap(fp, variables)
+      variables.each do |groups|
+        groups.each do |group|
+          fp.write("#{group.keys.first}#{@delimiter}#{try_to_upcase_exponent(group.values.first)}#{@delimiter}")
+        end
+      end
+    end
+
+    # content constructors
+
+    def file_content(&block)
+      file_end = "0#{@delimiter}EOF#{@delimiter}"
+
+      "#{block.call}#{file_end}"
+    end
+
+    def section_wrapper_content(section_name, &block)
+      section_begin = "0#{@delimiter}SECTION#{@delimiter}2#{@delimiter}#{section_name.upcase}#{@delimiter}"
+      section_end = "0#{@delimiter}ENDSEC#{@delimiter}"
+
+      "#{section_begin}#{block.call}#{section_end}"
+    end
+
+    def header_content(variables)
+      variables.inject('') do |result, (variable, groups)|
+        variable_part = "9#{@delimiter}#{'$' if variable[0] != '$'}#{variable}#{@delimiter}"
+        result << groups.inject(variable_part) do |group_result, (group_code, value)|
+          group_result << "#{group_code}#{@delimiter}#{try_to_upcase_exponent(value)}#{@delimiter}"
+        end
+      end
+    end
+
+    def other_section_content(variables)
+      variables.inject('') do |result, groups|
+        result << groups.inject('') do |group_result, group|
+          group_result << "#{group.keys.first}#{@delimiter}#{try_to_upcase_exponent(group.values.first)}#{@delimiter}"
+        end
+      end
+    end
+
+    # formatting
+
+    # replace exponential notation by decimal notation and remove redundant zeros in the end
+    def try_to_decimal_fraction(num)
+      if num.is_a? Float
+        ('%.25f' % num).to_s.sub(/0+$/, '')
+      else
+        num
+      end
+    end
+
+    def try_to_upcase_exponent(num)
+      if num.is_a? Float
+        num.to_s.sub('e', 'E')
+      else
+        num
+      end
+    end
+  end
+end