automotive-ecu 0.1.0

data/lib/ecu/labels/festwerteblock.rb

@@ -0,0 +1,80 @@
+require_relative "label"
+
+class Ecu
+  class Festwerteblock < Label
+
+    attr_reader :xdim, :ydim, :value, :unit
+
+    def initialize(name:,
+                   xdim:,
+                   ydim: 1,
+                   value:,
+                   unit: nil,
+                   function: nil,
+                   description: nil)
+      value        = reshape_if_needed(value, xdim, ydim)
+      ydim         = ydim == 0 ? 1 : ydim
+      @name        = name
+      @xdim        = xdim
+      @ydim        = ydim
+      @value       = value
+      @unit        = unit
+      @function    = function
+      @description = description
+
+      init_error "Dimensions for value don't match ydim" if value.size != ydim
+      init_error "Dimensions for value don't match xdim" if value.any? { |row| row.is_a?(Array) && row.size != xdim }
+    end
+
+    def round_to(n)
+      return self if value.any? { |row| row.any? { |e| e.is_a?(String) }}
+      self.with \
+        value: value.map { |row| row.map { |x| x.round(n) }}
+    end
+
+    def bytesize
+      xdim * ydim * BYTESIZE[:number]
+    end
+
+    def to_s(detail: false)
+      if detail == :value
+        "#{name}:\n#{to_s(detail: :justvalue)}"
+      elsif detail == :justvalue
+        ValuePrinter.call(self)
+      elsif detail == :onelinefull
+        "#{name} #{to_s(detail: :oneline)}"
+      elsif detail == :oneline
+        "(#{xdim}x#{ydim}) Z: #{valuestats(value, show_avg: true)}"
+      else
+        "#{name}: #{xdim}x#{ydim} #{type}".tap do |str|
+          if detail
+            str << "\n"
+            str << "  Unit: \"#{unit}\"\n"
+            str << "  Value:\n"
+            str << ValuePrinter.call(self).indent(4)
+            str << "\n"
+          end
+        end
+      end
+    end
+
+    def properties
+      [:name, :xdim, :ydim, :value, :unit, :function, :description]
+    end
+
+    def equality_properties
+      [:name, :value]
+    end
+
+    private
+
+    def reshape_if_needed(value, xdim, ydim)
+      if value.all? { |row| row.is_a?(Array) }
+        value
+      else
+        value.each_slice(xdim).to_a
+      end
+    end
+
+  end
+end

data/lib/ecu/labels/interpolator.rb

@@ -0,0 +1,55 @@
+class Array
+  def strictly_mon_inc?
+    self.each_cons(2).all? { |lo, hi| lo < hi }
+  end
+end
+
+class Ecu
+  class Interpolator
+    def self.interp1(x_ref, y_ref, x)
+      raise ArgumentError unless x_ref.size == y_ref.size
+      raise ArgumentError unless x_ref.strictly_mon_inc?
+
+      return y_ref.first if x < x_ref.first
+      return y_ref.last  if x > x_ref.last
+
+      x1, x2, fx = find_position(x_ref, x)
+
+      interp(y_ref[x1], y_ref[x2], fx)
+    end
+
+    def self.interp2(x_ref, y_ref, z_ref, x, y)
+      raise ArgumentError unless z_ref.size == y_ref.size
+      raise ArgumentError unless z_ref.all? { |row| row.size == x_ref.size }
+      raise ArgumentError unless x_ref.strictly_mon_inc?
+      raise ArgumentError unless y_ref.strictly_mon_inc?
+
+      x1, x2, fx = find_position(x_ref, x)
+      y1, y2, fy = find_position(y_ref, y)
+
+      interp(interp(z_ref[y1][x1], z_ref[y2][x1], fy),
+             interp(z_ref[y1][x2], z_ref[y2][x2], fy),
+             fx)
+    end
+
+    private
+
+    def self.find_position(ref, x)
+      x = x.to_f
+      n = ref.size - 1
+      return [0, 0, 0] if x < ref.first
+      return [n, n, 0] if x > ref.last
+
+      ref.each_cons(2).each do |lo, hi|
+        if (lo..hi).cover?(x)
+          f = (x - lo)/(hi - lo)
+          return [ref.index(lo), ref.index(hi), f]
+        end
+      end
+    end
+
+    def self.interp(x, y, f)
+      x*(1-f) + y*f
+    end
+  end
+end

