Mike Tyka, PhD

Calcium Carbonate to store CO₂ ?

Thu, 01 Jul 2021 00:00:00 +0000

The earth’s oceans contain a great deal of dissolved inorganic carbon (DIC) and a decent concentration of calcium (about 10mM). Furthermore the ocean has a huge surface area and is able to take up large quantities of CO₂ from the atmosphere. It is thus sometimes suggested that inducing precipitation of calcium carbonate (CaCO₃) from seawater could be a viable method to lock down carbon into a solid form, which could then be safely and easily stored somewhere. The thought is that removing carbonate from the ocean would subsequently cause it to absorb more CO₂ from the atmosphere.

Unintuitively, it turns out that this is not the case due to the way in which the ocean carbon chemistry works. Paradoxically, the exact opposite is true - precipitation of CaCO₃ in the ocean releases CO₂ to the atmosphere - how can this be ? This fallacy appears frequently enough, surprisingly sometimes even in peer reviewed papers ¹ᐧ ² ⁴

or startups

³, that it bears illuminating.

Inorganic carbon in the ocean

Most gases like O₂ or N₂ are not all that soluble in water because water is a polar liquid and these small molecules are non-polar. At first glance CO₂ might be thought to behave similarly, after all it’s not particularly polar. However, when CO₂ dissolves in water it can react with a hydroxyl ion to form a bicarbonate ion.

CO₂ + OH⁻  → HCO₃⁻

The bicarbonate ion can further react with another hydroxyl ion to form a carbonate ion.

HCO₃⁻ + OH⁻  → CO₃²⁻

^{(These reactions are often written as between CO₂ and water, releasing protons, but for
illustration purposes i think it’s more instructive to think of it the above way.)}

The key is that unlike CO₂ these carbonate ions are charged and tremendously soluble in water.

In pure water the availability of hydroxyl ions is very small, available only from the small amount of water that is always dissociated into H⁺ and OH⁻. Any CO₂ that dissolves from the air quickly reacts with the available OH⁻ and the subsequent imbalance of H⁺ and OH⁻ results in the solution to become acidic. This makes the availablity of OH⁻ even smaller and opposes further reaction. Thus the solubility of CO₂ in pure water is not much greater than that of other simple gases like O₂ or N₂, which do not react with water. How could we increase the ability of water to absorb CO₂ ? Simple: supply more OH⁻ ions that can gobble up CO₂ and turn it into bicarbonate, in other words, make the water more alkaline. This excess quantity of hydroxyl ions, which can react with CO₂, is called the water’s “alkalinity”. Thus the most basic way to express a quantifiable alkalinity is

Alk = [HCO₃⁻] + 2×[CO₃²⁻] + [OH⁻] + ...

This reflects both the excess OH⁻ that has already reacted with CO₂ into bicarbonate/carbonate ions (first two terms) and any free OH⁻ that is still available to react (third term). This quantity effectively respresents the capacity of a body of water to absorb CO₂, irrespective of how much CO₂ it has currently taken up. Alkalinity is a complicated concept and a full expression includes a number of other weak bases, but the carbonate ions are typically the most important and this simplified view is sufficient to understand carbonate precipitation.

Seawater contains a large quantity of alkalinity, which originates from dissolving alkaline rocks, which flows into the sea with the rivers. This alkalinity allows seawater to hold a huge quantity of CO₂; in fact the total quantity of CO₂ dissolved in the ocean (37000GtC) is 45 times greater than in the atmosphere (840GtC). Most of it is, of course, in the form of bicarbonate (89%) and carbonate ions (10%). Only a tiny fraction (0.5%) is dissolved as actual CO₂, like an ordinary gas.

Precipitating carbonates

To understand why precipitating carbonates lead to the release of CO₂ into the atmosphere, let’s look at the precipitation of CaCO₃. The reaction can be written in a number of ways, but they all result in the same outcome: Lets try one line of argument: Since most of the available carbonates are in the bicarbonate form (HCO₃⁻) one way to write the precipitation is :

 Ca²⁺ + 2HCO₃⁻ → CaCO₃ + CO₂ + H₂O

You can immediately see that for every CaCO₃ created, one CO₂ is moved from the carbonate pool (highly soluble) to the gas form (poorly soluble), and is thus released back into the atmosphere.

Another way to think about it is to ask “what would we need to do to restore the ocean to its prior state after precipitating a CaCO₃ ?” First, we precipitate the CaCO₃:

 Ca²⁺ + CO₃²⁻ → CaCO₃

Now, let’s restore the used-up CO₃²⁻ by bringing in a CO₂ from the atmosphere:

 CO₂ + 2OH⁻ → CO₃²⁻ + H₂O

You can see that doing so requires us to add two OH⁻ back to the ocean, in addition to the CO₂. (We won’t worry here about changes in the Ca²⁺ concentration). In other words a process that removes calcium carbonate from the ocean in a pH-neutral way needs to replenish the alkalinity from somewhere. If not, we will decrease the oceans capacity to store CO₂ by two units (we used up two OH⁻), for every one unit carbon we’ve precipitated. Since we’ve only removed one mol of carbon from the ocean, another unit of carbon will be released to the atmosphere.

Making alkalinity

Ok, but what if we generated new OH⁻ (i.e. alkalinity) in some way (for example using electrochemistry, like the Chlor Alkali process or by mining alkaline minerals) - could we use those to precipitate CaCO₃ and lock down CO₂ ? Yes, absolutely that would work. For every two moles of OH⁻ you could lock down one mol of carbon:

 Ca²⁺ + CO₂ + 2OH⁻ → CaCO₃ + H₂O

But, wait! There’s an even better thing you could do. You could simply add the alkalinity to the ocean and not precipitate any calcium carbonate. As we discussed earlier that would raise the oceans capacity to absorb CO₂ by two moles! Now you’re getting twice the bang for your buck: every mol of OH⁻ pulls down one mol of carbon! (actually the true number is a little lower, about 0.85 or so, for complicated reasons we won’t go into here). Why ? Because in the ocean most of the carbon is stored as bicarbonate instead of carbonate, and to convert a CO₂ to HCO₃⁻ you only need one OH⁻:

 CO₂ + OH⁻ → HCO₃⁻

Note that storing CO₂ in the ocean this way doesn’t acidify the ocean, since we have added the necessary alkalinity to go with it. There are many research proposals out there looking at the various ways to add alkalinity to the ocean to counteract it’s acidification and provide capacity to store the excess CO₂ in a pH neutral way. To learn more, this is a good place to start: Assessing ocean alkalinity for carbon sequestration

Syringe pump & pH stat

Sat, 13 Mar 2021 00:00:00 +0000

For an experiment I wanted to measure how quickly certain alkaline minerals, such as Mg(OH)₂ or MgSiO4 dissolve in seawater under constant pH. For a large enough volume of water this is a reasonable assumption but I needed to do it in a small volume. That would require the use of a tiny amount of Mg(OH)₂ and that would make it rather noisy to measure. However using a larger quantity doesn’t work because dissolving Mg(OH)₂ releases OH- ions and thus increases the pH, which significantly slows further dissolution. So I decided to use a pH-stat which would inject a tiny amount of HCl if the pH increased above the set point (8.1 in my case). The rate at which HCl was injected would then be directly proportional to the amount of Mg(OH)₂ that had dissolved. This means the injector needs to keep very accurate account of the amount of HCl dispensed.

