joseph 0.1.0 → 0.5.0

data/lib/joseph/cirseg.rb

@@ -0,0 +1,11 @@
+module Joseph
+  class Cirseg < FFI::Struct
+    layout :cp_x, :double,
+      :cp_y, :double,
+      :width, :double,
+      :height, :double,
+      :angle1, :double,
+      :angle2, :double
+
+  end
+end

data/lib/joseph/file_info.rb

@@ -0,0 +1,17 @@
+module Joseph
+  class FileInfo < FFI::Struct
+    layout :image, Image.by_ref,
+      :color, GdkColor.by_value,
+      :alpha, :uint16,
+      :is_visible, :int,
+      :private_render_data, :pointer,
+      :full_pathname, :string,
+      :name, :string,
+      :transform, UserTransformation.by_value,
+      :layer_dirty, :int
+
+    def image
+      self[:image]
+    end
+  end
+end

data/lib/joseph/gdk_color.rb

@@ -0,0 +1,35 @@
+module Joseph
+  class GdkColor < FFI::Struct
+    def self.create(r, g, b)
+      color = self.new
+      color.red = r
+      color.green = g
+      color.blue = b
+      color
+    end
+
+    layout :pixel, :uint32,
+      :red, :uint16,
+      :green, :uint16,
+      :blue, :uint16
+
+    def red=(val)
+      self[:red] = val.to_gdk_color
+    end
+
+    def green=(val)
+      self[:green] = val.to_gdk_color
+    end
+
+    def blue=(val)
+      self[:blue] = val.to_gdk_color
+    end
+
+    def hex=(val)
+      val.sub! /#/, ''
+      self.red = val[0..1].to_i(16)
+      self.green = val[2..3].to_i(16)
+      self.blue = val[4..5].to_i(16)
+    end
+  end
+end

data/lib/joseph/image.rb

@@ -0,0 +1,143 @@
+module Joseph
+  class Image < FFI::Struct
+    def self.create
+      Bridge.gerbv_create_image nil, nil
+    end
+
+    def self.memory_map
+      f = {}
+      f[:layertype] = :int
+
+      # Ugly as hell but works
+      9999.times do |ix|
+        sym = "aperture_#{ix}".to_sym
+        f[sym] = Aperture.by_ref
+      end
+
+      f[:layers] = :pointer
+      f[:states] = :pointer
+      f[:amacro] = :pointer
+      f[:format] = :pointer
+      f[:info] = ImageInfo.by_ref
+      f[:netlist] = :pointer
+      f[:gerbv_stats] = :pointer
+      f[:drill_stats] = :pointer
+      f
+    end
+    layout memory_map
+
+
+    def add(image, transformation = UserTransformation.new)
+      Bridge.gerbv_image_copy_image(image.pointer, transformation.pointer, self.pointer)
+
+      # Check if polarity reset is necessary
+      return if image.last_layer[:polarity] == 2
+      # As Gerbv does not reset polarity, we add another 'dummy' layer with dark polarity
+      # Afterwards a zero flash is created and associated to the new created layer
+      # Otherwise some strange memory issue occours when dumping the image
+
+      # Reset polarity of both images
+      layer = Bridge.gerbv_image_return_new_layer(last_layer)
+      layer[:polarity] = 2 # Default polarity
+
+      each_net do |net|
+        if net[:next].null?
+          dummy = Bridge.gerber_create_new_net(net, layer, nil)
+          dummy[:interpolation] = 8 # Do not draw net / GERBV_INTERPOLATION_DELETED
+        end
+      end
+
+      nil
+    end
+
+    def duplicate(transformation = nil)
+      Bridge.gerbv_image_duplicate_image(self, transformation)
+    end
+
+    def to_output(store = Ramdo::Store.new)
+      if rs274x?
+        Bridge.gerbv_export_rs274x_file_from_image(store.file, self, UserTransformation.new)
+      elsif drill?
+        Bridge.gerbv_export_drill_file_from_image(store.file, self, UserTransformation.new)
+      end
+
+      store
+    end
+
+    def each_net(&block)
+      address = self[:netlist]
+      loop do
+        net = Net.new(address)
+        yield(net) unless net[:aperture_state] == 0
+
+        # Keep address of next net and return if not available
+        address = net[:next]
+        break if address.null?
+      end
+    end
+
+    def net_count
+      c = 0
+      each_net { c += 1 }
+      c
+    end
+
+    def last_net
+      net = nil
+      each_net { |n| net = n }
+      net
+    end
+
+    def each_layer(&block)
+      address = self[:layers]
+      loop do
+        layer = Layer.new(address)
+        yield(layer)
+
+        address = layer[:next]
+        break if address.null?
+      end
+    end
+
+    def layer_count
+      c = 0
+      each_layer { c += 1 }
+      c
+    end
+
+    def last_layer
+      layer = nil
+      each_layer { |l| layer = l }
+      layer
+    end
+
+    def crop!(bb)
+      each_net do |net|
+        net[:start_y] = [bb[:bottom], net[:start_y]].min
+        net[:stop_y] = [bb[:bottom], net[:stop_y]].min
+        net[:start_x] = [bb[:left], net[:start_x]].max
+        net[:stop_x] = [bb[:left], net[:stop_x]].max
+        net[:start_y] = [bb[:top], net[:start_y]].max
+        net[:stop_y] = [bb[:top], net[:stop_y]].max
+        net[:start_x] = [bb[:right], net[:start_x]].min
+        net[:stop_x] = [bb[:right], net[:stop_x]].min
+      end
+    end
+
+    def rs274x?
+      self[:layertype] == 0
+    end
+
+    def drill?
+      self[:layertype] == 1
+    end
+
+    def info
+      self[:info]
+    end
+
+    def destroy!
+      Bridge.gerbv_destroy_image(self)
+    end
+  end
+end