data/lib/ecu/labels/kennfeld.rb

@@ -0,0 +1,107 @@
+require_relative "label"
+require_relative "interpolator"
+
+class Ecu
+  class Kennfeld < Label
+
+    attr_reader :value, :unit
+    attr_reader :xdim, :xvalue, :xunit
+    attr_reader :ydim, :yvalue, :yunit
+
+    def initialize(name:,
+                   xdim:,
+                   ydim:,
+                   xvalue:,
+                   yvalue:,
+                   value:,
+                   xunit: nil,
+                   yunit: nil,
+                   unit: nil,
+                   function: nil,
+                   description: nil)
+      value        = value.size > ydim ? value.each_slice(xdim).to_a : value
+      @name        = name
+      @xdim        = xdim
+      @ydim        = ydim
+      @xvalue      = xvalue
+      @yvalue      = yvalue
+      @value       = value
+      @xunit       = xunit
+      @yunit       = yunit
+      @unit        = unit
+      @function    = function
+      @description = description
+
+      init_error "Dimension mismatch: xvalue=#{xvalue.size} xdim=#{xdim}" if xvalue.size != xdim
+      init_error "Dimension mismatch: yvalue=#{yvalue.size} ydim=#{ydim}" if yvalue.size != ydim
+      init_error "Dimension mismatch: value.x=#{value.size} ydim=#{ydim}" if value.size != ydim
+      init_error "Dimension mismatch: value.y=XXX xdim=#{xdim}" if value.any? { |r| r.size != xdim }
+    end
+
+    def value_at(x, y)
+      Interpolator.interp2(xvalue, yvalue, value, x, y)
+    end
+
+    def round_to(n)
+      hsh = Hash.new
+      hsh[:xvalue] = xvalue.map { |x| x.round(n) } if xvalue.all? { |x| x.is_a?(Numeric) }
+      hsh[:yvalue] = yvalue.map { |x| x.round(n) } if yvalue.all? { |x| x.is_a?(Numeric) }
+      if value.all? { |row| row.all? { |x| x.is_a?(Numeric) }}
+        hsh[:value] = value.map { |row| row.map { |x| x.round(n) }}
+      end
+      self.with hsh
+    end
+
+    def reinterpx(new_xvalue)
+      self.with \
+        xvalue: new_xvalue,
+        value: yvalue.map { |y| new_xvalue.map { |x| value_at(x, y) } }
+    end
+
+    def reinterpy(new_yvalue)
+      self.with \
+        yvalue: new_yvalue,
+        value: new_yvalue.map { |y| xvalue.map { |x| value_at(x, y) } }
+    end
+
+    def bytesize
+      (xdim + 1) * (ydim + 1) * BYTESIZE[:number]
+    end
+
+    def to_s(detail: false)
+      if detail == :value
+        "#{name}:\n#{to_s(detail: :justvalue)}"
+      elsif detail == :justvalue
+        ValuePrinter.call(self)
+      elsif detail == :onelinefull
+        "#{name} #{to_s(detail: :oneline)}"
+      elsif detail == :oneline
+        "(#{xdim}x#{ydim}) " +
+          "X: #{valuestats(xvalue)}, " +
+          "Y: #{valuestats(yvalue)}, " +
+          "Z: #{valuestats(value, show_avg: true)}"
+      else
+        "#{name}: #{@xdim}x#{@ydim} #{type}".tap do |str|
+          if detail
+            str << "\n"
+            str << "  x-Unit: \"#{xunit}\"\n"
+            str << "  y-Unit: \"#{yunit}\"\n"
+            str << "  z-Unit: \"#{unit}\"\n"
+            str << "  Value:\n"
+            str << ValuePrinter.call(self).indent(4)
+            str << "\n"
+          end
+        end
+      end
+    end
+
+    def properties
+      [:name, :xdim, :ydim, :xvalue, :yvalue, :value, :xunit, :yunit, :unit, :function, :description]
+    end
+
+    def equality_properties
+      [:name, :xvalue, :yvalue, :value]
+    end
+
+  end
+end