To build a simple pH stat I used a syringe (30ml) mounted on a linear motor connected to a controller driven by a Raspberry Pi. The controller also has a pH electrode. This way the code on the Pi can run the control loop and actuate the linear motor whenever the pH increases while also keeping track of the exact movement of the motor and hence the exact quantity of HCl dispensed.

The design was as follows:

Computer controller

A Raspberry Pi B+ as the central coordinating unit which will read from the pH probe and determine the syringe movements. Since I wanted log files and a full Unix system this was a preferred choice over using a Arduino or similar smaller microcontroller, though that’s a viable alternative. Critical are an I2C port for communication with the pH probe, 2 GPIO outputs for stepping and direction control and two input GPIOs for the limit switches. Optional are additional GPIOs to dynamically set the step size (substepping).

pH Measurement

The pH electrode was purchased from Atlas Scientific (Gen 3 Lab Grade pH Probe )
The pH probe amp/ADC was also from Atlas Scientific ( EZO™ pH Circuit ) together with their carrier board (Electrically Isolated EZO™ Carrier Board ) which provides electrical isolation. These boards are addressable via I2C and can be essentially connected directly to the relevant pins on the Raspberry Pi. The board provides all the pH measurement and calibration commands necessary, via I2C.

The syringe assembly

A linear rail stepper motor. This is the one I used: 100mm Linear Actuator NEMA 11 (NEMA11) It works just like any stepper motor. This particular one wants 24V but your can actually drive it with 12V also, it just has less power. The length was determined by the length of the travel of the syringe, plus some extra.
A syringe. In version one I used a regular 30ml syringe with a Luer lock. From there I attached a short Luer to Luer extension tube (about 10cm) and then to a Luer lock dispenser needle. However I found that the plastic syringe and rubber plunger have too much internal flexibility and backlash and non linear response was a serious problem. So I ended up redesigning it with a 30ml glass syringe.
Some 3D printed parts to hold the syringe, the plunger and the limit switches in place. These have to be designed specific to the linear motor and the exact syringe used, but it is relatively straight forward to do in a CAD editor like OnShape.

Here’s a closeup of the syringe mounted in the holder.

The STEP files for the assembly are here: Syringe Holder.step
Two limit switches at either side of the linear stepper motod caddy, which signal back to the Pi that the end of the travel was reached. These receive 3V power from the Pi and then connect in series back to the Pi to a GPIO input pin. For visual confirmation I also added an LED via a resistor to ground, the Pi GPIO pins can sink supply current to drive these directly without a transistor.
To drive the motor I used a DRV8825 High Current Stepper Motor Driver Carrier. This board takes in 12V or 24V power and 3V logic signals for the direction and the steps. The four outputs are connected to the two coils inside the stepper motor. The STEP and DIRECTION pins are connected to GPIOs on the Pi and are driven directly by the code, since the precise speed/timing doesn’t matter so much as the precise control over the number of steps.

A PCB board to keep it all together.

This isn’t strictly necessary as most of the parts could just be wired together directly but I decided to to build a Raspberry Pi extension board with a GPIO header that would sit directly on top of the Pi and coordinate all the other elements. This has the advantage that everything is a lot neater and not as brittle, with patch wires running everywhere. The ciruit is quite simple:

The board hosts the DRV8825. Pins VMOT is connected to the 12V or 24V motor power supply (and 100uF cap to ground). Pins B1, B2 and A1, A2 connect to the coild on th emotor. Which pair is connected to which coil will determine the direction but that’s easily switchable in software so it doesn’t matter at assembly time. Pin DIR sets the direction, set to high mean one way, set to low means the other way. This is directly connected to the header on GPIO21. The pin STEP drives the motor. Every rising edge on this pin steps the motor one step or microstep. The pins MS1-3 set the microstep size. In this case I chose the finest microstepping available, 1/32 steps, by setting all three pins to high. Howevver to keep things configurable later i decided to provide the setting both by jumpers on the board but also by GPIO output pins in case I later decided I needed to change things dynamically.

The board also has a barrel plug for the 12V/24V supply and an 8 pin connector to go to the linear motor.

I designed a board on EasyEDA and had it manufactured. The Gerber files for the PCB are downloadable here:

<a href=”“/assets/syringepump/syringepump_gerber.zip”>[Gerber ZIP file]</a>

After soldering everything together the whole assembly looked like this:

Final assembly

Putting it all together on an acrylic lasercut board:

Software

Below is some example code on how to drive the syringe. The VOLUME_PER_STEP constant has to be determined empirically. To do this accurately I’d let the motor draw a full syringe of distilled water, and then dispense virtually all the liquid into a preweighed beaker. I can then weigh on a precision scale again and divide the number of steps taken. Distilled water is pretty damn close to a density of 1 so that was good enough for me. For an even more accurate volume determination one could calibrate the density of the water with a precision bulb pipette. The AtlasI2C library can be obtained from their website.

#!/usr/bin/python3
from time import sleep
import RPi.GPIO as GPIO
import time
from AtlasI2C import AtlasI2C
from threading import Thread

DIR =  9   # Direction GPIO Pin
STEP = 10  # Step GPIO Pin
FORWARD_STOP = 25   # Limit switch forward GPIO Pin
BACKWARD_STOP = 24  # Limit switch backward GPIO Pin
STOP = [BACKWARD_STOP, FORWARD_STOP]
FORWARD = 1     # Clockwise Rotation
BACKWARD = 0    # Counterclockwise Rotation
SPR = 48   # Steps per Revolution (360 / 7.5)

## Glass 30ml syringe
# This must be measured empirically
VOLUME_PER_STEP = 6.277352941E-8 # Liters per microstep

