src.acoustools.Fabrication.Translator

  1'''
  2Translates gcode file to lcode file 
  3
  4'''
  5# NEED TO ADD FRAME RATE CONTROL
  6
  7
  8from acoustools.Utilities import create_points
  9from acoustools.Paths import interpolate_points, distance, interpolate_arc, interpolate_bezier, bezier_to_distance
 10
 11from torch import Tensor
 12import torch
 13from typing import Literal
 14
 15
 16def gcode_to_lcode(fname:str, output_name:str|None=None, output_dir:str|None=None, log:bool=True, log_name:str|None=None, log_dir:str=None,
 17                    divider:float = 1000, relative:bool = False, 
 18                   max_stepsize:float=0.001, extruder:Tensor|None = None, pre_print_command:str = '', 
 19                   post_print_command:str = '', print_lines:bool=False, pre_commands:str= '', post_commands:str='', 
 20                   use_BEM:bool = False, sig_type:str='Trap', travel_type:Literal["hypot","legsXY","legsZ","bezier"]='hypot',
 21                   add_optimisation_commands:bool=True, via:Tensor|None=None, use_functions:bool=False):
 22    '''
 23    Converts a .gcode file to a .lcode file \n
 24    ```Python
 25    from acoustools.Fabrication.Translater import gcode_to_lcode
 26
 27
 28    pth = 'acoustools/tests/data/gcode/rectangle.gcode'
 29
 30    pre_cmd = 'C0;\\n'
 31    post_cmd = 'C1;\\nC3:10;\\nC2;\\n'
 32    gcode_to_lcode(pth, pre_print_command=pre_cmd, post_print_command=post_cmd)
 33
 34    ```
 35    :param fname: The file name of the gcode file
 36    :param output_name: The filename for the lcode file, if None will use the gcode file name with .gcode replaced with .lcode
 37    :param output_dir: output directory of the lcode file, if None will use the same as the gcode file
 38    :param log: If True will save log files 
 39    :param log_name: Name for the log file, if None will will use the gcode file name with .gcode replaced with .txt and the name with '_log' appended
 40    :param log_dir: Directory for log file, if None will use same as the gcode file
 41    :param divider: Value to divide dx,dy,dz by - useful to change units
 42    :param relative: If true will change relative to last position, else will be absolute
 43    :param max_stepsize: Maximum stepsize allowed, default 1mm
 44    :param extruder: Extruder location, if None will use (0,0.10, 0)
 45    :param pre_print_command: commands to put before the block resulting from each G01, G02 and G03 command
 46    :param post_print_command: commands to put before the block resulting from each G01, G02 and G03 command
 47    :param print_lines: If true will print which line is being processed
 48    :param pre_commands: commands to put at the top of the file
 49    :param post_commands: commands to put at the end of the file
 50    :param add_optimisation_commands: If True will add commands to help `acoustools.Fabrication.Optimsation` functions work correctly
 51    :param via: A point to move all paths through before going to the end point
 52    :param use_functions: If true will collapse common code into functions - needs `via` to be specified too
 53    :param use_BEM: If True will use scattering for the mesh while it is built
 54    :param sig_type: Defined signature to use for traps
 55    :param travel_type: Way to move the particle
 56
 57    '''
 58
 59
 60    name = fname.replace('.gcode','')
 61    parts = name.split('/')
 62    name = parts[-1]
 63    path = '/'.join(parts[:-1])
 64
 65    if extruder is None:
 66        extruder = create_points(1,1,0,-0.04, 0.04)
 67
 68    if output_name is None:
 69        output_name = name
 70
 71    if output_dir is None:
 72        output_dir = path
 73    
 74    if log_dir is None:
 75        log_dir = output_dir
 76    
 77    if log_name is None:
 78        log_name = name 
 79
 80    if use_functions:
 81        functions = {}
 82    else:
 83        functions = None
 84    
 85    
 86    output_file = open(output_dir+'/'+output_name+'.lcode','w')
 87    output_file.write(pre_commands)
 88
 89    if log: log_file = open(log_dir+'/'+log_name+'_log.txt','w')
 90
 91    head_position = create_points(1,1,0,0,0)
 92    E_val = 0
 93    
 94
 95
 96    with open(fname) as file:
 97        lines = file.readlines()
 98        Nl = len(lines)
 99        for i,line in enumerate(lines):
