Microfluidic device design.

Comments

• Matthias

  January 15

  @Jamboneil I did not know that there such a thing as a ultra hi-res printer ... do you have some more details about this?

  Anyway, I wrote a STL producer script myself some time ago - although for low-res printing It can take layers from a layout and stack the layers with a given height for each layer and export the result to STL. The script is actually very simple.

  Problem is: it will work only with a future version of KLayout which is not released yet. I noticed that most Slicing tools need a quality tesselation, so it came handy I included a Delaunay triangulator in KLayout. Only with that, the slicers I am using were able to process my STLs without crashing.

  I can provide a preview version soon I hope.

  Matthias
• Jamboneil

  January 16

  Hi Matthias, Thanks for replying.
  The 3D printer is here... https://www.nanoscribe.com/en/products/photonic-professional-gt2/

  Not exactly a home or hobby machine at around 500K Euros but very cool.

  kLayout is great for designing the microfluidics but making them is tricky as the pattern needs to be transfered in to SU-8 resin. This is no problem with resin thicknesses of up to 100µm but very difficult in thicknesses of 200µm which is what I'm trying to do.
  The slicing software for the nanoscribe will not accept any 2d files so I have to figure out a way of giving them some height and then converting them to stl format.

  Neil
• Matthias

  January 18 edited January 18

  Understood and thanks for the link!

  Give me a little time for the grown-up KLayout version that supports quality tessellation.

  For now, KLayout can offer trapezoid decomposition which in my experience can be digested in many cases but some slicers choke on small slivers.

  Here is a script I used myself. It needs to be executed as DRC (!) script. Please see the comments for details. It is made of a generic class and a small payload part that demonstrates how to use it:

  
  # A KLayout DRC (+ extensions) script which supports
  # printing of DRC-generated layers to STL.
  
  
  # The STL producer class
  # 
  # Usage
  # 
  # 1. Instantiate STLProducer
  # 2. Register Region or DRC::Layer objects with z information with register
  # 3. Call emit to write the STL file
  # 
  # Units: µm are turned into mm
  
  class STLProducer
  
    def initialize(dbu)
      @name = nil
      @file = nil
      @stack = []
      @dbu = dbu
    end
  
    def dbu
      @dbu
    end
  
    def emit(path)
      open(path)
      write
      finish
    end
  
    def register(z, height, data)
      if data.respond_to?(:data)
        data = data.data
      end
      if !data.is_a?(RBA::Region)
        raise("Expected a RBA::Region or DRC::Layer object for data argument in STLProducer#register")
      end
      # We calculate with 1/prec unit to have integers
      @stack << [ (z.to_f / dbu + 0.5).floor, ((z.to_f + height.to_f) / dbu + 0.5).floor, data ]
    end
  
  private
  
    def open(path)  
      @name = File.basename(path)
      @file = File.open(path, "w")
      @file.puts("solid " + @name)
    end
  
    def write
  
      z_values = (@stack.collect { |s| s[0] } + @stack.collect { |s| s[1] }).sort
      if z_values.size < 2
        return
      end
  
      data_sets = z_values.collect do |z|
        @stack.select { |s| s[0] <= z && s[1] > z }.collect { |s| s[2] }
      end
  
      data_before = RBA::Region::new
      data = nil
      (z_values.size - 1).times do |i|
  
        if !data
          data = data_sets[i]
          data = data.empty? ? RBA::Region::new : data.inject(:+).merged
        end
  
        data_after = data_sets[i + 1]
        data_after = data_after.empty? ? RBA::Region::new : data_after.inject(:+).merged
  
        z1 = z_values[i]
        z2 = z_values[i + 1]
  
        write_layer(data_before, data, data_after, z1, z2)      
  
        data = data_after      
        data_before = data
  
      end
  
    end
  
    def write_layer(data_before, data, data_after, z, zz)
  
      # vertical wall
      data.each do |poly|
        poly.each_edge do |e|
          emit_quadrangle(
            [ e.p1.x * dbu, e.p1.y * dbu, zz * dbu ],
            [ e.p2.x * dbu, e.p2.y * dbu, zz * dbu ],
            [ e.p2.x * dbu, e.p2.y * dbu, z * dbu ],
            [ e.p1.x * dbu, e.p1.y * dbu, z * dbu ]
          )
        end
      end
  
      # bottom new    
      fracture(data - data_before).each do |s|
        v = s.each_point_hull.collect do |p|
          [ p.x * dbu, p.y * dbu, z * dbu ]
        end
        emit_array(v)
      end
  
      # bottom removed    
      fracture(data_before - data).each do |s|
        v = s.each_point_hull.collect do |p|
          [ p.x * dbu, p.y * dbu, z * dbu ]
        end
        v.reverse!
        emit_array(v)
      end
  
      # top new    
      fracture(data_after - data).each do |s|
        v = s.each_point_hull.collect do |p|
          [ p.x * dbu, p.y * dbu, zz * dbu ]
        end
        emit_array(v)
      end
  
      # top removed    
      fracture(data - data_after).each do |s|
        v = s.each_point_hull.collect do |p|
          [ p.x * dbu, p.y * dbu, zz * dbu ]
        end
        v.reverse!
        emit_array(v)
      end
  
    end
  
    def fracture(data)
      if data.respond_to?(:delaunay)
        data.delaunay
      else
        # KLayout <0.29 uses trapezoid decomposition
        data.decompose_trapezoids_to_region
      end
    end
  
    def emit_triangle(v1, v2, v3)
      @file.puts("facet normal 0 0 0")
      @file.puts("    outer loop")
      @file.puts("        vertex %.12g %.12g %.12g" % v1)
      @file.puts("        vertex %.12g %.12g %.12g" % v2)
      @file.puts("        vertex %.12g %.12g %.12g" % v3)
      @file.puts("    endloop")
      @file.puts("endfacet")
    end
  
    def emit_quadrangle(v1, v2, v3, v4)
      emit_triangle(v1, v2, v3)
      emit_triangle(v3, v4, v1)
    end
  
    def emit_array(v)
      if v.size == 4
        emit_quadrangle(*v)
      elsif v.size == 3
        emit_triangle(*v)
      end
    end
  
    def finish
      @file.puts("endsolid " + @name)
      @file.close
    end
  
  end
  
  
  
  # A sample use case
  
  stl_producer = STLProducer::new(1.dbu)
  
  l1 = input(1, 0)
  l2 = input(2, 0)
  l3 = input(3, 0)
  
  # Create a layer of 2µm height (z=0, 2µm thickness) from "(l1 OR l2) NOT l3"
  stl_producer.register(0, 2.0, l1 + l2 - l3)
  
  # Stack l2 atop at z=+2µm with thickness 1µm
  stl_producer.register(2.0, 1.0, l2)
  
  # writes the output (TODO: change name)
  stl_producer.emit("/home/matthias/test.stl")
  

  With the following layout:

  

  this STL is produced:

  

  and it prints (on mm scale)

  

  (well, the A and O inner pieces fell out, because I did not connect them ...)

  Matthias
• nmz787_intel

  January 23

  There's also:
  https://github.com/dteal/gdsiistl

  though maybe Matthias' method avoids the potential issue that the Github repo calls out in this "NOTE":

  Due to a limitation of the library used to triangulate the polygonal boundaries of the GDSII geometry, the polygon borders (i.e., all geometry) are shifted slightly (by a hardcoded delta of about 0.01 units, or 10 nanometers in standard micron units) before export. Furthermore, due to another related limitation/bug (not yet completely understood; see source code comments), extra triangles are sometimes created covering holes in polygons.
  
  So the output mesh is not guaranteed to be watertight, perfectly dimensioned, or retain all polygon holes, but it should be arbitrarily close and err on the side of extra triangles, so a program (e.g., Blender) can edit the mesh by deleting faces and produce a negligibly-far-from perfect visualization.