data/lib/ecu/labels/kennlinie.rb

@@ -0,0 +1,84 @@
+require_relative "label"
+require_relative "interpolator"
+
+class Ecu
+  class Kennlinie < Label
+
+    attr_reader :xdim, :xvalue, :xunit
+    attr_reader :value, :unit
+
+    def initialize(name:,
+                   xdim:,
+                   xvalue:,
+                   value:,
+                   xunit: nil,
+                   unit: nil,
+                   function: nil,
+                   description: nil)
+      @name        = name
+      @xdim        = xdim
+      @xvalue      = xvalue
+      @value       = value
+      @xunit       = xunit
+      @unit        = unit
+      @function    = function
+      @description = description
+
+      init_error "Dimensions for value don't match xdim" if value.size != xdim
+      init_error "Dimensions for xvalue don't match xdim" if xvalue.size != xdim
+    end
+
+    def value_at(x)
+      Interpolator.interp1(xvalue, value, x)
+    end
+
+    def round_to(n)
+      hsh = Hash.new
+      hsh[:xvalue] = xvalue.map { |x| x.round(n) } if xvalue.all? { |x| x.is_a?(Numeric) }
+      hsh[:value]  = value.map  { |x| x.round(n) } if value.all?  { |x| x.is_a?(Numeric) }
+      self.with hsh
+    end
+
+    def reinterp(new_xvalue)
+      self.with \
+        xvalue: new_xvalue,
+        value: new_xvalue.map { |x| value_at(x) }
+    end
+
+    def bytesize
+      (1 + 1) * (xdim) * BYTESIZE[:number]
+    end
+
+    def to_s(detail: false)
+      if detail == :value
+        "#{name}:\n#{to_s(detail: :justvalue)}"
+      elsif detail == :justvalue
+        ValuePrinter.call(self)
+      elsif detail == :onelinefull
+        "#{name} #{to_s(detail: :oneline)}"
+      elsif detail == :oneline
+        "(#{xdim}x1) X: #{valuestats(xvalue)}, Z: #{valuestats(value, show_avg: true)}"
+      else
+        "#{name}: #{@xdim}x1 #{type}".tap do |str|
+          if detail
+            str << "\n"
+            str << "  x-Unit: \"#{xunit}\"\n"
+            str << "  y-Unit: \"#{unit}\"\n"
+            str << "  Value:\n"
+            str << ValuePrinter.call(self).indent(4)
+            str << "\n"
+          end
+        end
+      end
+    end
+
+    def properties
+      [:name, :xdim, :xvalue, :value, :xunit, :unit, :function, :description]
+    end
+
+    def equality_properties
+      [:name, :xvalue, :value, :type]
+    end
+
+  end
+end

data/lib/ecu/labels/label.rb

@@ -0,0 +1,82 @@
+require_relative "../interfaces/dcm/label"
+require_relative "../interfaces/lab/label"
+
+require_relative "value_comparison"
+require_relative "value_printer"
+
+class Ecu
+  class Label
+
+    BYTESIZE  = { number: 4,
+                  string: 25 }
+
+    attr_reader :name, :function, :description
+
+    def init_error(message)
+      fail ArgumentError, "Error creating #{name}: " + message
+    end
+
+    def type
+      self.class.name.split('::').last
+    end
+
+    def equality_properties
+      fail NotImplementedError, "Must be implemented in child classes"
+    end
+
+    def properties
+      fail NotImplementedError, "Must be implemented in child classes"
+    end
+
+    def <=>(other)
+      name <=> other.name if other.respond_to?(:name)
+    end
+
+    def hash
+      equality_properties.map { |p| self.public_send(p) }.hash
+    end
+
+    def to_h
+      properties.zip(properties.map { |p| instance_variable_get("@#{p}".to_sym) }).to_h
+    end
+
+    def with(hash={})
+      return self if hash.empty?
+      self.class.new(**to_h.merge(hash))
+    end
+
+    def ==(other)
+      return false unless other.instance_of?(self.class)
+      equality_properties.all? do |p|
+        if %i(value xvalue yvalue).include?(p)
+          ValueComparison.new(self.public_send(p), other.public_send(p)).eql?
+        else
+          self.public_send(p) == other.public_send(p)
+        end
+      end
+    end
+
+    def ===(other)
+      name == other.name
+    end
+
+    def match(selector)
+      %i(name function description).any? do |property|
+        self.public_send(property) && self.public_send(property).match(selector)
+      end
+    end
+
+    def valuestats(value, show_avg: false)
+      value = [value].flatten
+      min, avg, max = value.min, value.avg.round(1), value.max
+      if show_avg
+        "[#{min};~#{avg};#{max}]"
+      else
+        "[#{min};#{max}]"
+      end
+    end
+
+    alias :eql? :==
+
+  end
+end