100            if print_lines and i % 10 == 0: print(f'Computing, {i}/{Nl}', end='\r')
101            line = line.rstrip()
102            line_split = line.split()
103            if len(line_split) == 0 or line.startswith(';'):
104                if log: log_file.write(f'Line {i+1}, Ignoring line {line})\n')
105                continue
106            code = line_split[0]
107            args = line_split[1:]
108            command = ''
109            
110            E_val = get_E_val(*args, E_val=E_val)
111
112            if (code == 'G00' or code == 'G0') or ((code == 'G01' or code == 'G1') and E_val == 0): #Non-fabricating move
113                head_z = head_position[:,2].item()
114                command, head_position = convert_G00(*args, head_position=head_position, divider=divider, relative=relative)
115                if use_BEM and head_z != head_position[:,2]:
116                    command += 'C10;\n'
117                
118                if log: log_file.write(f'Line {i+1}, G00 Command: Virtual head updated to {head_position[:,0].item()}, {head_position[:,1].item()}, {head_position[:,2].item()} ({line}), E value set to {E_val} \n')
119            elif code == 'G01' or code == 'G1': #Fabricating move
120                command, head_position, N = convert_G01(*args, head_position=head_position, extruder=extruder, divider=divider, relative=relative, 
121                                                        max_stepsize=max_stepsize,pre_print_command=pre_print_command, 
122                                                        post_print_command=post_print_command, sig=sig_type, travel_type=travel_type, via=via,
123                                                        functions=functions)
124                
125                if log: log_file.write(f'Line {i+1}, G01 Command: Line printed to {head_position[:,0].item()}, {head_position[:,1].item()}, {head_position[:,2].item()} in {N} steps ({line}), E value set to {E_val} \n')
126            
127            elif code == 'G02' or code == 'G2': #Fabricating move
128                command, head_position, N = convert_G02_G03(*args, head_position=head_position, extruder=extruder, divider=divider, relative=relative, 
129                                                            max_stepsize=max_stepsize, anticlockwise=False,pre_print_command=pre_print_command, 
130                                                            post_print_command=post_print_command, sig=sig_type, 
131                                                            travel_type=travel_type, add_optimisation_commands=add_optimisation_commands , via=via,
132                                                            functions=functions)
133
134                if log: log_file.write(f'Line {i+1}, G02 Command: Circle printed to {head_position[:,0].item()}, {head_position[:,1].item()}, {head_position[:,2].item()} in {N} steps ({line}) \n')
135            
136            elif code == 'G03' or code == 'G3': #Fabricating arc
137                command, head_position, N = convert_G02_G03(*args, head_position=head_position, extruder=extruder, divider=divider, relative=relative, 
138                                                            max_stepsize=max_stepsize, anticlockwise=True,pre_print_command=pre_print_command, 
139                                                            post_print_command=post_print_command, sig=sig_type, 
140                                                            travel_type=travel_type , add_optimisation_commands=add_optimisation_commands , via=via,
141                                                            functions=functions)
142
143                if log: log_file.write(f'Line {i+1}, G03 Command: Circle printed to {head_position[:,0].item()}, {head_position[:,1].item()}, {head_position[:,2].item()} in {N} steps ({line}) \n')
144            elif code == 'G04' or code == 'G4': #Dwell!!
145                pass 
146            elif code.startswith(';'):
147                if log: log_file.write(f'Line {i+1}, Ignoring Comment ({line})\n')
148
149            else: #Ignore everything else
150                if log: log_file.write(f'Line {i+1}, Ignoring code {code} ({line})\n')
151            
152            output_file.write(command)
153        
154    
155    output_file.write(post_commands)
156    output_file.close()
157    if print_lines: print()
158    if log: log_file.close()
159
160def get_E_val(*args:str, E_val:float):
161    E = E_val
162    for arg in args:
163        if arg.startswith('E'):
164            E = float(arg[1:])
165    return E
166
167def parse_xyz(*args:str):
168    '''
169    Takes the args from a gcode line and ginds the XYZ arguments \n
170    :param args: list of arguments from gcode (all of the line but the command)
171    '''
172    x,y,z = None,None,None #Need to check if any of these need to not be changed
173    for arg in args:
174        arg = arg.lower()
175        if 'x' in arg:
176            x = float(arg.replace('x',''))
177        
178        if 'y' in arg:
179            y = float(arg.replace('y',''))
180        
181        if 'z' in arg:
182            z = float(arg.replace('z',''))
183
184    return x,y,z
185
186def update_head(head_position: Tensor, dx:float, dy:float, dz:float, divider:float, relative:bool):
187    '''
188    Updates the head (or other tensor) based on dx,dy,dz \n
189    :param head_position: Start position
190    :param dx: change (or new value) for x axis
191    :param dy: change (or new value) for y axis
192    :param dz: change (or new value) for z axis
193    :param divider: Value to divide dx,dy,dz by - useful to change units
194    :param relative: If true will change relative to last position, else will set head_position
195    '''
196    if relative:
197        if dx is not None: head_position[:,0] += dx/divider 
198        if dy is not None: head_position[:,1] += dy/divider
199        if dz is not None: head_position[:,2] += dz/divider
200    else:
201        if dx is not None: head_position[:,0] = dx/divider 
202        if dy is not None: head_position[:,1] = dy/divider
203        if dz is not None: head_position[:,2] = dz/divider
204
205def extruder_to_point(points:list[Tensor], extruder:Tensor, max_stepsize:float=0.001, travel_type:str='hypot', via:Tensor|None=None ) -> list[Tensor]:
206    '''
207    Will create a path from the extruder to each point in a shape \n
208    :param points: Points in shape
209    :param extruder: Extruder location
210    :param max_stepsize: Maximum stepsize allowed, default 1mm
211    :param travel_type: Type of movement to use, hypot: will use the shortest path, legsXY: will move in the XY plane then Z plane, legsZ: will move in the Z plane then XY plane, bezier, Will use a quadratic bezier in 3D
212    :param via: A point to move all paths through before going to the end point
213    :returns all points in path: 
214    '''
215    
216    #No path planning -> Talk to Pengyuan? 
217
218    all_points = []
219    for p in points:
220        if via is not None:
221            all_points += start_to_end(extruder, via, max_stepsize, travel_type) #can be replaced by a 'function' call
222            all_points += start_to_end(via, p, max_stepsize, travel_type)
223        else:
224            all_points += start_to_end(extruder, p, max_stepsize, travel_type)
225    
226    return all_points
227
228def start_to_end(end:Tensor, start:Tensor, max_stepsize:float=0.001, travel_type:str='hypot'):
229    '''
230    Will create a path from the a start position to an end \n
231    :param points: start point location
232    :param end: end point location
233    :param max_stepsize: Maximum stepsize allowed, default 1mm
234    :returns all points in path: 
235    '''
236
237    points = []
238    if travel_type == 'legsXY': #Move in XY plane then move in Z
239    
240        mid_point = create_points(1,1,x=start[0].item(), y=start[1].item(), z=end[:,2].item())
241        d = distance(start, mid_point)
242        N  = int(torch.ceil(torch.max(d / max_stepsize)).item())
243        points += interpolate_points(end, mid_point, N)
244
245        d = distance(mid_point, start)
246        N  = int(torch.ceil(torch.max(d / max_stepsize)).item())
247        points += interpolate_points(mid_point, start, N)
248    
249    elif travel_type == 'legsZ': #Move in XY plane then move in Z
250    
251        mid_point = create_points(1,1,x=end[:,0].item(), y=end[:,1].item(), z=start[2].item())
252        
253
254        d = distance(mid_point, start)
255        N  = int(torch.ceil(torch.max(d / max_stepsize)).item())
256        points += interpolate_points(end, mid_point, N)
257
258        d = distance(start, mid_point)
259        N  = int(torch.ceil(torch.max(d / max_stepsize)).item())
260        points += interpolate_points(mid_point, start, N)
261
262    elif travel_type == 'bezier': #Move along Bezier curve - paramatarised? 
263        mid_point = create_points(1,1,x=start[0].item(), y=start[1].item(), z=end[:,2].item())
264        offset_2 = mid_point - end
265
266        bezier = [end,  start, [0,0,0], offset_2]
267        
268        points += bezier_to_distance(bezier)
269
270    else: #default is hypot
271        d = distance(start, end)
272        N  = int(torch.ceil(torch.max(d / max_stepsize)).item())
273        points += interpolate_points(end, start, N)
274    
275    return points
276
277
278
279def points_to_lcode_trap(points:list[Tensor], sig:str='Trap', function_name:str='') -> tuple[str,Tensor]:
280    '''
281    Converts a set of points to a number of L1 commands (Traps) \n
282    :param points: The point locations
283    :param sig: The signature name to use
284    :param function_name: The name of the function these commands make up, if any
285    :returns command, head_position: The commands as string and the final head position
286    '''
287    command = ''
288    if function_name != '':
289        command += f"function:{function_name}: \n"
290    for point in points:
291        N = point.shape[2]
292        sig_num = {'Focal':'0','Trap':"1",'Twin':'2','Vortex':'3'}[sig]
293        command += f"L{sig_num}:"
294        for i in range(N):
295            command += f'{point[:,0].item()},{point[:,1].item()},{point[:,2].item()}'
296            if i+1 < N:
297                command += ':'
298        command += ';\n'
299    
300        head_position = point
301    
302    if function_name != '':
303        command += f"end:{function_name}; \n"
304
305    return command, head_position
306
307def convert_G00(*args:str, head_position:Tensor, divider:float = 1000, relative:bool=False) -> tuple[str, Tensor]:
308    '''
309    Comverts G00 commands to virtual head movements \n
310    :param args: Arguments to G00 command
311    :param head_position: strt position
312    :param divider: Value to divide dx,dy,dz by - useful to change units
313    :param relative: If true will change relative to last position, else will set head_position
314    :returns '', head_position: Returns an empty command and the new head position
315    '''
316    dx, dy, dz = parse_xyz(*args)
317
318    update_head(head_position, dx, dy, dz, divider, relative)
319
320    return '', head_position
321
322def convert_G01(*args:str, head_position:Tensor, extruder:Tensor, divider:float = 1000, 
323                relative:bool=False, max_stepsize:bool=0.001, pre_print_command:str = '', post_print_command:str = '', 
324                sig:str='Trap', travel_type:str='hypot', add_optimisation_commands:bool=True, via:Tensor|None=None,functions:dict|None=None) -> tuple[str, Tensor]:
325    '''
326    Comverts G00 commands to line of points \n
327    :param args: Arguments to G00 command
328    :param head_position: strt position
329    :param extruder: Extruder location
330    :param divider: Value to divide dx,dy,dz by - useful to change units
331    :param relative: If true will change relative to last position, else will set head_position
332    :param max_stepsize: Maximum stepsize allowed, default 1mm
333    :param pre_print_command: commands to put before generated commands
334    :param post_print_command: commands to put after generated commands
335    :param sig: Signature to use 
336    :param add_optimisation_commands: If True will add commands to help `acoustools.Fabrication.Optimsation` functions work correctly
337    :param via: A point to move all paths through before going to the end point
338    :returns command, head_position: Returns the commands and the new head position
339
340    '''
341    dx, dy, dz = parse_xyz(*args)
342
343    end_position = head_position.clone()
344
345    update_head(end_position, dx, dy, dz, divider, relative)
346
347    N = int(torch.ceil(torch.max(distance(head_position, end_position) / max_stepsize)).item())
348    if N > 0:
349        print_points = interpolate_points(head_position, end_position,N)
350
351        command, head_position = print_points_to_commands(print_points, extruder=extruder, max_stepsize=max_stepsize, 
352                                                      pre_print_command=pre_print_command, post_print_command=post_print_command,
353                                                      sig=sig, travel_type=travel_type, add_optimisation_commands=add_optimisation_commands, via=via,
354                                                     functions=functions)
355    else:
356        command = ''
357    return command, end_position, N
358
359def convert_G02_G03(*args, head_position:Tensor, extruder:Tensor, divider:float = 1000, 
360                    relative:bool=False, max_stepsize:float=0.001, anticlockwise:bool = False, 
361                    pre_print_command:str = '', post_print_command:str = '', sig:str='Trap', 
362                    travel_type:str='hypot', add_optimisation_commands:bool=True, via:Tensor|None=None, functions:dict|None=None)-> tuple[str, Tensor]:
363    '''
364    Comverts G02 and G03 commands to arc of points \n
365    :param args: Arguments to G00 command
366    :param head_position: strt position
367    :param extruder: Extruder location
368    :param divider: Value to divide dx,dy,dz by - useful to change units
369    :param relative: If true will change relative to last position, else will set head_position
370    :param max_stepsize: Maximum stepsize allowed, default 1mm
371    :param anticlockwise: If true will arc anticlockwise, otherwise clockwise
372    :param pre_print_command: commands to put before generated commands
373    :param post_print_command: commands to put after generated commands
374    :param sig: Signature to use 
375    :param add_optimisation_commands: If True will add commands to help `acoustools.Fabrication.Optimsation` functions work correctly
376    :param via: A point to move all paths through before going to the end point
377    :returns command, head_position: Returns the commands and the new head position
378    '''
379
380    dx, dy, dz = parse_xyz(*args)
381
382    end_position = head_position.clone()
383    origin = head_position.clone()
384
385    update_head(end_position, dx, dy, dz, divider, relative)
386
387    for arg in args:
388        arg = arg.lower()
389        if 'i' in arg:
390            I = float(arg.replace('i',''))
391        
392        if 'j' in arg:
393            J = float(arg.replace('j',''))
394    
395    update_head(origin, I, J, 0, divider, relative)
396    radius = distance(head_position, origin)
397
398    start_vec = (head_position-origin)
399    end_vec = (end_position-origin)
400    cos = torch.dot(start_vec.squeeze(),end_vec.squeeze()) / (torch.linalg.vector_norm(start_vec.squeeze()) * torch.linalg.vector_norm(end_vec.squeeze()))
401    
402    angle = torch.acos(cos)
403
404    d = angle * radius
405    N = int(torch.ceil(torch.max( d / max_stepsize)).item())
406    print_points = interpolate_arc(head_position, end_position, origin,n=N,anticlockwise=anticlockwise)
407    
408    command, head_position = print_points_to_commands(print_points, extruder=extruder, max_stepsize=max_stepsize, 
409                                                      pre_print_command=pre_print_command, post_print_command=post_print_command,
410                                                      sig=sig, travel_type=travel_type, add_optimisation_commands=add_optimisation_commands, via=via, 
411                                                      functions=functions)
412
413    return command, end_position, N
414
415def print_points_to_commands(print_points, extruder:Tensor, max_stepsize:float=0.001, 
416                    pre_print_command:str = '', post_print_command:str = '', sig:str='Trap', 
417                    travel_type:str='hypot', add_optimisation_commands:bool=True, via:Tensor|None=None, functions:dict|None={}):
418    '''
419    @private
420    '''
421    command = ''
422    for point in print_points:
423        if via is not None and functions is not None:
424            '''Check if we can use a function - if we have seen the same (extruder, travel_type, max_stepsize, via) before'''
425            extruder_x = extruder[:,0].item()
426            extruder_y = extruder[:,1].item()
427            extruder_z = extruder[:,2].item()
428
429            via_x = extruder[:,0].item()
430            via_y = extruder[:,1].item()
431            via_z = extruder[:,2].item()
432
433            idx = str(extruder_x) + '_' + str(extruder_y)+ '_' + str(extruder_z)+ '_' + travel_type+ '_' + \
434                    str(max_stepsize) + '_'+ str(via_x)+ '_' + str(via_y) + '_'+ str(via_z)
435            
436            if idx not in functions: #This is the first time we've seen this so create it
437
438                if 'names' not in functions:
439                    functions['names'] = 0
440                
441                name = functions['names'] + 1 
442                functions['names'] = name
443                
444                pt = extruder_to_point(via, extruder, travel_type=travel_type, max_stepsize=max_stepsize)
445                cmd, head_position =  points_to_lcode_trap(pt, sig=sig,function_name=f"F{name}")
446                command += pre_print_command
447                command += cmd
448                
449                functions[idx] = (f"F{name};\n", head_position)
450                
451
452            else:
453                '''Just use precomputed path'''
454                cmd, head_position = functions[idx]
455                command += pre_print_command
456                command += cmd
457            
458            pt = extruder_to_point(point, via, travel_type=travel_type, max_stepsize=max_stepsize)
459            cmd, head_position =  points_to_lcode_trap(pt, sig=sig)
460            command += cmd
461            command += post_print_command
462            if add_optimisation_commands: command += 'O0;\n'
463            
464            
465        else:
466
467
468            pt = extruder_to_point(point, extruder, travel_type=travel_type, max_stepsize=max_stepsize, via=via)
469            cmd, head_position =  points_to_lcode_trap(pt, sig=sig)
470            command += pre_print_command
471            command += cmd
472            command += post_print_command
473            if add_optimisation_commands: command += 'O0;\n'
474    
475    return command, head_position