data/lib/joseph/image_info.rb

@@ -0,0 +1,25 @@
+module Joseph
+  class ImageInfo < FFI::Struct
+    layout :name, :string,
+      :polarity, :int,
+      :min_x, :double,
+      :min_y, :double,
+      :max_x, :double,
+      :max_y, :double,
+      :offset_a, :double,
+      :offset_b, :double,
+      :encoding, :int,
+      :rotation, :double,
+      :justify_type_a, :int,
+      :justify_type_b, :int,
+      :justify_offset_a, :double,
+      :justify_offset_b, :double,
+      :justify_offset_actual_a, :double,
+      :justify_offset_actual_a, :double,
+      :plotter_film, :string,
+      :type, :string,
+      :hid_attribute, :pointer,
+      :n_attr, :int
+
+  end
+end

data/lib/joseph/knockout.rb

@@ -0,0 +1,13 @@
+module Joseph
+  class Knockout < FFI::Struct
+    layout :first_instance, :bool,
+      :type, :int,
+      :polarity, :int,
+      :lower_left_x, :double,
+      :lower_left_y, :double,
+      :width, :double,
+      :height, :double,
+      :border, :double
+
+  end
+end

data/lib/joseph/layer.rb

@@ -0,0 +1,11 @@
+module Joseph
+  class Layer < FFI::Struct
+    layout :step_and_repeat, StepAndRepeat.by_value,
+      :knockout, Knockout.by_value,
+      :rotation, :double,
+      :polarity, :int,
+      :name, :string,
+      :next, :pointer
+
+  end
+end

data/lib/joseph/net.rb

@@ -0,0 +1,38 @@
+module Joseph
+  class Net < FFI::Struct
+    layout :start_x, :double,
+      :start_y, :double,
+      :stop_x, :double,
+      :stop_y, :double,
+      :bounding_box, RenderSize.by_value,
+      :aperture, :int,
+      :aperture_state, :int,
+      :interpolation, :int,
+      :cirseg, Cirseg.by_ref,
+      :next, :pointer,
+      :label, :string,
+      :layer, :pointer,
+      :state, :pointer
+
+    def hash
+      [
+        self[:start_x],
+        self[:start_y],
+        self[:stop_x],
+        self[:stop_y]
+      ].hash
+    end
+
+    def length
+      (Vector[self[:start_x], self[:start_y]] - Vector[self[:stop_x], self[:stop_y]]).r
+    end
+
+    def flash?
+      self[:aperture_state] == 2
+    end
+
+    def destroy!
+      Bridge.gerbv_image_delete_net(self)
+    end
+  end
+end

data/lib/joseph/project.rb