data/lib/ecu/labels/label_list.rb

@@ -0,0 +1,137 @@
+require_relative "festwert"
+require_relative "festwerteblock"
+require_relative "kennlinie"
+require_relative "kennfeld"
+require_relative "stuetzstellenverteilung"
+
+require_relative "label_list_comparison"
+
+require_relative "../interfaces/dcm/label_list"
+require_relative "../interfaces/lab/label_list"
+require_relative "../interfaces/a2l/label_list"
+require_relative "../interfaces/mfile/label_list"
+
+require "set"
+require_relative "../../core_ext"
+
+class Ecu
+  class LabelList
+    include Enumerable
+
+    def self.from_file(file_path)
+      case File.extname(file_path)
+      when ".lab" then self.from_lab(File.read_encoded(file_path))
+      when ".a2l" then self.from_a2l(File.read_encoded(file_path))
+      else fail "Unknown file extension: #{file_path}!"
+      end
+    end
+
+    def self.labelclasses
+      [
+        Festwert,
+        Festwerteblock,
+        Kennlinie,
+        Kennfeld,
+        Stuetzstellenverteilung
+      ]
+    end
+
+    def initialize(labels=[], headers=[], subheaders=[], safe=false)
+      unless safe
+        names = labels.map(&:name)
+        if names.uniq.size != names.size
+          duplicates = names.select { |name| names.count(name) > 1 }.uniq
+          fail ArgumentError,
+            "Label list must not contain duplicates: #{duplicates.join(", ")}"
+        end
+      end
+      @labels     = labels
+      @headers    = headers
+      @subheaders = subheaders
+    end
+
+    attr_accessor :headers, :subheaders
+
+    def <<(label)
+      unless self.class.labelclasses.any? { |klass| label.is_a?(klass) }
+        fail ArgumentError, "Can only add recognised labels"
+      end
+      if self.map(&:name).include? label.name
+        fail ArgumentError, "Cannot add duplicate labels"
+      end
+      @labels << label
+    end
+
+    def ==(other)
+      @labels.all? do |label|
+        other.find { |l| l == label }
+      end
+    end
+
+    def each(&blk)
+      @labels.each(&blk)
+    end
+
+    def map_int(&blk)
+      self.class.new(@labels.map(&blk), @headers, @subheaders)
+    end
+
+    def select(&blk)
+      self.class.new(@labels.select(&blk), @headers, @subheaders)
+    end
+
+    def reject!(&blk)
+      @labels.reject!(&blk)
+    end
+
+    def reject(&blk)
+      self.class.new(@labels.reject(&blk), @headers, @subheaders)
+    end
+
+    def delete_if(&blk)
+      @labels.delete_if(&blk)
+    end
+
+    def group_by(&blk)
+      @labels.group_by(&blk).map { |k, v| [k, self.class.new(v)] }.to_h
+    end
+
+    def sort_by(&blk)
+      self.class.new(@labels.sort_by(&blk), @headers, @subheaders)
+    end
+
+    def merge(other)
+      LabelListComparison.new(self, other).merge(priority: :right)
+    end
+
+    def merge!(other)
+      merged      = merge(other)
+      @labels     = merged.to_a
+      @headers    = merged.headers
+      @subheaders = merged.subheaders
+    end
+
+    def +(other); merge(other) end
+
+    def to_a
+      @labels
+    end
+
+    def empty?
+      @labels.empty?
+    end
+
+    def contains?(name)
+      map(&:name).include?(name)
+    end
+
+    def to_s
+      "[#{@labels.map(&:to_s).join(", ")}]"
+    end
+
+    def size; count end
+
+    def inspect; to_s end
+
+  end
+end

