Mercurial > pygpibtoolkit / file comparison

comparison: pygpibtoolkit/plotter/hpgl_parser.py

pygpibtoolkit/plotter/hpgl_parser.py

changeset 104
916c255b3079
parent 91
f2a8f688dbc0
equal deleted inserted replaced
103:ad9b6e53ca68 104:916c255b3079
34 def parse(self, data): 34 def parse(self, data):
35 self.data = data 35 self.data = data
36 self.idx = 0 36 self.idx = 0
37 self.IN() 37 self.IN()
38 while self.idx < len(data): 38 while self.idx < len(data):
39 while data[self.idx] in [';','\n','\r', '\a', ' ']: 39 while data[self.idx] in ';\n\r\a ':
40 self.idx += 1 40 self.idx += 1
41 if data[self.idx] == chr(0x03): 41 if data[self.idx] == chr(0x03):
42 self.ESC() 42 self.ESC()
43 else: 43 else:
44 cmd = data[self.idx: self.idx+2].upper() 44 cmd = data[self.idx: self.idx+2].upper()
46 try: 46 try:
47 getattr(self, cmd)() 47 getattr(self, cmd)()
48 except AttributeError: 48 except AttributeError:
49 print("WARNING: received unknown command %s" % repr(cmd)) 49 print("WARNING: received unknown command %s" % repr(cmd))
50 50
51 while self.idx < len(data) and data[self.idx] in [';','\n','\r', '\a', ' ']: 51 while self.idx < len(data) and data[self.idx] in ';\n\r\a ':
52 self.idx += 1 52 self.idx += 1
53 53
54 def user_to_abs(self, pos): 54 def user_to_abs(self, pos):
55 """ 55 """
56 converts a position (x, y) given in user units to absolute 56 converts a position (x, y) given in user units to absolute
74 val = self.data[self.idx: idx2] 74 val = self.data[self.idx: idx2]
75 self.idx = idx2+1 75 self.idx = idx2+1
76 return val 76 return val
77 77
78 def polyline(self, values): 78 def polyline(self, values):
79 if (len(values)%2) == 1: 79 if (len(values) % 2) == 1:
80 # this is a syntax error in the HPGL data 80 # this is a syntax error in the HPGL data
81 values = values[:-1] 81 values = values[:-1]
82 values = numpy.array(values).reshape(-1, 2) 82 values = numpy.array(values).reshape(-1, 2)
83 # TODO use scaling 83 # TODO use scaling
84 # do plots 84 # do plots
85 values = numpy.r_[[self.pos], values] #add self.pos as 1st value 85 values = numpy.r_[[self.pos], values] # add self.pos as 1st value
86 if self.plot_mode == 'relative': 86 if self.plot_mode == 'relative':
87 values = values.cumsum(axis=0) 87 values = values.cumsum(axis=0)
88 if self.symbol_mode: 88 if self.symbol_mode:
89 self.plot_symbols(values[1:]) 89 self.plot_symbols(values[1:])
90 if self.pen_state == "down": 90 if self.pen_state == "down":
93 93
94 def plot_string(self, s): 94 def plot_string(self, s):
95 pass 95 pass
96 96
97 def get_window_for_paper(self): 97 def get_window_for_paper(self):
98 return 0,100,0,100 98 return (0, 100, 0, 100)
99
99 def get_scaling_points_for_paper(self): 100 def get_scaling_points_for_paper(self):
100 return 0,100,0,100 101 return (0, 100, 0, 100)
101 102
102 # effective plot methods; to be defined in subclasses (backends) 103 # effective plot methods; to be defined in subclasses (backends)
103 def plot_symbols(self, points): 104 def plot_symbols(self, points):
104 pass 105 pass
106
105 def plot_lines(self, points): 107 def plot_lines(self, points):
106 pass 108 pass
107 109
108 # HPGL-related methods 110 # HPGL-related methods
109 def ESC(self): 111 def ESC(self):
110 # print "ESC"
111 self.idx += 1 112 self.idx += 1
112 113
113 def OE(self): 114 def OE(self):
114 """ Output Error """ 115 """ Output Error """
115 pass 116 pass
116 117
117 def EC(self): 118 def EC(self):
118 """? what's this """ 119 """? what's this """
119 values = self.extract_value() 120 # values = self.extract_value()
121 pass
120 122
121 def OO(self): 123 def OO(self):
122 """idem""" 124 """idem"""
123 pass 125 pass
124 126
131 pass 133 pass
132 134
133 def DF(self): 135 def DF(self):
134 """ Default """ 136 """ Default """
135 self.pen = 0 137 self.pen = 0
136 self.pen_width = 1 # 1/300 inch 138 self.pen_width = 1 # 1/300 inch
137 self.pos = 0,0 139 self.pos = (0, 0)
138 self.char_set = "std" 140 self.char_set = "std"
139 self.plot_mode = 'absolute' 141 self.plot_mode = 'absolute'
140 self.char_direction = 1,0 142 self.char_direction = (1, 0)
141 self.line_type = 0 # 'solid' 143 self.line_type = 0 # 'solid'
142 self.pattern_len = 4 #percentage 144 self.pattern_len = 4 # percentage
143 self.window = self.get_window_for_paper() 145 self.window = self.get_window_for_paper()
144 self.char_size = 0.75, 1.5 #percentages 146 self.char_size = (0.75, 1.5) # percentages
145 self.symbol_mode = False 147 self.symbol_mode = False
146 self.tick_len = 0.5, 0.5 # % 148 self.tick_len = (0.5, 0.5) # %
147 self.std_char_set = 0 149 self.std_char_set = 0
148 self.alt_char_set = 0 150 self.alt_char_set = 0
149 self.selected_char_set = 0 151 self.selected_char_set = 0
150 self.char_slant = 0 # degrees 152 self.char_slant = 0 # degrees
151 self.scale = None 153 self.scale = None
152 self.str_terminator = chr(0x03) 154 self.str_terminator = chr(0x03)
153 self.chord_ang = 5 #degrees 155 self.chord_ang = 5 # degrees
154 self.fill_type = 'bidirectionnal', 1 156 self.fill_type = ('bidirectionnal', 1)
155 self.fill_distance = 1 # % 157 self.fill_distance = 1 # %
156 self.fill_slant = 0 # degrees 158 self.fill_slant = 0 # degrees
157 self.pen_thickness = 0.3 # mm 159 self.pen_thickness = 0.3 # mm
158 160
159 def IN(self): 161 def IN(self):
160 """ Initialize """ 162 """ Initialize """
161 self.DF() 163 self.DF()
162 self.pen_state = "up" 164 self.pen_state = "up"
163 self.rotation = 0 #degrees 165 self.rotation = 0 # degrees
164 self.scaling_points = self.get_scaling_points_for_paper() 166 self.scaling_points = self.get_scaling_points_for_paper()
165 167
166 def IP(self): 168 def IP(self):
167 """ Input Scale Point""" 169 """ Input Scale Point"""
168 values = self.extract_value() 170 values = self.extract_value()
186 188
187 def IW(self): 189 def IW(self):
188 values = self.extract_value() 190 values = self.extract_value()
189 if len(values) == 0: 191 if len(values) == 0:
190 self.window = self.get_window_for_paper() 192 self.window = self.get_window_for_paper()
191 elif len(value) == 4: 193 elif len(values) == 4:
192 self.window = tuple(values) 194 self.window = tuple(values)
193 195
194 def RO(self): 196 def RO(self):
195 values = self.extract_value() 197 values = self.extract_value()
196 if len(values) == 0: 198 if len(values) == 0:
228 def AA(self): 230 def AA(self):
229 """ Arc Absolute """ 231 """ Arc Absolute """
230 values = self.extract_value() 232 values = self.extract_value()
231 if len(values) in [3, 4]: 233 if len(values) in [3, 4]:
232 x, y, qc = values[:3] 234 x, y, qc = values[:3]
233 if len(values)==4: 235 if len(values) == 4:
234 qd = values[-1] 236 qd = values[-1] # noqa
235 else: 237 else:
236 qd = self.chord_ang 238 qd = self.chord_ang # noqa
237 # TODO : plot arc 239 # TODO : plot arc
238 print("plotting an arc") 240 # print("plotting an arc")
241
239 def AR(self): 242 def AR(self):
240 """ Arc Relative """ 243 """ Arc Relative """
241 values = self.extract_value() 244 # values = self.extract_value()
242 # TODO 245 # TODO
243 246
244 def CI(self): 247 def CI(self):
245 """ Circle Plot""" 248 """ Circle Plot"""
246 values = self.extract_value() 249 # values = self.extract_value()
247 # TODO 250 # TODO
248 251
249 def EA(self): 252 def EA(self):
250 """Edge Rectangle Absolute""" 253 """Edge Rectangle Absolute"""
251 values = self.extract_value() 254 # values = self.extract_value()
252 # TODO 255 # TODO
253 256
254 def ER(self): 257 def ER(self):
255 """Edge Rectangle Relative""" 258 """Edge Rectangle Relative"""
256 values = self.extract_value() 259 # values = self.extract_value()
257 # TODO 260 # TODO
258 261
259 def EW(self): 262 def EW(self):
260 """ Edge Wedge """ 263 """ Edge Wedge """
261 values = self.extract_value() 264 # values = self.extract_value()
262 # TODO 265 # TODO
263 266
264 def RA(self): 267 def RA(self):
265 """ Fill Rectangle Absolute """ 268 """ Fill Rectangle Absolute """
266 values = self.extract_value() 269 # values = self.extract_value()
267 # TODO 270 # TODO
268 271
269 def RR(self): 272 def RR(self):
270 """ Fill Rectangle Relative """ 273 """ Fill Rectangle Relative """
271 values = self.extract_value() 274 # values = self.extract_value()
272 # TODO 275 # TODO
273 276
274 def WG(self): 277 def WG(self):
275 """ Fill Wedge """ 278 """ Fill Wedge """
276 values = self.extract_value() 279 # values = self.extract_value()
277 # TODO 280 # TODO
278 281
279 def FT(self): 282 def FT(self):
280 """ Fill Type """ 283 """ Fill Type """
281 values = self.extract_value() 284 # values = self.extract_value()
282 # TODO 285 # TODO
283 286
284 def LT(self): 287 def LT(self):
285 """ Line Type """ 288 """ Line Type """
286 values = self.extract_value() 289 values = self.extract_value()
287 290
288 if len(values)==0: 291 if len(values) == 0:
289 self.line_type = 0 #'solid' 292 self.line_type = 0 # 'solid'
290 else: 293 else:
291 self.line_type = values[0] 294 self.line_type = values[0]
292 if len(values)>1: 295 if len(values) > 1:
293 self.pattern_len = values[1] 296 self.pattern_len = values[1]
294 297
295 def PW(self): 298 def PW(self):
296 """ Pen Width """ 299 """ Pen Width """
297 values = self.extract_value() 300 values = self.extract_value()
312 if len(values) == 1: 315 if len(values) == 1:
313 self.pen = values[0] 316 self.pen = values[0]
314 317
315 def TL(self): 318 def TL(self):
316 """ Tick Len """ 319 """ Tick Len """
317 values = self.extract_value() 320 # values = self.extract_value()
318 # TODO 321 # TODO
319 322
320 def XT(self): 323 def XT(self):
321 """ X-axis Tick """ 324 """ X-axis Tick """
322 # TODO 325 # TODO
323 print("X ticks") 326 # print("X ticks")
327 pass
324 328
325 def YT(self): 329 def YT(self):
326 """ X-axis Tick """ 330 """ X-axis Tick """
327 # TODO 331 # TODO
328 print("Y ticks") 332 # print("Y ticks")
333 pass
329 334
330 def PT(self): 335 def PT(self):
331 """ Pen Thickness Select """ 336 """ Pen Thickness Select """
332 values = self.extract_value() 337 values = self.extract_value()
333 if len(values) == 0: 338 if len(values) == 0:
372 values = self.extract_string() 377 values = self.extract_string()
373 self.plot_string(values) 378 self.plot_string(values)
374 x, y = self.pos 379 x, y = self.pos
375 values = values.split('\n') 380 values = values.split('\n')
376 if self.char_size == "absolute": 381 if self.char_size == "absolute":
377 x += len(values[-1]) * self.char_width *1016/2.54 382 x += len(values[-1]) * self.char_width * 1016 / 2.54
378 y += (len(values)-1) * self.char_height *1016/2.54 383 y += (len(values)-1) * self.char_height * 1016 / 2.54
379 else: 384 else:
380 x0, x1, y0, y1 = self.scale 385 x0, x1, y0, y1 = self.scale
381 dx = x1-x0 386 dx = x1-x0
382 dy = y1-y0 387 dy = y1-y0
383 x += len(values[-1]) * self.char_width / 100.0 * dx 388 x += len(values[-1]) * self.char_width / 100.0 * dx
384 y += (len(values)-1) * self.char_height / 100.0 * dy 389 y += (len(values)-1) * self.char_height / 100.0 * dy
385 390
386 #print "LB pos[%s] %s -> %s"%(repr(values), self.pos, (x,y))
387 self.pos = [x, y] 391 self.pos = [x, y]
388 392
389 def get_char_size(self): 393 def get_char_size(self):
390 if self.char_size == "absolute": 394 if self.char_size == "absolute":
391 x = self.char_width *1016/2.54 395 x = self.char_width * 1016 / 2.54
392 y = self.char_height *1016/2.54 396 y = self.char_height * 1016 / 2.54
393 else: 397 else:
394 x0, x1, y0, y1 = self.scale 398 x0, x1, y0, y1 = self.scale
395 dx = x1-x0 399 dx = x1-x0
396 dy = y1-y0 400 dy = y1-y0
397 x = self.char_width / 100.0 * dx 401 x = self.char_width / 100.0 * dx
400 404
401 def DI(self): 405 def DI(self):
402 """ Absolute Direction """ 406 """ Absolute Direction """
403 values = self.extract_value() 407 values = self.extract_value()
404 if len(values) == 0: 408 if len(values) == 0:
405 self.char_direction = 1.0, 0.0 409 self.char_direction = (1.0, 0.0)
406 elif len(values) == 2: 410 elif len(values) == 2:
407 self.char_direction = values 411 self.char_direction = values
408 412
409 def DR(self): 413 def DR(self):
410 """ Relative Direction """ 414 """ Relative Direction """
411 values = self.extract_value() 415 values = self.extract_value()
412 if len(values) == 0: 416 if len(values) == 0:
413 self.char_direction = 1.0, 0.0 417 self.char_direction = (1.0, 0.0)
414 elif len(values) == 2: 418 elif len(values) == 2:
415 # TODO : compute as percentages 419 # TODO : compute as percentages
416 self.char_direction = values 420 self.char_direction = values
417 421
418 def CP(self): 422 def CP(self):
421 # TODO 425 # TODO
422 if len(values) == 0: 426 if len(values) == 0:
423 values = 0, 1 427 values = 0, 1
424 x, y = self.pos 428 x, y = self.pos
425 if self.char_size == "absolute": 429 if self.char_size == "absolute":
426 x += values[0] * self.char_width *1016/2.54 430 x += values[0] * self.char_width * 1016 / 2.54
427 y += values[1] * self.char_height *1016/2.54 431 y += values[1] * self.char_height * 1016 / 2.54
428 else: 432 else:
429 x0, x1, y0, y1 = self.scale 433 x0, x1, y0, y1 = self.scale
430 dx = x1-x0 434 dx = x1-x0
431 dy = y1-y0 435 dy = y1-y0
432 x += values[0] * self.char_width / 100.0 * dx 436 x += values[0] * self.char_width / 100.0 * dx
433 y += values[1] * self.char_height / 100.0 * dy 437 y += values[1] * self.char_height / 100.0 * dy
434 #print "CB pos[%s] %s -> %s"%(repr(values), self.pos, (x,y))
435 self.pos = [x, y] 438 self.pos = [x, y]
436 439
437 def SI(self): 440 def SI(self):
438 """ Set Absolute Character Size """ 441 """ Set Absolute Character Size """
439 values = self.extract_value() 442 values = self.extract_value()
440 self.char_size = "absolute" 443 self.char_size = "absolute"
441 if len(values) == 0: 444 if len(values) == 0:
442 self.char_width = 0.1879 # cm 445 self.char_width = 0.1879 # cm
443 self.char_height = 0.2690 # cm 446 self.char_height = 0.2690 # cm
444 elif len(values) == 2: 447 elif len(values) == 2:
445 self.char_width, self.char_height = values 448 self.char_width, self.char_height = values
446 449
447 def SR(self): 450 def SR(self):
448 """ Set Relative Character Size """ 451 """ Set Relative Character Size """
449 values = self.extract_value() 452 values = self.extract_value()
450 self.char_size = "relative" 453 self.char_size = "relative"
451 if len(values) == 0: 454 if len(values) == 0:
452 self.char_width = 0.75 # percentage 455 self.char_width = 0.75 # percentage
453 self.char_height = 1.5 # id 456 self.char_height = 1.5 # id
454 elif len(values) == 2: 457 elif len(values) == 2:
455 self.char_width, self.char_height = values 458 self.char_width, self.char_height = values
456 459
457 def SL(self): 460 def SL(self):
458 """ Character Slant """ 461 """ Character Slant """
459 values = self.extract_value() 462 # values = self.extract_value()
460 # TODO 463 # TODO
464 pass
461 465
462 def UC(self): 466 def UC(self):
463 """ User Defined Character """ 467 """ User Defined Character """
464 values = self.extract_value() 468 # values = self.extract_value()
465 # TODO 469 # TODO
470 pass
471
466 472
467 if __name__ == '__main__': 473 if __name__ == '__main__':
468 import sys 474 import sys
469 data = open(sys.argv[1]).read() 475 data = open(sys.argv[1]).read()
470 476

Mercurial Repository: pygpibtoolkit

mercurial