microstation 0.4.1 → 0.8.3

data/lib/microstation/ext/win32ole.rb

@@ -0,0 +1,7 @@
+class WIN32OLE
+
+  def ole_obj
+    self
+  end
+
+end

data/lib/microstation/extensions/faa.rb

@@ -0,0 +1,124 @@
+module Microstation
+  class Drawing
+    class Number
+    end
+  end
+end
+
+
+module Microstation
+
+
+  class Drawing
+
+
+
+    def number
+      binding.pry
+      Drawing::Number.from_string(self.basename)
+    end
+
+    class Number
+
+      DRAWING_RE = /(.+)-.+-(.+)-(.+).dgn/
+
+      def self.from_string(drawing_name)
+        md = DRAWING_RE.match(drawing_name.to_s)
+        new(md[1],md[2],md[3])
+      end
+
+
+      def Index(str)
+        return str if str == Drawing::Index
+        Drawing::Index.new(str.to_s)
+      end
+
+
+
+      attr_reader :locid, :factype, :index
+
+      def initialize(locid,factype, index)
+        @locid = locid.to_s.upcase
+        @factype = factype.to_s.upcase
+        @index = Index(index)
+      end
+
+
+
+      def to_s
+        [locid,'D',factype,index.to_s].join("-")
+      end
+
+      def discipline
+        index.discipline
+      end
+
+      def +(n)
+        self.class.new(locid,factype,index.+(n))
+      end
+
+      def -(n)
+        self.class.new(locid,factype,index.-(n))
+      end
+
+    end
+
+
+    class Index
+
+
+
+      def initialize(str)
+        return str if str === Index
+        @nbr = str
+      end
+
+      def discipline
+        @nbr[0].upcase
+      end
+
+      def digits
+        @nbr[1..-1]
+      end
+
+      def to_s
+        combined_string(digits_string)
+      end
+
+      def as_int
+        digits.to_i
+      end
+
+      def digits_string(n = digits)
+        "%03d" % n
+      end
+
+      def combined_string(dstring)
+        "#{discipline}#{dstring}"
+      end
+
+      def +(n)
+        self.class.new( combined_string( digits_string(as_int + n)))
+      end
+
+
+      def -(n)
+        self.class.new( combined_string( digits_string(as_int - n)))
+
+      end
+
+      def succ
+        self.+(1)
+      end
+
+      def pred
+        self.-(1)
+      end
+
+
+
+    end
+
+  end
+
+end

data/lib/microstation/file_tests.rb

@@ -0,0 +1,68 @@
+module Microstation
+
+  module FileTests
+
+
+    def microstation_drawing?(f)
+      f = f.to_path if f.respond_to? :to_path
+      f = f.to_str
+      File.file?(f) && File.extname(f) == '.dgn'
+    end
+
+    def drawing?(f)
+      f = f.to_path if f.respond_to? :to_path
+      f = f.to_str
+      File.file?(f) && drawing_type?(f)
+    end
+
+
+    def drawing_type?(f)
+      f = f.to_path if f.respond_to? :to_path
+      f = f.to_str
+      ext = File.extname(f)
+      ext == '.dwg' || ext == '.dgn'
+    end
+
+    def check_is_drawing(f)
+      raise ArgumentError, 'File must be a dgn or dwg file' unless drawing?(f)
+    end
+    def check_is_dgn(f)
+      raise ArgumentError, 'File must be a dgn file' unless microstation_drawing?(f)
+    end
+  end
+
+end
+
+
+if $0 == __FILE__
+
+  class Test
+
+    include Microstation::FileChecks
+
+
+  end
+
+  module Microstation
+
+    class Test2
+
+      include FileChecks
+
+    end
+
+  end
+
+  t = Test.new
+  t2 = Microstation::Test2.new
+
+  def check_type(c,c2,f)
+    puts "c.drawing_type?(#{f}) == #{c.drawing_type?(f)}"
+    puts "c2.drawing_type?(#{f}) == #{c2.drawing_type?(f)}"
+  end
+
+  %w( doc.pdf doc.doc doc.rtf doc.dgn doc.dwg doc.rb).each do |f|
+    check_type(t,t2,f)
+  end
+
+end

data/lib/microstation/functions.rb