GPIO.setmode(GPIO.BCM)
GPIO.setup(DIR, GPIO.OUT)
GPIO.setup(STEP, GPIO.OUT)
GPIO.setup(FORWARD_STOP, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(BACKWARD_STOP, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.output(DIR, FORWARD)

_pump_pwm_speed = 0.0
_pump_pwm_thread_active = False
_pump_pwm_thread = None
_pump_pwm_count = 0
_pump_pwm_mask = 1

def _ph_thread_call():
  global _pump_pwm_speed,_pump_pwm_thread_active,_pump_pwm_count
  while _pump_pwm_thread_active:
    now_time = time.time()
    direct =  1 if _pump_pwm_speed>0 else 0
    step   =  1 if _pump_pwm_speed>0 else -1
    GPIO.output(DIR, direct)
    if abs(_pump_pwm_speed) < 0.001:
      sleep(0.1)
      continue

    if GPIO.input(STOP[direct]):
      continue

    delay = max(0,abs(0.5/_pump_pwm_speed) - 0.0000855)
    block = max(1,min(int(_pump_pwm_speed//10), 10))
    for i in range(block):
      #print("[EDGE] block=",block, " t=",time.time())
      GPIO.output(STEP, _pump_pwm_mask*GPIO.HIGH)
      sleep(delay)
      GPIO.output(STEP, _pump_pwm_mask*GPIO.LOW)
      sleep(delay)
    _pump_pwm_count += block*step

def start_pump_pwm_thread():
  global _pump_pwm_thread, _pump_pwm_thread_active
  _pump_pwm_thread_active = True
  _pump_pwm_thread = Thread(target=_ph_thread_call)
  _pump_pwm_thread.start()

def stop_pump_pwm_thread():
  global _pump_pwm_thread, _pump_pwm_thread_active
  if _pump_pwm_thread_active:
    _pump_pwm_thread_active = False
  _pump_pwm_thread.join()

def set_pump_pwm(rate):
  global _pump_pwm_speed
  _pump_pwm_speed = min(5000,rate)
  #print("Set rate to : ", _pump_pwm_speed)

def get_pump_position():
  return _pump_pwm_count

def set_pump_dry_run(dry_run):
  global _pump_pwm_mask
  if dry_run: _pump_pwm_mask = 0
  else: _pump_pwm_mask = 1

def blocking_move_steps(steps, speed):
  pump_pwm_count = 0
  while pump_pwm_count < steps:
    now_time = time.time()
    GPIO.output(DIR, direct)
    delay = max(0,abs(0.5/speed) - 0.0000855)
    if GPIO.input(STOP[direct]):
      print("Hit backstop.")
      break
    block = max(1,min(int(speed//20), 10))
    for i in range(block):
        GPIO.output(STEP, GPIO.HIGH)
        sleep(delay)
        GPIO.output(STEP, GPIO.LOW)
        sleep(delay)
    pump_pwm_count += block
  return pump_pwm_count

#############################################
# Interface as command line tool 

def main():
  parser = argparse.ArgumentParser()
  parser.add_argument('cmd', help='command')
  parser.add_argument('--speed', type=float, default=2000, help='steps/s (1-4000)')
  parser.add_argument('--steps', type=int, default=1000000, help='')
  parser.add_argument('--volume', type=float, default=None, help='volume in ml')
  parser.add_argument('--threaded', action='store_true', help="Threaded mode is inaccurate in total number of steps, if speed is high")

  args = parser.parse_args()

  if args.cmd != "bwd" and args.cmd != "fwd":
    print("[cmd] must be 'bwd' or 'fwd'")

  direct =  1 if args.cmd == "fwd" else 0
  steps = args.steps
  if args.volume:
    steps = int(args.volume*1E-3 / VOLUME_PER_STEP)

  print("Going %d steps at speed %f steps/s... (Volume = %f.3ml)"%(steps, args.speed, 1E3*steps*VOLUME_PER_STEP))

  if args.threaded: # Asynchronous version
    start_pump_pwm_thread()
    set_pump_pwm(args.speed)
    while _pump_pwm_count < steps:
      time.sleep(0.05)
    stop_pump_pwm_thread()
    print("Final steps: ", _pump_pwm_count)

  else:             # Blocking version
    pump_pwm_count = blocking_move_steps(steps, args.speed):
    print("Final steps: ", pump_pwm_count)

  print("Done.")

if __name__ == '__main__':
  main()

pH measurement code

Below is example code which will take pH measurements from the pH electrode. On disadvantage of the Atlas measurement board is that it’s fairly slow. A measurement takes ~1s, which makes fast reaction tricky.

#!/usr/bin/python3
import time
from AtlasI2C import (
	 AtlasI2C
)
import argparse
from threading import Thread

def print_devices(device_list, device):
    for i in device_list:
        if(i == device):
            print("--> " + i.get_device_info())
        else:
            print(" - " + i.get_device_info())

def get_devices():
    device = AtlasI2C()
    device_address_list = device.list_i2c_devices()
    device_list = []
    print(device_address_list)
    for i in device_address_list:
        device.set_i2c_address(i)
        response = device.query("I")
        if response.startswith("Error"):
          continue
        moduletype = response.split(",")[1]
        response = device.query("name,?").split(",")[1]
        device_list.append(AtlasI2C(address = i, moduletype = moduletype, name = response))
    return device_list


# Background pH service (Seperate thread)
_pH_thread_active = False
_pH_thread = None
_pH_readings = []
_pH_reading_times = []

def _ph_thread_call(device, pH_finetune=0.0, callback=None):
  global _pH_readings, _pH_reading_times, _pH_thread_active
  while _pH_thread_active:
    now_time = time.time()
    try:
      pHstring = device.query("R")
    except IOError:
      print("PH query failed. IO Error")
      continue

    try:
      pH = float(pHstring.split(":")[-1].strip().strip('\x00')) + pH_finetune
    except ValueError:
      print("PH value invalid. ValueError")
      continue

    _pH_readings.append(pH)

    if callback: callback(pH)

def start_ph_thread(callback=None):
  global _pH_thread, _pH_thread_active
  device_list = get_devices()
  print(device_list)
  device = device_list[0]
  print_devices(device_list, device)
  _pH_thread_active = True
  _pH_thread = Thread(target=_ph_thread_call,args=(device,0.0,callback))
  _pH_thread.start()

def stop_ph_thread():
  global _pH_thread, _pH_thread_active
  _pH_thread_active = False
  if _pH_thread is not None:
    _pH_thread.join()

#############################################
# Interface as command line tool 

def main():
  usage = """
   ph.py c                Measure pH continuously 
   ph.py cal,mid,7.01     Calibrate Midpoint
   ph.py cal,low,4.00     Calibrate Lowpoint
   ph.py cal,high,10.05   Calibrate Highpoint
  """
  parser = argparse.ArgumentParser()
  parser.add_argument('cmd', help="")
  try:
    args = parser.parse_args()
  except:
    print(usage)
    raise

  device_list = get_devices()
  print(device_list)
  device = device_list[0]
  print_devices(device_list, device)

  # Continuous reading
  if args.cmd.lower() == "c":
    def print_ph(ph):
      print(ph)
    start_ph_thread(callback=print_ph)
    while True:
      time.sleep(1)
    return

  try:
    print(device.query(args.cmd))
  except IOError:
    print("Query failed \n - Address may be invalid, use list command to see available addresses")


if __name__ == '__main__':
    main()

To calibrate the electrode there are several commands that can be issued. Putting the electrode into the respective pH buffer, the following commands can be used to calibrate the pH board.

#python3 ph.py cal,mid,7.01
#python3 ph.py cal,high,10.04

We can now continuously read pH values.

python3 ph.py c

From here the possibilities are endless. One could program time controlled or pH controlled releases. Acid-base auto-titration is pretty easy, though it’s important to think about overshoot and the non-linearity of the pH scale.

Shrink Raspberry Pi Images

Thu, 25 Jul 2019 00:00:00 +0000

I often make images of Raspberry Pi sdcards for easy installation and cloning. Unfortunately the size of the image will always be that of the size of the card, which is usually much larger than the amount of actual data. Thankfully there is a way to shrink an image, though every tutorial i’ve seen online is cumbersome and manual (e.g. using gparted). Instead I wrote a script that does it automatically and shrinks the image to it’s minimal size.

NOTE: USE AT OWN RISK - THIS IS UNTESTED. ALWAYS BACKUP YOUR IMAGE BEFORE TRYING THIS.

Clone the script

git clone https://github.com/mtyka/shrinkwrap.git
cd shrinkwrap

Copy the sd card over

Find your sdcard device, might be /dev/sdb or /dev/mmcblk0 or other.

lsblk

Copy the image locally to an img file

sudo dd bs=4M if=/dev/mmcblk0 of=myimage.img conv=fsync status=progress

Shrink the image

./shrinkwrap.sh myimage.img

Copy the image to new sd card

sudo dd bs=4M if=myimage.img of=/dev/mmcblk0.img conv=fsync status=progress

Boot from the card

You can now resize the image back to take the full SD card size by going to:

sudo raspi-config

And then choose “Expand root partition to fill SD card” option under Advanced Options.

Headless RPi - prevent SD corruption

Tue, 09 Oct 2018 00:00:00 +0000

Raspberry Pis are perfect when building interactive art projects (e.g. 20 printers printing ML generated tweets and often it’s nice to leave the Pi headless, i.e. without keyboard or monitor. And it’s convenient to just power up the device to start it and pull the power when its time to shut it down. However there are two minor issues - how do you get your code to start without a login and how do you precent system corruption. Thanksfully there are solutions to that.

Startup: Starting your code on startup.

There a many solutions for this but personally I like to run my code as a service. To do so add a file like the one below to /etc/rc.d/ and make it executable. This assumes your startup script lives in /home/you/mycode/run.sh and exepects to be run from that directory.

#! /bin/sh

### BEGIN INIT INFO
# Provides:             tweet_printer
# Required-Start:       $remote_fs $syslog
# Required-Stop:        $remote_fs $syslog
# Default-Start:        2 3 4 5
# Default-Stop:         0 1 6
# Short-Description:    Tweet stream deamon
### END INIT INFO

. /lib/lsb/init-functions

start() {
  log_action_begin_msg "Starting tweet printer daemon"
	cd /home/you/mycode/
	sh run.sh # OR python3 run.oy OR ./myexe 
  log_action_end_msg
}

stop() {
  log_action_begin_msg "Stopping tweet printer daemon"
  # <Insert command to kill your process here>
  #
  log_action_end_msg
}

case "$1" in
    start)
      start
  ;;
    stop)
      stop
  ;;
    restart)
      stop
      start
  ;;
    *)
      echo "Usage: <MYSERVICENAME> {start|stop|restart}"
      exit 1
  ;;
esac
exit 0

After making the file, run

sudo chmod +x /etc/init.d/myscript 
sudo update-rc.d /etc/init.d/myscript defaults

Note your code will run as root. Note this can also be a python program directly but i prefer the shell script to keep things more seperated.

Shutdown: Preventing SD corruption

Linux systems do not like to to be powered off suddenly and this can lead to corruption of the filesystem on the SD card. Last time we faced this issue we researched a bunch of UPS-like soutions that would detect power failure and provide both bridge-over power and a signal to the Pi to cleanly shut down using extra electronics and super caps or batteries. However, there’s a much much simpler solution: just mount the filesystem read only. This is not 100% straightforward and can have some drawbacks but for what we were doing it was perfect. Doing so makes the entire system completely stateless and thus unable to corrupt itself. THe drawback is you cannot persist any state from one boot to the next but there are aalso workarounds which we’ll discuss at the end. I’m basically following the instructions from http://ideaheap.com/2013/07/stopping-sd-card-corruption-on-a-raspberry-pi/ here, except that I go one more step and fully mount the system read-only. The lock/unlock scripts work around the usability issue.

0) Disable swapping

This will disable swapping:

sudo dphys-swapfile swapoff
sudo dphys-swapfile uninstall
sudo update-rc.d dphys-swapfile remove

Check that free -m shows the swap to be 0

1) Set up /etc/fstab to mount /var/log and /var/tmp using tmpfs. The system needs scratch space to write into, so just mounting the root filesystem read-only doesnt work very well. However we can setup in-RAM filesystem for this purpose. Add these two lines to /etc/fstab

none                  /var/log        tmpfs   size=1M,noatime   0       0
none                  /var/tmp        tmpfs   size=1M,noatime   0       0

Then also add ro to the line that mounts your root and boot file system. In the end the file should now look someting like this:

proc                  /proc           proc    defaults          0       0
PARTUUID=d6a29f93-01  /boot           vfat    ro,noatime        0       2
PARTUUID=d6a29f93-02  /               ext4    ro,noatime        0       1
none                  /var/log        tmpfs   size=1M,noatime   0       0
none                  /var/tmp        tmpfs   size=1M,noatime   0       0

Now the system will be stateless. However sometime its necesseray to unlock it to make mods:

2) Set up two script that will allow us to temporarily lock and unlock the filesystem if we need to edit something.

~/lock.sh

#!/bin/sh
mount -o remount,ro $(mount | grep " on / " | awk '{print $1}')

~/unlock.sh

#!/bin/sh
mount -o remount,rw $(mount | grep " on / " | awk '{print $1}')

If you’re updating kernels etc oyu may also have to remount /boot but that’s not as frequently necessary so I dont set up a script for that.

4) Hit sudo reboot check your service starts up

Drawbacks of this method

In my experience this works really well in practice, but there could be drawbacks:

You have no persistent system log - if something went wrong it can make debugging hard.
You can’t persist state from one boot to the next. One work around is to have a second SD card using a USB stick which is mounted periodically just when needed and then unmounted. Or you can briefly remount / read-write, write your state and then remount again. Not perfect (if the power goes of right that second) but it makes it way less likely. Or, if you hae network, you could send the state to a farawy server.
The tmp dirs that are in memory fill up you have an issue.
Not having a swap partition, if you run out of memory, you’ll likely crash.

Glass etching

Tue, 09 Oct 2018 00:00:00 +0000

When casting glass I usually need to sandblast the glass after cold working in order to get a smooth and consistent texture across the piece. I usually use a 150grit medium at 35 psi or so.

Sandblasting will make everything really even and nice, but results in a very whitish, extremely scattery surface that lets little light shine through. The reason is that sandblasting essentially knocks tiny chunks out of the surface of the glass (every time a sand particle collides with the glass) and results in a surface that has lots of sharp edges, each refracting and scattering light. Any liquid or moisture on the surface will smooth the surface and make it more transluscent and thus oils from hands etc show up in really ugly ways.

To get a more consistently transluscent surface and no more finger prints you have two options to smooth the microscopic sharp edges. Either cover the glass in a varnish, like Liquid Luster. I don’t like this option because it just seems wrong to cover the glass in plastic. It also feels weird to touch and doesn’t look quite as nice. The other option is to lightly etch the glass - effectively rounding out the sharp edges, chemically. The disadvantage of this option is that it involves some quite dangerous chemicals. Silicates (SiO4) do not dissolve in much, but they are attached by hydroflouric acid and related compounds. HF is incredibly toxic and dangerous stuff - pretty much not feasible outside of a lab or an industrial setting.

Somewhat more managable but still very dangerous is Ammonium Biflouride. His Glassworks sells a product called Varietch which consists of ~50% Ammoniumbiflouride and ~50% sucrose (C12H22O11), sold as a powder. The sucrose is inert here and acts presumably as filler and also a hygroscopic, keeping the power wet-ish (you don’t want to inhale Ammoniumflouride powder). Or perhaps they add it to increase the viscosity of the solution ? I’m not sure. Either way you dissolve it in water and it etches glass very nicely at slightly reduced risk (You still need to use thick rubber gloves, a respirator and eye protection etc. Flouride poisoning is extremely dangerous).

One problem I’ve encountered is with lead glass (crystal). Lead glass is beautiful and easier to cast (it less viscous at a given temperature). However when etching lead glass with ammonium biflouride the surface gets covered in a thick white substance which is insoluble and hard to scrub off. For years I’d just use muscle grease and scrub it off, or sometimes a pressure washer. I noticed that Soda glass does not form this residue. Recently I thought about what this stuff must be and came up with a better (albeit also hazardous) solution. Lead glass is a mixture of SiO4, PbO and K2O. Reacting with NH4HF2, these yield SiF4, PbF2 and KF. Now, the first and last are water soluble, but PbF2 is in fact a white, water-insoluble solid and thus most likely the white residue I find when etching my lead glass.

After some research I found that lead flouride (PbF2) is soluble in nitric and in hydrochloric acid. So I did two experiments to check my suspicion. First i etched a piece of lead glass and a piece of soda-lime glass. As expected, only the lead lead glass developed the residue. Second I got some muriatic (hydrochloric) acid from the hardware store (used to etch concrete). This is ~32% HCl. I soaked the residue covered piece of leadcrystal for ~ 1 hr and to my delight the residue was completely dissoved.

Obviously using concentrated hydrochloric acid is dangerous and needs to be done with great care and with good ventilation and safety equipment (Rubber gloves, Eye protection, Face shield, rubber apron). Note that all that is already necessary when dealing with the Varietch Ammoniumbiflouride, so it doesnt make the overall process much worse.

More notes:

32% HCl, dissolves within 1 hr 10% HCl, did not dissolve in 12 hrs.

Superresolution with semantic guide

Wed, 09 Aug 2017 00:00:00 +0000

A few months ago I posted some results from experiments with highresolution GAN-generated faces. By popular request here is a little more on the approach taken and some newer results.

Generative machine learning has made tremendous strides in recent years. Unfortunately most models are limited to resolutions below 256x256 due to memory and processing limitations. For larger resolutions two-step methods have been proposed such as StackGAN where an initial GAN generates a low-resolution sample from a seed random distribution and then a second, conditional GAN generates a high resolution image from the initial sample. To get high resolution faces, I built on that idea but in order to get up to 768x768 or larger I apply the second up-res stage in tiles, taking in small crops of the initial and increasing their resolution 8x. Overlapping tiles are then merged and feathered into the final image.

Details

A typical up-resolution network (e.g Ledig et al. ) is a generative network which is conditioned on a low-resolution input patch and produces a plausible matching highres image. This means that the early parts of the network have to essentially interpret the semantic content of the lowres image in order to decide which highres features and textures to generate. This in itself is effectively an image segmentation/recognition task and is made especially difficult because much of the information needed is contextual, i.e. located outside the input patch and thus unavailable to the network during both training and inference. To help with this issue, for the narrow case of high-resolution face generation, one can supplement semantic information in the form of additional input channels. This information can be generated from the full low-res image (not just the crop) and thus provide the additional semantic guidance. Similar ideas have been used in prior work for examples (Isola et al, Champagnard et al. and recently in Chen et al. ).

First a lowres image is generated using a typical DCGAN at 128x128. Since this is a pretty standard procedure the following will focus on the high resolution step(s).

Semantic guide

The lowres face is then processed through a facial landmark algorithm (using DLIB) to generate a facial feature guide. For simplicity the guide is encoded simply as colors in RGB. Alternatively each feature could be saved in its own channel. The mask is depth-stacked with the low-res image (to make a 128x128x6 image) and then downsampled slightly to 96x96x6. The downsampling steps helps to smooth out artifacts in the lowres image that came from the lowres GAN and also conveniently anti-aliases the guide. For the next step, individual 32x32x6 crops of this input are fed into the second stage, the up-resolution network.

Upres generator

The upres stage is a J-shaped network, similar to a U-Net: The encoder side of the network is truncated (starting at 32x32x6) and has 4x fewer channels compared to the decoder side. The reduction increases training speed and reduces parameters. Due to the presence of the semantic guide the encoder side of the network can afford to be slimmer. The decoder side has 2 additional convolutional layers between each deconv step, all the way up to 256x256, thus achieving 8x upsampling. The additional layers beef up the modeling capacity of the network and seem to help generate more elaborate textures. Skip connections are added between layers of equal x,y extent on either side of the U to improve gradient flow and give access to the lowres features at most places in the network, just like in the original U-net. Compared to pix2pix I’ve also removed the batchnorm step which doesn’t appear to help, slows down training and also means that inference and training use different normalization parameters.

Discriminator

The discriminator takes the highres output, as well as the lowres 32x32x6 input and determines whether the highres is real or not and whether it is a plausible highres version of the lowres input. It’s structure is identical to that used in pix2pix (Isola et al ) except that the 32x32x6 input is simply concatenated with the feature channels after 4 down samplings of the highres input when the discriminator spatial extent has reached 32x32.

Lowres L1 loss

Similar to pix2pix, the generator loss is composed of a GAN loss and a direct L1 pixel loss. However the L1 loss is applied to a downsampled pair of images (32x32, using avgpooling) rather than the full 256x256. In other words the L1 loss only ensures that the down-sampled output of the generator is a plausible source for the 32x32 input rather than an exact reproduction of the training data. We want to avoid penalizing the generator for getting the exact details wrong - instead fine details are evaluated only by the GAN loss which only assesses realism in general, not an exact match to each training example. This idea is similar in spirit to the Laplacian loss used by Bojanowski et al. except that the highres evaluation is left to a GAN rather than matching the Laplacian pyramids.

Inference & Tiling.

To reduce tiling artifacts, overlapping tiles are generated and blended together. I also present each tile twice, once flipped in x. Other aspects of the input can also be varied (contrast, saturation). This is because the quality of the upres differs stochastically depending on the input. After transforming back, one can compare the quality against some metric. One possible metric is running each output hrough the trained discriminator and using it’s output to pick the most “realistic”. Alternatively simply measuring contrast or the variance of the laplacian of the output (to detect sharpness) can be used.

Interesting insights (YMMV):

Semantic guiding is a powerful tool to assist generative networks. Very recent work by Chen et al., has impressively demonstrated this also.
Batchnorm doesn’t always help. I found batchnorm weird and annoying on the generator path. Sometimes using batch averages at inference time worked better than using the averaged values. Also tried per sample batchnorm, i.e. normalizing just over the x,y dimensions but not over the batch which sometimes worked better. In the end I found that just disabling batchnorm all-together does not degrade performance but gets around some of the inference-time instabilities. I still use batchnorm in the discriminator but in the generator it’s nice to not have it.
Applying L1 at a downsampled scale gives more room for the generator to in-paint details free of constraints, other than realism.
Garbage in/garbage out: Putting in the time to clean your data set of bad data points (blurry pictures, drawings, half-tone, artifacts, occluded faces etc) really pays off, even if it reduces the size of your dataset. It seems that a smaller high quality set is much more effective than a large dataset with poor quality images. I wrote a handy little tool SwipeLabel for my phone that can be used to sort images with swipe gestures. It’s easy to use and you can sort your data while on the bus, while bouncing a baby, while waiting in line etc..

Latest results:

Some more recent results below. Getting better skin texture but hair seems to have gotten worse.

Video

I’m experimenting too with doing some smooth interpolations in z space and then upressing each frame. Unfortuantely the upres step isn’t super stable from frame to frame. Frame interpolation helps a little bit with that problem. Anyway, it makes an interesting looking video:

Work in progress: Portraits of Imaginary People

Tue, 06 Jun 2017 00:00:00 +0000

For a while now I’ve been experimenting with ways to use generative neural nets to make portraits. Early experiments were based on deepdream-like approaches using backprop to the image but lately I’ve focused on GANs. As always resolution and fine detail is really difficult to achieve. For starters the receptive field of thse networks is usually less than 256x256 pixels. One way around this is tiling combined with stacking GANs, which many people have experimented with, for example this paper uses a two-stage GAN to get high resolution: (https://arxiv.org/abs/1612.03242).

I tried a similar approach and I’ve been finally been having some more success upres-ing GAN-generated faces to 768x768 pixels in two stages and in some cases as far as 4k x 4k, using three stages. This gives them a lot more crisp detail. Since I’m trying to do this with art in mind, I don’t mind if the results are not necessarily realistic but fine texture is important no matter what even if it’s surreal but highres texture.

As usual I’m battling mode collapse and poor controllability of the results and a bunch of trickery is necessary to reduce the amount of artifacts. Specifically the second stage GAN is meta stable between smooth skin and hairy skin and often results in patchy output. For now I’m using vanilla GANs and these results are fairly cherry-picked - I should give WGAN, CramerGAN or BEGAN a shot, word is they converge better. BEGAN seems to have a smoother, VAE kinda look which perhaps makes sense because the discriminator is an auto encoder and the loss is an indirect reconstruction loss.

Anyways, here are some highly cherry-picked work-inprogress results:

The quality depends strongly on the realism of the lowres output. I typically generate things at 128x128 or 256x256 at the first stage and then upres to 768x768 or 1024x1024 at the second stage. In most cases the quality is nowhere near the above, but in some cases the results are kinda interesting artistically. Occasionally a sort of artistic style emerges.

Adding a third stage allows upressing up to 4k. However I dont have any actual training data at that resolution, meaning the network only learns to generally predict smooth edges etc, It can’t know the details of what skin pores or eyelashes look like. A super-highres database of faces would be needed here. Still for purposes of printing it’s nicer to create some interesting looking artifacts at this resolution, rather than bilinear interpolation of just pixelation.

Some full size 4k ones (click to enlarge):

Anyways, the goal is to make these into printable physical-world art pieces but I found in practice the resolution and detail has to be pretty high or it just doesn’t look nice printed. Like I said, it’s all work in flux and progress, more soon.

Followup: Method

Aug 8th, 2017

By popular request a little more on the approach taken here.

Square to Hex

Sat, 11 Mar 2017 00:00:00 +0000

Imagine you had a square grid of points and you’d like to transform that grid into a hexagonal grid of points such that the local relationships between points are preserved. For irregular or arbitrary start or target grids tools like Mario Klingemann’s RasterFairy do an excellent job. However for a regular to regular transform I was wondering if there were optimal, regular, tilable solutions.

The naive way to transform from square to hex is to simply take every second row and shift it by half the gridspacing. That gives you triangles and you’re done. However, unfortunately, the triangles are now not equilateral, being stretched in y by sqrt(3)/2. Ok, you say, why not just just rescale in y by 2/sqrt(3), and now you’re done. Ok, but now you’ve changed the aspect ratio of the points. What if you wanted to preserve the aspect ratio and get an equilateral, hexagonal arrangement and minimize the grid distortion.

Obviosuly there can’t be perfect solutions to this problem since sqrt(3) is irrational. However we can find grid arrangements whose aspect ratio change is very close to 1.0

Square	Hexagonal	Aspect Devation	Points
4x4	4x4	0.866	20
4x6	4x6	0.866	24
16x14	14x16	1.131	224
18x16	16x18	1.096	288
20x18	18x20	1.069	360
22x20	20x22	1.048	440
24x22	22x24	1.031	528
26x24	24x26	1.016	624
28x26	26x28	1.004	728

The 28x26 solution appears to be so optimal that there appears to be no better solution up to 10000 points (i didn’t search past that point. Eventually, of course, there should be an even better approximation though it becomes intractable for the assignment algorithm (see below) since the Kuhn-Munkres algorithm is O(N^3).

Ok, now once we have the grids we still have to assign which point in the square grid becomes which point in the hex grid. We can calculate the ideal minimal distortion by solving the assignment problem over a cost matrix of distances. For the patches to be tileable we need to calculate the distance matrix under periodic boundary conditions, i.e if you walk out of the unit cell to the left you reappear on the right.

16x14 = 224 points

18x16 = 288 points

20x18 = 360 points

22x20 = 440 points

24x22 = 528 points

26x24 = 624 points

28x26 = 728 points

Tiling

All these can be tiled so arbitrarily large planes of points can be converted this way.:

224 2x2

728 2x2

3D printing glass and bronze: Lost-PLA casting

Sun, 11 Dec 2016 00:00:00 +0000

For a few years now I have been experimenting with casting glass and occasionally bronze from 3D printed positive models. Specifically I use this technique to make sculptures of protein molecules rendered as their solvent accessible surface, which are created from their scientifically precise chrystallographic coordinates.

I begin the process of casting a molecular sculpture by reviewing different possible macromolecules for their potential. I often get asked how I choose my models. I have three criteria:

Scientific relevance

Is it an interesting macromolecule?
Does it have an important function that is readily explainable and accessible?
Does it have historical significance in terms of its discovery ?

Artistic relevance

Do I find it aesthetically pleasing ?
Is there symmetry in quaternary structure, or a regularity to its fold?
Does it have a particularly striking shape when rendered volumetrically or through ribbons ?

Practical feasibility

Is it feasible to cast, process, mount etc. ?
Is its size prohibitive in terms of equipment I have and time expenditure.
Does it have structural features that make it unrealistically difficult ?

Once I’ve chosen a candidate I build an initial model using a molecular editor such as RasMol or PyMol. PyMol’s volume function is quite good. MSMS also works. At this stage I think about the final presentation and mounting. Somehow a flat surface is needed or some sort of cradle. It’s good to have some sort of idea even this early of how it’s going to work, even though in practice I often change my mind later as I get to know the piece. For multipart pieces I also assess the fit and do other artistic edits in terms of choosing a conformation for flexible molecules (such as the carbohydrate in the lysozyme piece) which isn’t rigidly determined. There I can manipulate the torsion angles to change the overall shape in a way that makes sense. Finally I calculate a solvent accessible area and save the coordinates and faces as an .stl or .obj file.

These raw models I then load into Blender for further editing. In many cases I will make changes at this stage. First I have to decide on a scale, though in practice all my current work is at the same scale of 4 Angstrom/inch. The mixing of metric and imperial units is a bit funny, but it came from when I was making hand-formed copper models where my raw materials were in imperial units but the units of molecular modeling are Angstrom or nanometers. Somehow this scale worked well for what I was doing and so it has become my standard.

I also prepare the models for printing. Since macromolecules don’t have a flat surface I almost always cut the model into two parts, creating a large surface for each half to be printed on. Choosing the cut plane is critical to minimize the number of overhangs during printing, which usually yield worse surface quality and waste support material. In some cases I use 3 or 4 cut planes, especially when the models get large, here I have to work carefully to take in account the printing volume and balance number of pieces vs printability and overhang avoidance.

I then print each part on a typical PLA extrusion printer. Even though the print is just a throwaway positive I actually print it with a relatively thick skin and a reasonably large amount of fill density. This is for a number of reasons. In post processing, especially smoothing, I found having a thin skin to be problematic. Especially during solvent smoothing the model can collapse or distort if it does not have sufficient internal support. Furthermore a thin skin is more likely to have a small hole that might go undetected. This will later lead to ingress of plaster-slurry which can end up being embedded in the glass (see section below). A thicker skin will be easier to keep watertight. I almost always choose clear PLA, because it burns out the cleanest. Colored PLA (even that “white” variety) has additional additives which do not burn out well. Once all the parts are printed I glue them together, usually using a small amount of superglue first to keep them in a fixed position and then I seal the seam using a soldering iron. Generally I manipulate the PLA using soldering irons which work great when small parts of the model need to be repaired, fused, remove or added. I use a little PLA filament as “solder” if I need to add material. I have a couple of different tips in different shapes which I use like hot spatulas. I use these to smooth out any coarse artifacts on the model. Fine stuff is left for the next step. At this stage I also make sure different models fit together properly and I make any necessary modifications if not.

To get rid of the print lines I’ve tried a number of different techniques, many of which didn’t really work. Obviously getting the highest possible print to start with is paramount. Thinner layer thicknesses are better and make smoothing much easier. Smoothing is important though. The plaster will readily pick up the fine detail of the print lines and those will later be evident int he glass/metal. Now is the easiest time to get rid of them.

Generally these days I start by brushing on some Dichloromethane (DCM, or methylene chloride). This stuff is really very nasty and I do this work either in a fume hood or outside with a fan blowing away from me. I use a respirator with chemical filters, PVA gloves and full eye glasses. Do not use this chemical unless you’ve taken the proper safety precautions! However I found no other solvent even remotely as good at smoothing as Dichloromethane. Apparentl Tetrahydrofuran (THF) is ok, though I’ve not tried it. Acetone is completely useless, as PLA is completely insoluble in Acetone. Due to the nastiness of Dichloromethane I’ve never attempted doing vapor smoothing, but the simple cold brush on works surprisingly great. Sometimes I do two “coats”. With each coat the Dichloromethane dissolves the surface layer of the PLA and the resolidifies, running into the cracks. It also conveniently seals any tiny holes in the print where print layers have failed to fuse properly. Another method is to spray on many coats of a lacquer, e.g. shellac. This has some problems though during burnout and can leave undesirable carbon residues in the mold which can be tricky to remove. With higher burnout temperatures though this has been less of a problem.

One thing to be aware of though is that if you ever intend to make a rubber mold out of a printed positive, do not use Shellac. Shellac has residual alcohol in it and apparently is one of the very very few things that bonds to setting rubber. I found this out the hard way when my mold positive didn’t want to come out of the mold, cracking the rubber. For direct-into-plaster positives it works ok though thick layers have a tendency to char and leave carbon deposits.

When the model is ready and smooth, I attach the sprues and air vents. Depending on whether it is a metal cast or a glass cast these have to be designed differently. Liquid metal has a very low viscosity and runs fast. This means that supply channels can be more narrow but air vents have to be a little wider since the air is getting displaced much faster (almost instantly). Metal will also run up channels so not every part of the model has to have a supply line “from the top” so to speak. Often a single inlet is sufficient. In fact often a better quality is achieved when the cavity is filled from the bottom. Glass on the other hand is a completely different animal. It oozes, slowly, over the course of many hours. Much thicker than honey. This means supply channels want to be relatively wide (or it will take a very long time). Air vents can be very thin since the air has tons of time to escape. Also glass won’t run upwards very much. On the bottom of the model, with sufficiently long melts, I found that the pressure is high enough to force glass upwards perhaps an inch or two at best. Higher Up on the model though it won’t, so each chamber of the model needs at least a small supply sprue. The size is determined by the size of the chamber to be filled, though I often er on the side of caution. Believe me it is a crushing feeling when you open your mold and everything went well except some little part of it didn’t fill.

The other thing I check at this stage is water tightness. The easiest way is just to submerge the entire model in a bucket of water and watch for any bubbles, just like you would with a bicycle tire. If it bubbles, you have a problem. It turns out that when the model is leaky, a little plaster slurry will seep into the internal honeycomb of the printed model. It hardens and when you burn out the plastic will remain in this crumbly but solid lattice shape, while the surrounding plastic evaporates. The remaining plaster will stay behind and end up getting embedded into the glass. Another disappointing thing to find out after everything else worked seamlessly. This is also a great time to estimate the volume of the positive. This will later inform how much glass to place in the kiln, which has to be done relatively accurately.

Do make air vents I simply use printer filament. To attach them I use a soldering iron. For glass the air vents don’t need to go to the top of the mold, they can go to the bottom or the side. The glass is too viscous to leave through the air vents. With metal they need to go to the top. Liquid metal can squeeze through tiny holes and channels and you risk a leak. I’ll often connect the air vents into a sort of network both to make it more stable (it’s easy to break it off when handling the model) and to create redundancy. Below is a photo of a fully set up model, ready for pouring of the plaster mix. Note it’s upside down. The inlet, the main sprue, is on the bottom and is connected to a coated wooden board using plasticine or wax.

To make the actual mold I’ve tried two different ways, both work and it sort of depends on gut feeling and the shape of the piece as to which I’ll choose. The first involves building a wall around the piece that’s stuck to the base plate. I often use corrugated plastic to make the barrier. I use wax and/or plasticine to seal the bottom of the wall. Since the piece is upside down, the wall needs to be about 1-2 inches taller than the highest point of the mold such that the mold later has a thick enough bottom. The second way involves taking a suitably sized cardboard box and a plastic bag. I line the inside of the cardboard with the bag, taping it to the side. Later I will fill the “bucket” with plaster and then lower the piece down into it from the top, hanging from the support board. In this case I usually use a long slender support so that I have space to add additional plaster if needed.

Time to pour the plaster mix. For glass casting the mold mix is 1:1:1 silica:plaster:water, by weight. The silica is 200 mesh finely ground silica. It acts as a refractory material, i.e. it helps withstand the heat. The plaster is simple potter’s plaster. I thoroughly mix these at 1:1 as dry powders first. This ensures very thorough mixing later so there aren’t pockets of just plaster or just silica. To mix the plaster you always add the powder mix to a bucket of water. I guesstimate the final amount I need for the mold. You need a little over half the final volume in water. Perhaps 60% or so. Better too much than too little, nothing more annoying than having to mix another batch in a rush. Eyeballing the amount of plaster needed I found fiendishly difficult. Either way, you start with a bucket of water and slowly add the powder mix until a dry island appears at the top of the water surface, which doesn’t sink in anymore. It’s important not to stir during that time. Usually by the time the last of the plaster mix is added there’s a little island in the middle of the bucket surrounded by water. I usually wait a minute and let more of the air escape and the plaster soak through. Then, if it’s a small amount I mix it with my hands or in case of larger amount, I use a drill with a mixer attachment. Avoid whisking in air, this is the opposite of pancake making.

For many molds I will first do a face coat and then finish the mold in second pour. The first coat I pour on, and work into all the details using a brush, ladling it on and on until it becomes thick enough to stick, forming a thickish layer over the positive. This step ensures every crevice is filled and also reduces the amount of surface bubbles since working in the material with your hands or a brush tends to pop any bubbles or promote them rising to the surface. As the plaster hardens I rake in some grooves with my fingers to provide a good interlocking with the second, poured, layer. For most molds I set in some fiberglass around the outside and sometimes additional fiberglass ribbon if the mold is particularly slender. There is nothing worse than a cracked, burst mold with oozing glass emerging spilling in the kiln. I then mix a second batch of plaster and pour it in. Generally I do both layers in one sitting. You don’t want the face coat to dry out and then pour the second one.

Now that the mold is poured, I generally let it air dry for a few days. After the first 24 hrs I take off the box or container that held the plaster, aiding drying. Next, we need to burn out the mold. I place the mold, upside-down, in the kiln, usually on top of a metal grating I’ve built. Underneath I place a metal pan to catch the drippings. The pan is lined with some aluminum foil for easy cleaning. The burnout protocol plateaus at several temperatures. First 230 to dry the mold completely. Then at 500 to drive off all the chemically bound water and start melting the PLA. At the end of this stage the bulk of the PLA will have melted and dripped out into the pan, so I will open the kiln and empty the pan. The program then ascends to 700. At this temperature PLA will evaporate rapidly and carbon deposits will also oxidize away. I noticed that when I didn’t go up to this temperature, some of the molten PLA mould soak into the plaster and then, upon cooling and contraction, cause the plaster to crack. However if the temperature is raised sufficiently, the PLA evaporates completely, thus not creating those stresses during cooling and many cracks are avoided. Some cracks still occur, but the resultant flashing can later be ground off.

Time (Hr:Min)	Temp(F)	Description
2:00	230	Drying wet mold
2:30 (Hold)	230	Drying wet mold
3:00	500	Melt PLA without burning it
4:00 (Hold)	500	Melt PLA without burning it
2:00	700	Vaporize remaining PLA
4:00 (Hold)	700	Vaporize remaining PLA
7:00	60	Cool to room temperature

At this point the mold is ready for casting. With the opening pointing upwards, the mold is placed in the kiln. I often place fire bricks around the mold just in case it fails the bricks will keep the mold from completely breaking apart and leaking its contents into the kiln. Cleaning off the glass from the shelf and heating elements is a huge pain. Above the mold I place a suitable size flower pot which will hold most of the cold glass.

Using my earlier estimate of the volume I figure out how much glass to put in the flowerpot. Ideally the amount is just right so that at the end of the melt the mold is completely full, with a good amount remaining in the funnel above the mold but virtually none in the flowerpot. Too much glass and it will overflow the mold, waste glass and cause a mess. Also it will shatter during demolding and, if unlucky, will send cracks propagating into the piece. Too little and the piece won’t be filled completely. Either outcome is highly undesirable.

Sometime the geometry of the piece doesn’t allow for all of the necessary glass to be placed in the pot at once. In that case some has to be reserved and added during the melt. My kiln has a special hole at the top to allow this to happen easily. However adding cold glass to a 1500F kiln causes the glass to violently shatter, sometimes spraying bits of it everywhere in the kiln, once again, making a mess (or potentially falling into another mold if multiple pieces are being cast at once). Measuring the volume of glass chunks is easiest done also by adding them to a bucket of clean water and measuring the displacement which can be compared to the displacement of the positive, done earlier.

I often load the glass wet (but not dripping) into the flowerpot - as the kiln warms up there’s plenty of time for it to evaporate. I buy the glass in billets, usually from Gaffer. To get the right amount I use a glass cutter to score the billets and a hammer to crack them (wear safety glasses!). I try and minimize the number of pieces, since the smaller the pieces the more likely they are to trap bubbles as they melt. Bigger bubble-free pieces are best, but sometimes fitting it all into the flowerpot necessitates breaking them up a bit more than ideal.

The next step is figure out the firing protocol. These are given usually by the glass manufacturer (e.g. Gaffer) and depend on the thickness of the thickest part of the model and how thick the mold is. An example profile is below.

Time (Hr:Min)	Temp(F)	Description
3:00	300	Drying wet mold
2:00 (Hold)	300	Drive off chemical water
6:00	1000	Heating glass and mold
2:00 (Hold)	1000	Time to equalize temperature
10	1475	Bring up to melting temp
8:00 (Hold)	1475	Allow glass to flow
2:00	890	Crash temp to solidify piece
10:00 (Hold)	890	Hold at Annealing temperature
20:00	700	Slow cooling
20:00	300	…
6:00	75	…

I usually skip the first two steps if the mold is already dried and burned out. Be sure to check with your glass’ manufacturer about the right protocol, it depends strongly on the type of piece and the glass chemistry.

The melt time depends also on the geometry of the model and how the glass flows. There needs to be enough time for the glass to reach every part of the mold. The thinner parts of the mold are the more time that takes, however it depends also on other factors. The pressure at the bottom of the mold is much larger than at the top so glass will flow faster, generally. There is no hard science here, just experience and guessing. I usually err on the side of longer, just to be sure. However longer also means the mold spends more time at the highest temperature which weakens the plaster and stresses the mold. I also plan to check the kiln 30 minutes or so before the temperature is scheduled to drop again. It is relatively safe to open the kiln, since the glass is molten and can’t suffer thermal cold shock. However you are staring into a 1500F hell hole so protective gloves and a face shield are a must. The infrared radiation is super intense. I always try and place the mold in such a way that I can see if the mold is full even if the door is just slightly cracked to minimize exposure (Though at least on one occasion I had to fix a problem inside the kiln at top temperature and had to reach in with kevlar gloves and manipulate a fallen flowerpot - I don’t recommend it). If after the inspection the mold isn’t full I can extend the melt time and, if required, add more glass. Once the program moves into its annealing phase I try not to open the kiln anymore until the program is completely done. There is literally nothing to be done, the glass is solid anyway and opening it risks cold shock and cracks.

After the cast is completely cold (i usually wait 24hrs after the program’s end) I begin removing the mold material by this point it is quite brittle and it’s easy to break it. If the cast shape is quite convex and thick, I usually just remove the mold dry by gently chiseling (with a wooden chisel) and knock on the plaster until it falls of.

However if the mold is quite fragile or complex it is easy to break the glass at this point. To demold I soak the entire mold in a bucket of water. after a few hours the plaster will fall off almost by itself. I then clean the piece with water.

The next step is cold working. Using a dremel and a diamond bit I grind off the air vents, the sprues and any flashing. Once completed, wash the piece again and then let it dry for sandblasting. The sandblasting evens out the texture between the places the piece has been ground and other spots, giving a smooth even finish. It can also help reduce any print lines that are still visible.

Sandblasting smoothes the glass but leaves a very white, scattering surface. Furthermore any moisture or oils from fingers will reduce light scattering and leave dark prints. To make the glass more translucent again it is then etched using a biflouride salt (like potassium biflouride). It is available in powder form from “His Glassworks” - again this is a quite hazardous substance. I work in a well ventilated environment with safety glasses and rubber gloves. The powder is simply dissolved in water and the glass is placed in the solution for 10 minutes or so. Afterwards i dip the glass in a baking soda solution to neutralize the acid. The etching process leaves a white film behind (likely some insoluble compound of the silica and the acid). This needs to be scrubbed off. On of the easiest ways I found to do this is to use a pressure washer. I place the glass on the lawn outside, on an old towel and direct the pressure washer stream down wards onto the glass. This is quite effective removing the white deposits, even in hard to access crevices and pits. Obviously if the glass is quite thin and fragile using the pressure washer method is dangerous and may crack the glass. In that case using a stiff brush, like a toothbrush makes more sense.

To see more pieces check out my website

Class visualization with bilateral filters

Fri, 05 Feb 2016 00:00:00 +0000

A while ago I played with style visualizations and bilateral filters. The latter have the nice property of filtering out noise but preserving edges. Here are some example class from GoogLeNet (Inception network). Big shout out to Audun m. Øygard and Kyle McDonald who were among the first to use filters (e.g. gaussian blurs) essentially as image regularizers for single class visualizations. These visualizations here were directly inspired by their ideas.

Neural Network art show

I’ll be showing 3 high-res pieces based on this technique at the Neural Network art show at Gray Area in San Francisco end of February.

Class #34, Leatherback Turtle

Class #76, Tarantula

Class #144, Pelican

Class #156, Blenheim Spaniel

Class #488, Chain

Class #725, Pitcher

Class #944, Artichoke

Fun with video

Here’s a little animation I call the “Animal parade”

Combining bilateral filters with style transfer

These were made using bilateral class visualization using GoogLeNet (cello, violin, saxophone) and then had style transfer applied with the style coming from a natural picture (photo).