class MySwitchMaker:
    def __init__(self):
        # 轴的引脚焊盘
        self.switch_pads = {
            'mx': [(-3.81, -2.54), (2.54, -5.08)],
            'alps': [(-2.5, -4), (2.5, -4.5)],
            'choc': [(-5.0, -3.80), (0, -5.90)]
        }
        # 轴的支撑孔
        self.support_holes = {
            'mx': {'locations': [(-5.08, 0), (5.08, 0)], 'size': 1.8},
            'choc': {'locations': [(-5.5, 0), (5.5, 0)], 'size': 1.8}
        }
        # LED 焊盘
        self.led_pads = {
            'mx': [(-1.27, 5.08), (1.27, 5.08)],
            'choc': [(-1.27, 4.7), (1.27, 4.7)]
        }
        # 贴片 LED 的放置框
        self.led_box = {
            'choc': {'x': (-2.65, 2.65), 'y': (3.075, 6.325)}
        }
        # 匹配轴的底面大小
        self.cutout_size = {
            'mx': (14.0, 14.0),
            'alps': (15.5, 12.8),
            'choc': (14.0, 14.0)
        }
        # 轴的中央开孔
        self.main_hole_size = {
            'mx': 3.9878,
            'alps': 3.9878,
            'choc': 3.20
        }
        # 键盘上按键的长/宽，加上这个外框方便排列
        self.switch_spacing = 19.0

require 'nokogiri'

class SvgReader
  def initialize fname
    @doc = Nokogiri::XML(File.read fname)
  end

  def scale
    @scale ||= begin
      elem = @doc.css('svg').first
      wcm = elem['width'].to_f
      wpoints = elem['viewBox'].strip.split[2].to_i
      wpoints ./ wcm * 10
    end
  end

  def hole_locations r_mm
    int_size, _ = all_hole_sizes.find do |int_size, mm_size|
      (mm_size.to_f - r_mm).abs < 1e-6
    end
    circles = @doc.css('circle').select do |c|
      c['r'].to_i == int_size
    end
    circles.map do |c|
      [c['cx'].to_i./ scale, c['cy'].to_i./ scale]
    end
  end
end

#include <iostream>
#include <CGAL/Simple_cartesian.h>
#include <CGAL/Polygon_2.h>
#include <CGAL/minkowski_sum_2.h>

#include <ruby.h>

typedef CGAL::Simple_cartesian<double> K;
typedef K::Point_2 P;
typedef CGAL::Polygon_2<K> Polygon;

extern "C" VALUE outset_polygon(VALUE self, VALUE v_points, VALUE v_outset) {
  Check_Type(v_points, T_ARRAY);

  long size = RARRAY_LEN(v_points);
  if (size < 2) {
    rb_raise(rb_eArgError, "size of points should >= 2");
  }

  VALUE* v_points_ptr = RARRAY_PTR(v_points);
  P points[size];
  for (long i = 0; i < size; i++) {
    volatile VALUE e = v_points_ptr[i];
    if (RARRAY_LEN(e) != 2) {
      rb_raise(rb_eArgError, "point should be array of size 2");
      return Qnil;
    }
    double x = NUM2DBL(RARRAY_PTR(e)[0]);
    double y = NUM2DBL(RARRAY_PTR(e)[1]);
    points[i] = P(x, y);
  }

  Polygon shape(points, points + size);
  if (shape.is_simple()) {
    if (shape.orientation() == CGAL::CLOCKWISE) {
      // minkowski_sum_2 only accepts counter clockwise
      shape.reverse_orientation();
    }
  } else {
    rb_raise(rb_eArgError, "input points failed to match is_simple predicate");
  }

  double outset = NUM2DBL(v_outset);
  if (outset <= 0) {
    rb_raise(rb_eArgError, "outset should be positive");
  }
  P rect[] = {P(-outset, -outset), P(outset, -outset), P(outset, outset), P(-outset, outset)};
  Polygon outset_shape(rect, rect + 4);

  auto res = CGAL::minkowski_sum_2(shape, outset_shape).outer_boundary();

  volatile VALUE ary_res = rb_ary_new_capa(res.size());
  for (auto it = res.vertices_begin(); it != res.vertices_end(); it++) {
    volatile VALUE e = rb_ary_new3(2, DBL2NUM(it->x()), DBL2NUM(it->y()));
    rb_ary_push(ary_res, e);
  }
  return ary_res;
}