@@ -0,0 +1,60 @@
+require 'dry/monads'
+module Microstation
+
+  class App
+    include Dry::Monads[:result]
+  end
+
+  module Functions
+
+    extend Dry::Monads[:result]
+
+    def get_points_by_rectangle
+      queue = cad_input_queue
+      queue.show_command('Get points by block')
+      start_point = queue.get_point
+      if start_point.failure?
+        return Failure(:point1_reset)
+      end
+      queue.send_command "PLACE BLOCK"
+      queue.send_data_point start_point.value!
+      end_point = queue.get_point
+      if end_point.failure?
+        return Failure(:point2_reset)
+      end
+      Success([start_point.value!, end_point.value!])
+    end
+
+    def get_points_by_line
+      queue = cad_input_queue
+      queue.show_command("Get points by line")
+      start_point = queue.get_point
+      if start_point.failure?
+        return Failure(:point1_reset)
+      end
+      queue.send_command "PLACE LINE"
+      queue.send_data_point start_point.value!
+      end_point = queue.get_point("Enter next vertex")
+      if end_point.failure?
+        return Failure(:point2_reset)
+      end
+      Success([start_point.value!, end_point.value!])
+    end
+
+    def clear_ui
+      cad_input_queue.clear_ui
+    end
+
+    def get_point
+      cad_input_queue.get_point
+    end
+
+
+  end
+
+
+  class App
+    include Functions
+  end
+end
+

data/lib/microstation/graphics.rb

@@ -0,0 +1,35 @@
+module Microstation
+
+  module Graphics
+
+
+    def line(p1,p2,el = WIN32OLE_VARIANT::Nothing)
+      pt1 = app.to_ole_point3d(p1)
+      pt2 = app.to_ole_point3d(p2)
+      begin
+        ole = app.ole_obj.CreateLineElement2(el,pt1,pt2)
+      rescue Exception => ex
+        binding.pry
+        return nil
+      end
+      add_element(ole) if ole
+    end
+
+
+    def line_from_pts(pts, el = WIN32OLE_VARIANT::Nothing)
+      ole_points = pts.map{ |pt| app.to_ole_point3d(pt) }
+      ole = app.ole_obj.CreateLineElement1(el, ole_points)
+      if ole
+        add_element(ole) 
+      else
+        binding.pry
+      end
+    rescue Exception => e
+      binding.pry
+      return nil
+    end
+  end
+
+
+end
+

data/lib/microstation/line.rb

@@ -0,0 +1,19 @@
+require 'microstation/element'
+
+module Microstation
+
+  class Line < Element
+
+    def length
+      ole_obj.Length
+    end
+
+
+    def vertices
+      ole_obj.AsVertexList
+      n = ole_obj.VerticesCount
+      list = ole_obj.GetVertices
+      list
+    end
+  end
+end

data/lib/microstation/model.rb

@@ -0,0 +1,45 @@
+#require_relative 'scan/scan_trait'
+require 'microstation/wrap'
+require_relative 'model_trait'
+
+#require_relative 'ts/tagset_trait'
+#require_relative 'graphics'
+#require_relative 'ts/instance'
+
+
+module Microstation
+
+  class DefaultModel
+
+    include ::Microstation::ModelTrait
+
+    attr_reader :app,:ole_obj
+
+    def initialize(app,ole)
+      @app = app
+      @ole_obj = ole
+    end
+
+    def drawing
+      @drawing ||= ::Microstation::Drawing.from_ole_obj(app,ole_obj)
+    end
+
+
+  end
+
+
+  class Model
+
+    include ::Microstation::ModelTrait
+
+    attr_reader :app,:drawing,:ole_obj
+
+    def initialize(app,drawing,ole)
+      @app = app
+      @drawing = drawing
+      @ole_obj = ole
+    end
+
+  end
+
+end

data/lib/microstation/model_trait.rb