data/lib/ecu/labels/label_list_comparison.rb

@@ -0,0 +1,65 @@
+class Ecu
+  class LabelListComparison
+
+    def initialize(left, right)
+      unless left.is_a?(LabelList) && right.is_a?(LabelList)
+        fail "Can only merge LabelLists (left: #{left.class}, right: #{right.class})!"
+      end
+
+      @left               = left.map(&:name).zip(left).to_h
+      @right              = right.map(&:name).zip(right).to_h
+      @unified_headers    = left.headers + right.headers
+      @unified_subheaders = left.subheaders + right.subheaders
+      @names              = Hash.new
+    end
+
+    def names(criterion)
+      @names[criterion] ||= \
+        case criterion
+        when :left_exclusive  then left.keys - right.keys
+        when :right_exclusive then right.keys - left.keys
+        when :common          then left.keys & right.keys
+        when :nonequal        then names(:common).select { |n| left.fetch(n) != right.fetch(n) }
+        when :equal           then names(:common).select { |n| left.fetch(n) == right.fetch(n) }
+        else fail "Unknown criterion #{criterion}"
+        end
+    end
+
+    def left_exclusive
+      names(:left_exclusive).map { |name| left.fetch(name) }
+    end
+
+    def right_exclusive
+      names(:right_exclusive).map { |name| right.fetch(name) }
+    end
+
+    def differences
+      names(:nonequal).map { |name| [ left.fetch(name), right.fetch(name) ] }
+    end
+
+    def merge(priority: :right)
+      labels = []
+      left.each do |name, label|
+        if names(:common).include?(name) && priority == :right
+          labels << right.fetch(name)
+        else
+          labels << left.fetch(name)
+        end
+      end
+      right.each do |name, label|
+        next if labels.map(&:name).include?(name)
+        if names(:common).include?(name) && priority == :left
+          labels << left.fetch(name)
+        else
+          labels << right.fetch(name)
+        end
+      end
+      LabelList.new(labels, @unified_headers, @unified_subheaders)
+    end
+
+    private
+
+    attr_reader :left, :right
+
+  end
+end

data/lib/ecu/labels/stuetzstellenverteilung.rb

@@ -0,0 +1,65 @@
+require_relative "label"
+
+class Ecu
+  class Stuetzstellenverteilung < Label
+
+    attr_reader :xdim, :xvalue, :xunit
+
+    def initialize(name:,
+                   xdim:,
+                   xvalue:,
+                   xunit: nil,
+                   function: nil,
+                   description: nil)
+      @name        = name
+      @xdim        = xdim
+      @xvalue      = xvalue
+      @xunit       = xunit
+      @function    = function
+      @description = description
+
+      init_error "Dimensions for xvalue don't match xdim" if xvalue.size != xdim
+    end
+
+    def round_to(n)
+      return self unless xvalue.all? { |x| x.is_a?(Numeric) }
+      self.with \
+        xvalue: xvalue.map { |x| x.round(n) }
+    end
+
+    def bytesize
+      xdim * BYTESIZE[:number]
+    end
+
+    def to_s(detail: false)
+      if detail == :value
+        "#{name}:\n#{to_s(detail: :justvalue)}"
+      elsif detail == :justvalue
+        ValuePrinter.call(self)
+      elsif detail == :onelinefull
+        "#{name} #{to_s(detail: :oneline)}"
+      elsif detail == :oneline
+        "(#{xdim}x1) X: #{valuestats(xvalue)}"
+      else
+        "#{name}: #{@xdim}x1 #{type}".tap do |str|
+          if detail
+            str << "\n"
+            str << "  Unit: \"#{xunit}\"\n"
+            str << "  Value:\n"
+            str << ValuePrinter.call(self).indent(4)
+            str << "\n"
+          end
+        end
+      end
+    end
+
+    def properties
+      [:name, :xdim, :xvalue, :xunit, :function, :description]
+    end
+
+    def equality_properties
+      [:name, :xvalue]
+    end
+
+  end
+end