@@ -0,0 +1,87 @@
+module Joseph
+  class Project < FFI::Struct
+    def self.create(r = 0x00, g = 0x00, b = 0x00)
+      project = Bridge.gerbv_create_project
+      project[:background].red = r
+      project[:background].green = g
+      project[:background].blue = b
+      project
+    end
+
+    attr_reader :index
+
+    layout :background, GdkColor.by_value,
+      :max_files, :int,
+      :file, :pointer,
+      :curr_index, :int,
+      :last_loaded, :int,
+      :render_type, :int,
+      :check_before_delete, :bool,
+      :path, :string,
+      :execpath, :string,
+      :execname, :string,
+      :project, :string
+
+    def initialize(address)
+      super(address)
+      @index = Hash.new
+    end
+
+    def file(ix)
+      ix = @index[ix] if ix.is_a? Symbol
+      return nil if ix.nil? || ix > self[:last_loaded]
+
+      FileInfo.new((self[:file] + (ix * FFI::Type::POINTER.size)).read_pointer)
+    end
+
+    def add_file(file, name, color = {})
+      file = file.file if file.is_a? Ramdo::Store
+      [:red, :green, :blue, :alpha].each { |k, v| color[k] ||= 0xFF.to_gdk_color }
+
+      last_ix = self[:last_loaded]
+      Bridge.gerbv_open_layer_from_filename_with_color(self, file, color[:red], color[:green], color[:blue], color[:alpha])
+      return false if self[:last_loaded] == last_ix # Return if file is invalid
+
+      @index[name] = self[:last_loaded]
+    end
+
+    def each_file(&block)
+      0.upto(self[:last_loaded]) do |ix|
+        file = FileInfo.new((self[:file] + (ix * FFI::Type::POINTER.size)).read_pointer)
+        yield(file)
+      end
+    end
+
+    def to_png(args = {})
+      store = args[:store] || Ramdo::Store.new
+      dpi = args[:dpi] || 600 # HiDPI setting for high resolution screens
+
+      if args[:bb] && args[:bb].valid?
+        Bridge.gerbv_export_png_file_from_project(self, render_info(args[:bb], dpi, !!args[:mirror]), store.file)
+      else
+        Bridge.gerbv_export_png_file_from_project_autoscaled(self, 1920, 1080, store.file)
+      end
+
+      store
+    end
+
+    def destroy!
+      Bridge.gerbv_destroy_project(self)
+    end
+
+    private
+    def render_info(bb, dpi, mirror)
+      info = RenderInfo.new
+      info[:render_type] = 3
+
+      info[:display_width] = dpi * bb.width
+      info[:display_height] = dpi * bb.height
+      info[:scale_factor_x] = dpi
+      info[:scale_factor_y] = dpi
+      info[:lower_left_x] = mirror ? -bb.right : bb.left
+      info[:lower_left_y] = bb.top
+
+      info
+    end
+  end
+end

data/lib/joseph/render_info.rb

@@ -0,0 +1,11 @@
+module Joseph
+  class RenderInfo < FFI::Struct
+    layout :scale_factor_x, :double,
+      :scale_factor_y, :double,
+      :lower_left_x, :double,
+      :lower_left_y, :double,
+      :render_type, :uint,
+      :display_width, :int,
+      :display_height, :int
+  end
+end

data/lib/joseph/render_size.rb

@@ -0,0 +1,50 @@
+module Joseph
+  class RenderSize < FFI::Struct
+    def self.from_image(image)
+      rs = self.new
+      rs[:left] = image.info[:min_x]
+      rs[:right] = image.info[:max_x]
+      rs[:top] = image.info[:min_y]
+      rs[:bottom] = image.info[:max_y]
+      rs
+    end
+
+    layout :left, :double,
+      :right, :double,
+      :bottom, :double,
+      :top, :double
+
+    def valid?
+      !(self[:right].infinite? || self[:left].infinite? || self[:top].infinite? || self[:bottom].infinite?)
+    end
+
+    def to_s
+      "Right #{self[:right]} / Left #{self[:left]} / Top #{self[:top]} / Bottom #{self[:bottom]}"
+    end
+
+    def width
+      (self[:right] - self[:left]).abs
+    end
+
+    def height
+      (self[:top] - self[:bottom]).abs
+    end
+
+    def left
+      self[:left]
+    end
+
+    def right
+      self[:right]
+    end
+
+    def top
+      self[:top]
+    end
+
+    def bottom
+      self[:bottom]
+    end
+  end
+
+end