@@ -0,0 +1,189 @@
+require_relative 'graphics'
+require_relative 'scan_trait'
+
+module Microstation
+  module ModelTrait
+
+    include Graphics
+
+    include ScanTrait
+    # include TS::TagSetTrait
+
+    def name
+      ole_obj.name
+    end
+
+    def find_by_id(id)
+      ele = ole_obj.GetElementById64(id) rescue nil
+      return nil unless ele
+      app.ole_to_ruby(ele)
+    end
+
+    def active?
+      ole_obj.IsActive
+    end
+
+    def get_selected_elements
+      Enumerator.new(ole_obj.GetSelectedElements,app)
+    end
+
+    def get_selected_text
+      get_selected_elements.select{|t| t.textual?}
+    end
+
+    def get_matching_text(re)
+      result = []
+      get_selected_text.each do |t|
+        md = re.match( t)
+        if md
+          if block_given?
+            yield t,md
+          else
+            result << t
+          end
+        end
+        result
+      end
+    end
+
+    def change_text_suffix(reg,offset)
+      get_matching_text(reg) do |t,md|
+        pre = md[1]
+        suff = Integer( md[2] ) + offset
+        t.replace "#{pre}#{suff}"
+      end
+    end
+
+    def unselect_element(el)
+      ole_obj.UnselectElement(el.ole_obj)
+    end
+
+    def select_element(el)
+      ole_obj.SelectElement(el.ole_obj)
+    end
+
+    def readonly?
+      ole_obj.IsReadOnly
+    end
+
+    def activate
+      ole_obj.Activate
+    end
+
+    def locked?
+      ole_obj.IsLocked?
+    end
+
+    def to_s
+      "Microstation::Model-#{name}"
+    end
+
+
+    def add_element(el)
+      if el.respond_to? :ole_obj
+        el = el.ole_obj
+        ole_obj.AddElement(el)
+        self
+      end
+    end
+
+    def select_tagset_instances
+
+    end
+
+    def scan_tags_filtered( ts_name: nil, base_element_id: nil,&block)
+      case [ts_name, base_element_id]
+          in [nil, nil]
+          scan_tags(&block)
+          in [String,nil]
+          scan_tags.select{ |t| t.tagset_name == ts_name }
+          in [String, Numeric]
+          scan_tags.select{ |t| t.tagset_name == ts_name && t.base_element_id == base_element_id }
+          in [nil, Numeric]
+          scan_tags.select{ |t| t.base_element_id == base_element_id  }
+
+      end
+    end
+
+    def tags_to_hash(tags)
+      return to_enum(__callee__,tags) unless block_given?
+      tsets = tags.group_by{ |t| t.tagset_name }
+      tsets.each do |tsname, tags|
+        elements = tags.group_by{|t| t.base_element_id}
+        elements.each do |id, tag_elts|
+          result_hash = {
+            name: tsname,
+            model: name,
+            tags: tag_elts,
+            base_element_id: id,
+          }
+          yield result_hash
+        end
+      end
+    end
+
+    def get_tagsets_in_model_hash(ts_name: nil, base_element_id: nil,&block)
+      tags = scan_tags_filtered(ts_name: ts_name, base_element_id: base_element_id)
+      tags_to_hash(tags, &block)
+    end
+
+    def get_tagsets_in_model_hash_old
+      results = []
+      tsets  = scan_tags.group_by{|t| t.tagset_name}
+      tsets.each do |tsname, tags|
+        elements = tags.group_by{|t| t.base_element_id}
+        elements.each do |id, tag_elts|
+          result_hash = {
+            name: tsname,
+            model: name,
+            tags: tag_elts,
+            base_element_id: id,
+          }
+          if block_given?
+            yield result_hash
+          else
+            results << result_hash
+          end
+        end
+        results unless block_given?
+      end 
+
+    end
+
+
+    # Scan the model with
+    # @param [Scan::Criteria] criteria - the criteria to scan
+    # @yield the item
+    def scan_model(criteria=nil)
+      #    binding.pry
+      criteria = criteria || create_scanner(:nullscanner)
+      scan_result = ole_run_scan(criteria)
+      return [] unless scan_result
+      #   binding.pry
+      scan_enum = ::Microstation::Enumerator.new(scan_result, app)
+      result =  []
+      if block_given?
+        scan_enum.each do |item|
+          yield item
+        end
+      else
+        scan_enum.each do |item|
+          result << item
+        end
+      end
+
+      return result unless block_given?
+    end
+
+
+    private
+
+    def ole_run_scan(criteria)
+      criteria.resolve
+      scan_result = self.ole_obj.Scan(criteria.ole_obj) rescue nil
+    end
+
+
+  end
+
+end