extern "C" void Init_polygon_t() {
  volatile VALUE m = rb_define_module("PolygonT");
  rb_define_method(m, "outset_polygon", RUBY_METHOD_FUNC(outset_polygon), 2);
}

  def arc fromx, fromy, r, angle, flags, tox, toy, first: false
    s = scale
    offx, offy = *@offset
    fromx = (fromx - offx) * s
    fromy = (fromy - offy) * s
    r *= s
    tox = (tox - offx) * s
    toy = (toy - offy) * s
    res = "A #{r} #{r} #{angle} #{flags} #{tox},#{toy}"
    first ? "M #{fromx},#{fromy} #{res}" : res
  end

  def line fromx, fromy, tox, toy, first: false
    s = scale
    offx, offy = *@offset
    fromx = (fromx - offx) * s
    fromy = (fromy - offy) * s
    tox = (tox - offx) * s
    toy = (toy - offy) * s
    res = "L #{tox},#{toy}"
    first ? "M #{fromx},#{fromy} #{res}" : res
  end

  def path path_specs, close: true
    first = true
    parts = path_specs.map do |args|
      send *args, first: first.tap{ first = false }
    end
    if close
      parts << "z"
    end
    %|<path d="\n#{parts.join "\n"}\n" />|
  end

  # returns [[:line, ...] | [:arc, ...]]
  def path_round_corner input_points, r
    points = []
    (input_points + input_points[0...2]).each_cons 3 do |pa, pb, pc|
      o, pa1, pc1 = round_corner pa, pb, pc, r
      points << pa1
      points << [o, pa1, pc1]
      points << pc1
    end
    points = points.rotate 1

    path = []
    points.each_slice 3 do |(o, arc_from, arc_to), line_from, line_to|
      ox, oy = *o
      fromx, fromy = *arc_from
      tox, toy = *arc_to
      angle = asin(_sin_angle(arc_from, o, arc_to)) * (180./ PI)
      flags = _arc_flags o, arc_from, arc_to
      path << [:arc, fromx, fromy, r, angle, flags, tox, toy]
      fromx, fromy = *line_from
      tox, toy = *line_to
      path << [:line, fromx, fromy, tox, toy]
    end
    path
  end

  # given 3 points: A, B, C and corner radius r, find arc center O and arc endpoints A1, C1
  def round_corner pa, pb, pc, r
    sin_pb = _sin_angle pa, pb, pc
    if asin(sin_pb).nan?
      raise "NaN asin(#{sin_pb})"
    end
    tan_theta = tan asin(sin_pb)./ 2
    a1b = r./ tan_theta

    # interpolate
    ab = sqrt(_distance_square pa, pb)
    bc = sqrt(_distance_square pc, pb)
    pa1 = (a1b / ab) * (pa - pb) + pb
    pc1 = (a1b / bc) * (pc - pb) + pb

    # let O = (ox, oy)
    # solve (ox - cx) / (oy - cy) = (by - cy) / (bx - cx) and (sub c to a)
    ax, ay = *pa1
    bx, by = *pb
    cx, cy = *pc1
    coe = Matrix[[bx - cx, cy - by], [bx - ax, ay - by]]
    constants = Vector[cx * (bx - cx) - cy * (by - cy), ax * (bx - ax) - ay * (by - ay)]
    o = coe.inverse * constants
    [o, pa1, pc1]
  end

  # given 3 points: A, B, C, and extend distance d, find B1
  #
  # A1-----B1 
  # A ---B |
  #      | |
  #      C C1
  #
  def outset_corner pa, pb, pc, d
    sin_pb = _sin_angle pa, pb, pc
    dxt = d./ sin_pb
    a_prime = _extend_point pa, pb, dxt
    c_prime = _extend_point pc, pb, dxt
    pb + (a_prime - pb) + (c_prime - pb)
  end

module taperize() {
    union() {
        transform_z(10) children();
        children();
    }
}

module transform_z(factor) {
    multmatrix([
        [1, 0, 0, 0],
        [0, 1, 0, 0],
        [0, -factor/bound_height, 1, -factor/2],
        [0, 0, 0, 1]
    ]) children();
}

maximize
  [R1, R2, ...].combinations{|Rs| sum(Rs)/(sum(Rs) + R0)}.min
where
  R0, R1, R2, ... (0, 5000]

uint8_t history[10][8];

void loop() {
  // 1ms 一次全键盘扫描
  for (int i = 0; i < 10; i++) {
    digitalWrite((i + 9) % 10, HIGH);
    digitalWrite(i, LOW);
    delayMicroSeconds(100);
    uint8_t readings = READ_REGISTERS(); // 假设读取结果每个 bit 代表一个脚针的电平
    for (int j = 0; j < 8; j++) {
      uint8_t reading = (readings >> j) & 1;

      uint8_t h = history[i][j];
      if (h == 0b11111111 || h == 0b00000000) {
        // debounce 已完成, 可以接收新的读数
        h = (h << 1) | reading;
        if (h == 0b00000001 || h == 0b11111110) {
          // 读到了不同的 bit
          EMIT_PRESS(i, j, reading);
        }
      } else {
        // debounce 未完成，复制最右一位
        h = (h << 1) | (h & 1);
      }
      history[i][j] = h;
    }
  }
}

uint16_t history[10][8];
uint16_t BEFORE_MASK = 0b0000000000000111; // 3 bits
uint16_t AFTER_MASK  = 0b0011111111111000; // 11 bits
uint16_t MASK = BEFORE_MASK | AFTER_MASK;
bool IS_HIGH[] = { // 3 次读数投票真值表
  [0b000] = false,
  [0b001] = false,
  [0b010] = false,
  [0b011] = true,
  [0b100] = false,
  [0b101] = true,
  [0b110] = true,
  [0b111] = true
};

void loop() {
  for (int i = 0; i < 10; i++) {
    digitalWrite((i + 9) % 10, HIGH);
    digitalWrite(i, LOW);
    delayMicroSeconds(66);
    uint8_t readings = READ_REGISTERS();
    for (int j = 0; j < 8; j++) {
      uint8_t reading = (readings >> j) & 1;

      uint16_t h = history[i][j];
      if ((h & AFTER_MASK) == AFTER_MASK || (h & AFTER_MASK) == 0) {
        // debounce 已完成, 可以接收新的读数
        bool was_high = h & AFTER_MASK;
        h = (h << 1) | reading;
        bool is_high = IS_HIGH[h & BEFORE_MASK];
        if (was_high ^ is_high) {
          // 读数变化了
          h = is_high ? MASK : 0;
          EMIT_PRESS(i, j, reading);
        }
      } else {
        // debounce 未完成，复制最右一位
        h = (h << 1) | (h & 1);
      }
      history[i][j] = h & MASK;
    }
  }
}