├── README.org
├── neosmartpen.py
├── pen2pdf.py
└── pen2reveal.py


/README.org:
--------------------------------------------------------------------------------
 1 | #+TITLE: README for python-neosmartpen
 2 | #+AUTHOR: Alexei Gilchrist
 3 | #+DATE: 2019-06-15
 4 | 
 5 | Python library for reading and manipulating Neo Smartpen data
 6 | 
 7 | * neosmartpen
 8 | 
 9 | Requirements: just python3
10 | 
11 | Usage:
12 | #+BEGIN_SRC python
13 |   import neosmartpen
14 |   pages = neosmartpen.parse_pages(path_to_neonotes_file)
15 | #+END_SRC
16 | 
17 |  - ~pages~ will be a list of page dictionaries:
18 |  - Page dictionaries contain a bunch of parameters and a list of ~strokes~:
19 |  |--------------+-------------------------|
20 |  | Field        | Description             |
21 |  |--------------+-------------------------|
22 |  | neo          | 'neo' (check)           |
23 |  | file_version | File version            |
24 |  | note_type    |                         |
25 |  | page         | Page number             |
26 |  | width        | Notebook width          |
27 |  | height       | Notebook height         |
28 |  | ctime        | Created timestamp (ms)  |
29 |  | mtime        | Modified timestamp (ms) |
30 |  | modified     | Flag if data modified   |
31 |  | strokes      | Stroke list             |
32 |  |--------------+-------------------------|
33 |  - ~strokes~ are dictionaries with properties like color, and list of ~dots~:
34 |  |-----------+------------------------|
35 |  | Field     | Description            |
36 |  |-----------+------------------------|
37 |  | type      | 0=stroke, 1=voice memo |
38 |  | color     | (A,R,G,B) [0-255]      |
39 |  | thickness | [0-2]                  |
40 |  | time      | Start timestamp (ms)   |
41 |  | dots      | List of point data     |
42 |  | extra     | ?                      |
43 |  |-----------+------------------------|
44 |  - ~dots~ are (x,y,pressure,dt) tuples that define the stroke. 
45 | ~dt~ is the time delta between points in ms.
46 |  
47 | * pen2pdf
48 | 
49 | Convert neonotes file to multi-page pdf.
50 | 
51 | Requirements: ~python3~ and ~reportlab~ 
52 | 
53 | Usage:  
54 | #+BEGIN_SRC bash
55 |   pen2pdf.py pen_file.zip output.pdf 
56 |   pen2pdf.py -h
57 | #+END_SRC
58 | 
59 | * pen2reveal
60 | 
61 | Convert neonotes file to ~index.html~ for use with [[https://revealjs.com][reveal.js]]
62 | 
63 | Usage:
64 | #+BEGIN_SRC bash
65 |   pen2reveal.py neonotes_file index.html 
66 |   pen2reveal -h
67 | #+END_SRC
68 | 


--------------------------------------------------------------------------------
/neosmartpen.py:
--------------------------------------------------------------------------------
  1 | import os, sys, re, glob
  2 | import struct
  3 | from zipfile import ZipFile
  4 | 
  5 | def parse_pagedata(raw):
  6 |     '''
  7 |     Parse the binary page.data format into python structure
  8 |     '''
  9 |     # Spec from https://github.com/NeoSmartpen/Documentations/blob/master/NeoNote_data_Eng_V1.0.pdf
 10 |     # Appears to be little endian
 11 |     # page.data:
 12 |     #
 13 |     # bytes desc
 14 |     # 3  'neo' (verification string)
 15 |     # 4  File version
 16 |     # 4  Note type
 17 |     # 4  Page Number
 18 |     # 4  (Float 32) notebook width
 19 |     # 4  (Float 32) notebook height
 20 |     # 8  created timestamp (millisecond)
 21 |     # 8  modified timestamp (millisecond)
 22 |     # 1  Flag if data modified
 23 |     # 4  number of strokes
 24 |     # ... stroke data ...
 25 |     # 4  Length of guid string
 26 |     # *  Page guid string (for evernote?)
 27 |     #
 28 |     # stroke:
 29 |     # 1  Type (0=stroke, 1=voice memo)
 30 |     # 4  Color 32 bits RGBA
 31 |     # 1  Thickness (0,1,2)
 32 |     # 4  Number of dots
 33 |     # 8  Start timestamp (millisecond)
 34 |     # ... dots ...
 35 |     # 1  Length of extra data (0-255)
 36 |     # ... extra data ... (Pen type: 0=Neo smart pen, 1=pem from neo notes, 2=highlighter from neo notes)
 37 |     #
 38 |     # dot data 13 bytes:
 39 |     # 4  x (float 32)
 40 |     # 4  y (Float 32)
 41 |     # 4  pressure (Float 32)
 42 |     # 1  time diff from previous dot
 43 |     #
 44 |     # x and y where normalised by max(width,height)
 45 | 
 46 |     o = struct.unpack('<3s3i2f2Q?I', raw[:44])
 47 | 
 48 |     if o[0]!=b'neo':
 49 |         raise Exception("Not a valid neopen data file")
 50 | 
 51 |     data = {'neo':o[0], 'file_version':o[1], 'note_type':o[2], 'page':o[3],
 52 |             'width':o[4], 'height':o[5], 'ctime':o[6], 'mtime':o[7],
 53 |             'modified':o[8], 'strokes':[]}
 54 | 
 55 |     nstrokes = o[9]
 56 | 
 57 |     start = 44
 58 |     for n in range(nstrokes):
 59 |         o = struct.unpack('<BIBIQ', raw[start:start+18])
 60 |         #import pudb; pudb.set_trace()
 61 | 
 62 |         if o[0]==1:
 63 |             # audio registration, not a pen stroke, skip it.
 64 |             start+=108
 65 |             continue
 66 | 
 67 |         col = [(o[1]>>(8*i))&0xff for i in range(3,-1,-1)]
 68 | 
 69 |         stroke = {'type':o[0], 'color':col, 'thickness':o[2], 'time':o[4]}
 70 |         ndots = o[3]
 71 |         start2 = start+18
 72 |         dots = []
 73 |         if ndots > 1000:
 74 |             # something has gone wrong
 75 |             raise Exception('Something has gone wrong parsing dots in stroke')
 76 |         for m in range(ndots):
 77 |             d = struct.unpack('<fffB', raw[start2:start2+13])
 78 |             dots.append(d)  #x,y,pressure,dt
 79 |             start2 += 13
 80 | 
 81 |         stroke['dots'] = dots
 82 | 
 83 |         N = struct.unpack('<B', raw[start2:start2+1])[0]
 84 |         extra = struct.unpack('<%dc'%(N), raw[start2+1:start2+N+1])
 85 |         data['strokes'].append(stroke)
 86 |         start=start2+1+N
 87 | 
 88 |     return data
 89 | 
 90 | def parse_pages(path):
 91 |     '''
 92 |     Parse neonotes file and extract stroke data on each page
 93 |     '''
 94 | 
 95 |     parsedpages = []
 96 | 
 97 |     if os.path.isdir(path):
 98 |         pages = glob.glob(path+'/*/*/page.data')
 99 |         pagepaths = []
100 |         for p in pages:
101 |             so = re.search('Data/(\d+)\.page_store', p)
102 |             n=int(so.group(1))
103 |             pagepaths.append((n,p))
104 | 
105 |         pagepaths.sort(key=lambda x: x[1])
106 | 
107 |         for n,p in pagepaths:
108 |             fp = open(p, 'rb')
109 |             raw = fp.read()
110 |             fp.close()
111 |             data = parse_pagedata(raw)
112 |             parsedpages.append(data)
113 | 
114 |     else:
115 |         # Assumed to be a zip file
116 |         zip = ZipFile(path)
117 |         pages = [p for p in zip.namelist() if p.endswith('page.data')]
118 |         pagepaths = []
119 |         for p in zip.namelist():
120 |             if p.endswith('page.data'):
121 |                 so = re.search('Data/(\d+)\.page_store', p)
122 |                 n=int(so.group(1))
123 |                 pagepaths.append((n,p))
124 | 
125 |         pagepaths.sort(key=lambda x: x[1])
126 | 
127 |         for n,p in pagepaths:
128 |             zp = zip.open(p)
129 |             raw = zp.read()
130 |             zp.close()
131 |             data = parse_pagedata(raw)
132 |             parsedpages.append(data)
133 | 
134 |     return parsedpages
135 | 
136 | 
137 | if __name__ == "__main__":
138 |     pages = parse_pages(sys.argv[1])
139 | 
140 |     for n,data in enumerate(pages):
141 |         print('Page ', n+1)
142 |         for m,s in enumerate(data['strokes']):
143 |             print('\nStroke {}'.format(m))
144 |             if s['type']==0:
145 |                 print('col:',s['color'], ' thickness:', s['thickness'])
146 |                 for x,y,p,dt in s['dots']:
147 |                     print('x:{x:.2f}, y:{y:.2f}, p:{p:.2f}, dt:{dt:2d}'.format(**locals()))
148 |             else:
149 |                 print('audio')
150 | 
151 | def bounding_box(strokes):
152 |     '''
153 |     Return the bounding box of the strokes
154 |     (x_min, y_min, x_max, y_max)
155 |     '''
156 |     xm,ym=None,None
157 |     xM,yM=None,None
158 | 
159 |     for s in strokes:
160 |         for x,y,p,dt in s['dots']:
161 |             if xm==None:
162 |                 xm,ym=x,y
163 |                 xM,yM=x,y
164 |             else:
165 |                 xm,ym=min(xm,x),min(ym,y)
166 |                 xM,yM=max(xM,x),max(yM,y)
167 |     return (xm,ym,xM,yM)
168 | 
169 | def col2hex(col):
170 |     hexcol = "#%02x%02x%02x"%(col[1],col[2],col[3])
171 |     return hexcol
172 | 
173 | 
174 | 
175 | 


--------------------------------------------------------------------------------
/pen2pdf.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | import sys
 3 | import neosmartpen
 4 | from reportlab.lib.pagesizes import A4
 5 | from reportlab.pdfgen import canvas
 6 | import argparse
 7 | import logging
 8 | logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.INFO)
 9 | 
10 | # Daniel's 3 Box control regions:
11 | # 4 6 12 13
12 | # 4 15 12 22
13 | # 4 24 12 31
14 | 
15 | parser = argparse.ArgumentParser(description='Convert Neo SmatPen zip file to PDF.')
16 | parser.add_argument('input',  help='Input zip file')
17 | parser.add_argument('output', help='Output PDF file')
18 | parser.add_argument('-t', nargs=4, default=(4,6,12,13), metavar=('x1','y1','x2','y2'), type=int, help='Transition trigger region')
19 | 
20 | args = parser.parse_args()
21 | 
22 | TRANSITION_REGION = args.t
23 | 
24 | def transition(x,y):
25 |     if TRANSITION_REGION[0]<x<TRANSITION_REGION[2] and \
26 |        TRANSITION_REGION[1]<y<TRANSITION_REGION[3]:
27 |         return True
28 |     else:
29 |         return False
30 | 
31 | c = canvas.Canvas(args.output, bottomup=0)
32 | 
33 | pages = neosmartpen.parse_pages(args.input)
34 | c.setAuthor("pen2pdf")
35 | c.setTitle("Notes")
36 | c.setSubject("Notes generated with pen2pdf")
37 | 
38 | def addPage(canvas, page, strokes):
39 |     canvas.setLineCap(1)
40 |     if page['height']>page['width']:
41 |         PAGE=(A4[0],A4[1])
42 |     else:
43 |         PAGE=(A4[1],A4[0])
44 | 
45 |     canvas.setPageSize(PAGE)
46 |     S = PAGE[0]/page['width']
47 | 
48 |     for s in strokes:
49 |         dots = s['dots']
50 |         x0,y0,p0,dt0 = dots[0]
51 | 
52 |         for x,y,p,dt in dots[1:]:
53 |             # the factor 1.5 visually matches the thickness in neonote app 
54 |             canvas.setLineWidth((s['thickness']+1.5)*p)
55 |             col = s['color']
56 |             canvas.setStrokeColorRGB(col[1]/255,col[2]/255,col[3]/255)
57 |             canvas.line(S*x0,S*y0,S*x,S*y)
58 |             x0,y0,p0=x,y,p
59 | 
60 |     canvas.showPage()
61 | 
62 | 
63 | for n,data in enumerate(pages):
64 |     logging.info('Generating Page: %d', n+1)
65 |     strokes = []
66 |     for s in data['strokes']:
67 |         dots = s['dots']
68 |         x0,y0,p0,dt0 = dots[0]
69 |         if transition(x0,y0):
70 |             addPage(c, data, strokes)
71 |         else:
72 |             strokes.append(s)
73 |     addPage(c, data, strokes)
74 | 
75 | c.save()
76 | 
77 | 


--------------------------------------------------------------------------------
/pen2reveal.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | import sys
  3 | import neosmartpen
  4 | import argparse
  5 | import logging
  6 | logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.INFO)
  7 | 
  8 | parser = argparse.ArgumentParser(description='Convert Neo SmatPen file to reveal.js slides')
  9 | parser.add_argument('input',  help='Input smartpen file')
 10 | parser.add_argument('output', help='Output html file')
 11 | parser.add_argument('-t', nargs=4, default=(0,0,10,10), metavar=('x1','y1','x2','y2'), type=int, help='Transition trigger region')
 12 | 
 13 | # <?xml version="1.0"?>
 14 | # <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" 
 15 | #               "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
 16 | # <svg width="134" height="38" xmlns="http://www.w3.org/2000/svg">
 17 | 
 18 | args = parser.parse_args()
 19 | 
 20 | TRANSITION_REGION = args.t
 21 | 
 22 | def transition(x,y):
 23 |     if TRANSITION_REGION[0]<x<TRANSITION_REGION[2] and \
 24 |        TRANSITION_REGION[1]<y<TRANSITION_REGION[3]:
 25 |         return True
 26 |     else:
 27 |         return False
 28 | 
 29 | TEMPLATE = '''<html>
 30 | 	<head>
 31 | 		<meta charset="utf-8">
 32 | 		<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
 33 | 
 34 | 		<title>reveal.js</title>
 35 | 
 36 | 		<link rel="stylesheet" href="css/reset.css">
 37 | 		<link rel="stylesheet" href="css/reveal.css">
 38 | 		<link rel="stylesheet" href="css/theme/white.css">
 39 | 
 40 | 		<!-- Theme used for syntax highlighting of code -->
 41 | 		<link rel="stylesheet" href="lib/css/monokai.css">
 42 | 
 43 | 		<!-- Printing and PDF exports -->
 44 | 		<script>
 45 | 			var link = document.createElement( 'link' );
 46 | 			link.rel = 'stylesheet';
 47 | 			link.type = 'text/css';
 48 | 			link.href = window.location.search.match( /print-pdf/gi ) ? 'css/print/pdf.css' : 'css/print/paper.css';
 49 | 			document.getElementsByTagName( 'head' )[0].appendChild( link );
 50 | 		</script>
 51 | 	</head>
 52 | 	<body>
 53 | 		<div class="reveal">
 54 | 			<div class="slides">
 55 |                <section>
 56 | %s
 57 |                </section>
 58 | 			</div>
 59 | 		</div>
 60 | 
 61 | 		<script src="js/reveal.js"></script>
 62 | 
 63 | 		<script>
 64 | 			// More info about config & dependencies:
 65 | 			// - https://github.com/hakimel/reveal.js#configuration
 66 | 			// - https://github.com/hakimel/reveal.js#dependencies
 67 | 			Reveal.initialize({
 68 | 				dependencies: [
 69 | 					{ src: 'plugin/markdown/marked.js' },
 70 | 					{ src: 'plugin/markdown/markdown.js' },
 71 | 					{ src: 'plugin/notes/notes.js', async: true },
 72 | 					{ src: 'plugin/highlight/highlight.js', async: true }
 73 | 				]
 74 | 			});
 75 | 		</script>
 76 | 	</body>
 77 | </html>
 78 | '''
 79 | 
 80 | pages = neosmartpen.parse_pages(args.input)
 81 | 
 82 | def makeFragment(page, strokes, S=10):
 83 |     paths = []
 84 | 
 85 |     if len(strokes)==0:
 86 |         return ''
 87 | 
 88 |     # Find limits of fragment
 89 |     xm,ym,xM,yM = neosmartpen.bounding_box(strokes)
 90 | 
 91 |     for s in strokes:
 92 |         dots = s['dots']
 93 |         x0,y0,p0,dt0 = dots[0]
 94 |         D=[]
 95 | 
 96 |         for x,y,p,dt in dots[1:]:
 97 |             L='<line x1="%.2f" y1="%.2f" x2="%.2f" y2="%.2f" stroke-width="%.2f"/>\n'%((S*(x0-xm)), (S*(y0-ym)), (S*(x-xm)), (S*(y-ym)), (s['thickness']+4)*p)
 98 | 
 99 |             D.append( L )
