Processing Forum

Screen name:
pepsimaxxie

pepsimaxxie's Profile

1 Posts

0 Responses

0 Followers

Activity Trend

Last 30 days

Loading Chart...

Show:

Expanded view
List view

error loading font

[1 Reply]
- 08-Jun-2013 02:08 AM
- Forum: Programming Questions
Hello all, when compiling the peice of code attached evrything goes well except loading the font. The error I receive is:
"Could not load forn Univers-66.vlw. Make sure that the font has been copied to the data folder of your sketch."

The Univers-66.vlw file is located in the folder "data" in the same map as where the .pde is located.

The code I'm using for this is:

Copiled using: processing 1.2.1 (not 2.0 since not all libraries are compatible with that), windows x64 ultimate
1. // Load font
2. font = loadFont("Univers-66.vlw");
3. textFont(font);
The whole peice of code:
2. /******************************************************************************************
3. * Magnetometer Sampling Sketch for Razor AHRS v1.4.1
4. * 9 Degree of Measurement Attitude and Heading Reference System
5. * for Sparkfun "9DOF Razor IMU" and "9DOF Sensor Stick"
6. *
7. * Released under GNU GPL (General Public License) v3.0
8. * Copyright (C) 2011-2012 Quality & Usability Lab, Deutsche Telekom Laboratories, TU Berlin
9. * Written by Peter Bartz (peter-bartz@gmx.de)
10. *
11. * Infos, updates, bug reports and feedback:
12. * http://dev.qu.tu-berlin.de/projects/sf-razor-9dof-ahrs
13. ******************************************************************************************/
15. /*
16. NOTE: There seems to be a bug with the serial library in the latest Processing
17. versions 1.5 and 1.5.1: "WARNING: RXTX Version mismatch ...". The previous version
18. 1.2.1 works fine and is still available on the web.
19. */
21. /*
22. NOTE: You have to install a library, before this sketch can be run!
23. We're using EJML for matrix math, because it's really fast:
24. http://code.google.com/p/java-matrix-benchmark/
25. Also, it's released under LGPL, which fits well with our GPL.
26. Get the library from: http://code.google.com/p/efficient-java-matrix-library/ (you only need
27. the .jar file), find your Processing "libraries" folder (normally this is Processing/libraries
28. in your user documents folder). Create a folder "EJML" inside "libraries",
29. create a folder "library" inside "EJML" and put the .jar inside. Rename to EJML.jar. So you
30. should have "libraries/EJML/library/EJML.jar". Restart Processing and you're good.
31. More info on installing libraries in Processing: http://wiki.processing.org/w/How_to_Install_a_Contributed_Library
32. */
33. import org.ejml.data.*;
34. import org.ejml.simple.*;
35. import org.ejml.ops.*;
37. import java.io.*;
39. // IF THE SKETCH CRASHES OR HANGS ON STARTUP, MAKE SURE YOU ARE USING THE RIGHT SERIAL PORT:
40. // 1. Have a look at the Processing console output of this sketch.
41. // 2. Look for the serial port list and find the port you need (it's the same as in Arduino).
42. // 3. Set your port number here:
43. final static int SERIAL_PORT_NUM = 0;
44. // 4. Try again.
48. import processing.opengl.*;
49. import processing.serial.*;
51. final static int SERIAL_PORT_BAUD_RATE = 57600;
53. final static int NUM_MAGN_SAMPLES = 10000;
54. float magnetom[][] = new float[NUM_MAGN_SAMPLES][3];
55. int magnetomIndex = 0;
57. PFont font;
58. Serial serial;
60. boolean synched = false;
62. // Skip incoming serial stream data until token is found
63. boolean readToken(Serial serial, String token) {
64. // Wait until enough bytes are available
65. if (serial.available() < token.length())
66. return false;
68. // Check if incoming bytes match token
69. for (int i = 0; i < token.length(); i++) {
70. if (serial.read() != token.charAt(i))
71. return false;
72. }
74. return true;
75. }
77. // Global setup
78. void setup() {
79. // Setup graphics
80. size(800, 800, OPENGL);
81. smooth();
82. noStroke();
83. frameRate(50);
84. colorMode(HSB);
86. // Load font
87. font = loadFont("Univers-66.vlw");
88. textFont(font);
90. // Setup serial port I/O
91. println("AVAILABLE SERIAL PORTS:");
92. println(Serial.list());
93. String portName = Serial.list()[SERIAL_PORT_NUM];
94. println();
95. println("HAVE A LOOK AT THE LIST ABOVE AND SET THE RIGHT SERIAL PORT NUMBER IN THE CODE!");
96. println(" -> Using port " + SERIAL_PORT_NUM + ": " + portName);
97. serial = new Serial(this, portName, SERIAL_PORT_BAUD_RATE);
98. }
100. void setupRazor() {
101. println("Trying to setup and synch Razor...\n");
103. // On Mac OSX and Linux (Windows too?) the board will do a reset when we connect, which is really bad.
104. // See "Automatic (Software) Reset" on http://www.arduino.cc/en/Main/ArduinoBoardProMini
105. // So we have to wait until the bootloader is finished and the Razor firmware can receive commands.
106. // To prevent this, disconnect/cut/unplug the DTR line going to the board. This also has the advantage,
107. // that the angles you receive are stable right from the beginning.
108. delay(3000); // 3 seconds should be enough
110. // Set Razor output parameters
111. serial.write("#osrb"); // Turn on binary output of raw sensor data
112. serial.write("#o1"); // Turn on continuous streaming output
113. serial.write("#oe0"); // Disable error message output
115. // Synch with Razor
116. serial.clear(); // Clear input buffer up to here
117. serial.write("#s00"); // Request synch token
118. }
120. float readFloat(Serial s) {
121. // Convert from little endian (Razor) to big endian (Java) and interpret as float
122. return Float.intBitsToFloat(s.read() + (s.read() << 8) + (s.read() << 16) + (s.read() << 24));
123. }
125. void skipBytes(Serial s, int numBytes) {
126. for (int i = 0; i < numBytes; i++) {
127. s.read();
128. }
129. }
131. void draw() {
132. // Reset scene
133. lights();
135. // Sync with Razor
136. if (!synched) {
137. background(0);
138. textAlign(CENTER);
139. fill(255);
140. text("Connecting to Razor...", width/2, height/2, -200);
142. if (frameCount == 2)
143. setupRazor(); // Set ouput params and request synch token
144. else if (frameCount > 2)
145. synched = readToken(serial, "#SYNCH00\r\n"); // Look for synch token
146. return;
147. }
149. // Output "max samples reached" message?
150. if (magnetomIndex == NUM_MAGN_SAMPLES - 1) {
151. fill(0, 255, 255);
152. text("MAX NUMBER OF SAMPLES REACHED!", width/2, 0, -250);
153. println("MAX NUMBER OF SAMPLES REACHED!");
154. }
156. pushMatrix(); {
157. translate(width/2, height/2, -900);
159. // Draw sphere and background once
160. if (magnetomIndex == 0) {
161. background(0);
162. noFill();
163. stroke(255);
164. sphereDetail(10);
165. sphere(400);
166. fill(200);
167. text("Press 'r' to reset. Press SPACE to output calibration parameters to console and quit.", 0, 1100, -600);
168. }
170. // Read and draw new sample
171. if (magnetomIndex < NUM_MAGN_SAMPLES && serial.available() >= 36) {
172. // Read all available magnetometer data from serial port
173. while (serial.available() >= 36) {
174. // Skip accel data
175. skipBytes(serial, 12);
176. // Read magn data
177. magnetom[magnetomIndex][0] = readFloat(serial); // x
178. magnetom[magnetomIndex][1] = readFloat(serial); // y
179. magnetom[magnetomIndex][2] = readFloat(serial); // z
180. // Skip gyro data
181. skipBytes(serial, 12);
182. }
184. // Draw new point
185. fill((magnetom[magnetomIndex][2] + 800) / 8, 255, 255);
186. noStroke();
187. translate(magnetom[magnetomIndex][0], magnetom[magnetomIndex][1], magnetom[magnetomIndex][2]);
188. sphere(5);
190. magnetomIndex++;
191. }
192. } popMatrix();
193. }
195. void keyPressed() {
196. switch (key) {
197. case '0': // Turn Razor's continuous output stream off
198. serial.write("#o0");
199. break;
200. case '1': // Turn Razor's continuous output stream on
201. serial.write("#o1");
202. break;
203. case 'f': // Request one single yaw/pitch/roll frame from Razor (use when continuous streaming is off)
204. serial.write("#f");
205. break;
206. case ' ': // Calculate and output calibration parameters, output binary magnetometer samples file, quit
207. case ENTER:
208. case RETURN:
209. outputCalibration(); // Do the magic
210. exit(); // We're done
211. break;
212. case 'r': // Reset samples and clear screen
213. magnetomIndex = 0;
214. break;
215. }
216. }
218. void outputCalibration() {
219. /* ELLIPSOID FITTING CODE */
220. // Adaption of 'ellipsoid_fit' matlab code by Yury Petrov (See 'Matlab' folder
221. // that came with the archive containing this file).
223. // Check if we have at least 9 sample points
224. if (magnetomIndex < 9) {
225. println("ERROR: not enough magnetometer samples. We need at least 9 points.");
226. exit();
227. }
229. // Seperate xyz magnetometer values and make column vectors
230. SimpleMatrix x = new SimpleMatrix(magnetomIndex, 1);
231. SimpleMatrix y = new SimpleMatrix(magnetomIndex, 1);
232. SimpleMatrix z = new SimpleMatrix(magnetomIndex, 1);
233. for (int i = 0; i < magnetomIndex; i++) {
234. x.set(i, magnetom[i][0]);
235. y.set(i, magnetom[i][1]);
236. z.set(i, magnetom[i][2]);
237. }
240. /*
241. % fit ellipsoid in the form Ax^2 + By^2 + Cz^2 + 2Dxy + 2Exz + 2Fyz + 2Gx + 2Hy + 2Iz = 1
242. D = [ x .* x, ...
243. y .* y, ...
244. z .* z, ...
245. 2 * x .* y, ...
246. 2 * x .* z, ...
247. 2 * y .* z, ...
248. 2 * x, ...
249. 2 * y, ...
250. 2 * z ]; % ndatapoints x 9 ellipsoid parameters
251. */
252. SimpleMatrix D = new SimpleMatrix(x.numRows(), 9);
253. D.insertIntoThis(0, 0, x.elementMult(x));
254. D.insertIntoThis(0, 1, y.elementMult(y));
255. D.insertIntoThis(0, 2, z.elementMult(z));
256. D.insertIntoThis(0, 3, x.elementMult(y).scale(2));
257. D.insertIntoThis(0, 4, x.elementMult(z).scale(2));
258. D.insertIntoThis(0, 5, y.elementMult(z).scale(2));
259. D.insertIntoThis(0, 6, x.scale(2));
260. D.insertIntoThis(0, 7, y.scale(2));
261. D.insertIntoThis(0, 8, z.scale(2));
263. /*
264. % solve the normal system of equations
265. v = ( D' * D ) \ ( D' * ones( size( x, 1 ), 1 ) );
266. */
267. SimpleMatrix tempA = D.transpose().mult(D);
268. SimpleMatrix ones = x.copy(); ones.set(1);
269. SimpleMatrix tempB = D.transpose().mult(ones);
270. SimpleMatrix v = tempA.solve(tempB);
272. /*
273. % form the algebraic form of the ellipsoid
274. A = [ v(1) v(4) v(5) v(7); ...
275. v(4) v(2) v(6) v(8); ...
276. v(5) v(6) v(3) v(9); ...
277. v(7) v(8) v(9) -1 ];
278. */
279. SimpleMatrix A = new SimpleMatrix(new double[][]
280. {{v.get(0), v.get(3), v.get(4), v.get(6)},
281. {v.get(3), v.get(1), v.get(5), v.get(7)},
282. {v.get(4), v.get(5), v.get(2), v.get(8)},
283. {v.get(6), v.get(7), v.get(8), -1.0}});
285. /*
286. % find the center of the ellipsoid
287. center = -A( 1:3, 1:3 ) \ [ v(7); v(8); v(9) ];
288. */
289. SimpleMatrix center = A.extractMatrix(0, 3, 0, 3).scale(-1).solve(v.extractMatrix(6, 9, 0, 1));
291. /*
292. % form the corresponding translation matrix
293. T = eye( 4 );
294. T( 4, 1:3 ) = center';
295. */
296. SimpleMatrix T = SimpleMatrix.identity(4);
297. T.insertIntoThis(3, 0, center.transpose());
299. /*
300. % translate to the center
301. R = T * A * T';
302. % solve the eigenproblem
303. [ evecs evals ] = eig( R( 1:3, 1:3 ) / -R( 4, 4 ) );
304. radii = sqrt( 1 ./ diag( evals ) );
305. */
306. SimpleMatrix R = T.mult(A).mult(T.transpose());
307. SimpleEVD evd = R.extractMatrix(0, 3, 0, 3).divide(-R.get(3, 3)).eig();
309. SimpleMatrix evecs = new SimpleMatrix(3, 3);
310. evecs.insertIntoThis(0, 0, evd.getEigenVector(0));
311. evecs.insertIntoThis(0, 1, evd.getEigenVector(1));
312. evecs.insertIntoThis(0, 2, evd.getEigenVector(2));
314. SimpleMatrix radii = new SimpleMatrix(new double[][]
315. {{Math.sqrt(1.0 / evd.getEigenvalue(0).getReal()),
316. Math.sqrt(1.0 / evd.getEigenvalue(1).getReal()),
317. Math.sqrt(1.0 / evd.getEigenvalue(2).getReal())}});
319. //center.print();
320. //evecs.print();
321. //radii.print();
324. /* CALCULATE COMPENSATION MATRIX */
325. // Adaption of my 'magnetometer_calibration' matlab code. (See 'Matlab' folder
326. // that came with the archive containing this file).
327. /*
328. % compensate distorted magnetometer data
329. % e_eigenvecs is an orthogonal matrix, so ' can be used instead of inv()
330. scale = inv([e_radii(1) 0 0; 0 e_radii(2) 0; 0 0 e_radii(3)]) * min(e_radii); % scaling matrix
331. map = e_eigenvecs'; % transformation matrix to map ellipsoid axes to coordinate system axes
332. invmap = e_eigenvecs; % inverse of above
333. comp = invmap * scale * map;
334. */
335. SimpleMatrix scale = new SimpleMatrix(3, 3);
336. scale.zero();
337. scale.set(0, 0, radii.get(0));
338. scale.set(1, 1, radii.get(1));
339. scale.set(2, 2, radii.get(2));
340. scale = scale.invert().scale(CommonOps.elementMin(radii.getMatrix()));
342. SimpleMatrix map = evecs.transpose();
343. SimpleMatrix invmap = evecs;
344. SimpleMatrix comp = invmap.mult(scale).mult(map);
345. //comp.print();
347. /* OUTPUT RESULTS */
348. // Output magnetometer samples file
349. try {
350. println("Trying to write " + magnetomIndex + " sample points to file magnetom.float ...");
351. FileOutputStream fos = new FileOutputStream(sketchPath("magnetom.float"));
352. DataOutputStream dos = new DataOutputStream(fos);
353. for (int i = 0; i < magnetomIndex; i++) {
354. dos.writeFloat(magnetom[i][0]);
355. dos.writeFloat(magnetom[i][1]);
356. dos.writeFloat(magnetom[i][2]);
357. }
358. fos.close();
359. println("Done.");
360. } catch(Exception e) {
361. println("Exception: " + e.toString());
362. }
363. println("\n");
365. // Output calibration
366. System.out.printf("In the Razor_AHRS.pde (or .ino), under 'SENSOR CALIBRATION' find the section that reads 'Magnetometer (extended calibration)'\n");
367. System.out.printf("Replace the existing 3 lines with these:\n\n");
368. System.out.printf("#define CALIBRATION__MAGN_USE_EXTENDED true\n");
369. System.out.printf("const float magn_ellipsoid_center[3] = {%.6g, %.6g, %.6g};\n", center.get(0), center.get(1), center.get(2));
370. System.out.printf("const float magn_ellipsoid_transform[3][3] = {{%.6g, %.6g, %.6g}, {%.6g, %.6g, %.6g}, {%.6g, %.6g, %.6g}};\n",
371. comp.get(0), comp.get(1), comp.get(2), comp.get(3), comp.get(4), comp.get(5), comp.get(6), comp.get(7), comp.get(8));
372. println("\n");
373. }

«Prev
Next »