DEM Converter

topo.py

import re

class Topo(object):
    def __init__(self, array, xscale=1.0, yscale=1.0):
        self.array = array
        self.w = len(array[0])
        self.h = len(array)
        minz = min(map(min, array))
        self.maxz = max(map(max, array))-minz
        self.minz = 0.0
        self.xscale = xscale
        self.yscale = yscale
        self.zscale = 1.0
        for x, row in enumerate(self.array):
            for y, val in enumerate(row):
                self.array[x][y] = val-minz

    def shift_z(self, value):
        self.zoffset = value

    def scale(self, value):
        self.xscale *= value
        self.yscale *= value
        self.zscale *= value

    def __iter__(self):
        def scale_row(x, row):
            for y, z in enumerate(row):
                yield (x*self.xscale, y*self.yscale, z*self.zscale)
        for x, row in enumerate(self.array):
            yield scale_row(x,row)

    def transpose(self):
        pass

    def __str__(self):
        return "<Topo width=%g height=%g depth=%g>" % (self.width, self.height, self.depth)

    @property
    def width(self):
        return self.w*self.xscale

    @property
    def height(self):
        return self.h*self.yscale

    @property
    def depth(self):
        return (self.maxz-self.minz)*self.zscale

    def scale_to_depth(self, depth):
        d = self.depth
        scale_factor = depth/d
        self.scale(scale_factor)

    def to_gcode(self, feedrate, safe_z, pass_depth):
        g = [
            'G20',
            'G17',
            'G0 Z%0.4f' % safe_z,
            'M4',
            'G4 P4.0',
            'G0 X0 Y0',
        ]
        def depth(z):
            return (self.depth - z)
        dir = False
        for r, row in enumerate(self):
            row = list(row)
            # Staggered plunge for first row
            if r == 0:
                current_z = pass_depth
                more_to_cut = True
                while more_to_cut:
                    more_to_cut = False
                    if dir:
                        row = reversed(row)
                    
                    for x,y,z in row:
                        z = depth(z)
                        if z > current_z:
                            more_to_cut = True
                            g.append('G1 X%0.4f Y%0.4f Z-%0.4f F%0.4f' % (x,y,current_z,feedrate))
                        else:
                            g.append('G1 X%0.4f Y%0.4f Z-%0.4f F%0.4f' % (x,y,z,feedrate))
                    print more_to_cut
                    current_z += pass_depth
                    dir = not dir

            else:
                if dir:
                    row = reversed(list(row))
                for c, (x,y,z) in enumerate(row):
                    z = depth(z)
                    g.append('G1 X%0.4f Y%0.4f Z-%0.4f F%0.4f' % (x,y,z,feedrate))
            dir = not dir

        g.extend([
            'G0 Z%0.4f' % safe_z,
            'M8',
            'G0 X0 Y0'
        ])
        return '\n'.join(g)


    @staticmethod
    def from_dem(filename):
        array = []
        dict = {}
        with open(filename, 'r') as fp:
            for line in fp.readlines():
                match = re.match(r'(\w+)\s+(-?\d+(?:\.\d+)?)', line)
                if match:
                    key, value = match.groups()
                    value = float(value) if '.' in value else int(value)
                    dict[key] = value
                else:
                    array.append(map(float, line.split()))
            
            scale = dict.get('cellsize', 1.0)
            return Topo(array, scale, scale)


if __name__ == "__main__":
    t = Topo.from_dem('tcef.plus.dem.10m.txt')
    t.scale_to_depth(0.9)
    with open('topo.nc', 'w') as fp:
        fp.write(t.to_gcode(90.0, 0.5, 0.005))