100 |             x0,y0,p0=x,y,p
101 | 
102 |         hexcol = neosmartpen.col2hex(s['color'])
103 |         g = '<g stroke="%s" stroke-linecap="round">%s</g>'%(hexcol, ' '.join(D))
104 |         paths.append(g)
105 | 
106 |     # style="position: fixed; left: 0px; top: 0px;"
107 |     svg = '<div class="fragment">\n<svg width="%d" height="%d">\n'%(round(S*(xM-xm)), round(S*(yM-ym)))
108 |     for p in paths:
109 |         svg+=p
110 |     svg+='</svg></div>\n'
111 | 
112 |     return svg
113 | 
114 | for n,data in enumerate(pages):
115 |     logging.info('Generating Slide: %d', n+1)
116 |     fragments = []
117 |     strokes = []
118 | 
119 |     for s in data['strokes']:
120 |         dots = s['dots']
121 |         x0,y0,p0,dt0 = dots[0]
122 |         if transition(x0,y0):
123 |             f = makeFragment(data, strokes)
124 |             fragments.append(f)
125 |             strokes = []
126 |         else:
127 |             strokes.append(s)
128 |     f = makeFragment(data, strokes)
129 |     fragments.append(f)
130 | 
131 | frags = '\n'.join(fragments)
132 | 
133 | fp = open(args.output, 'w')
134 | fp.write(TEMPLATE%frags)
135 | fp.close()
136 | 
137 | 


--------------------------------------------------------------------------------