Processing Forum

Screen name:
arrmin

arrmin's Profile

2 Posts

6 Responses

0 Followers

Activity Trend

Last 30 days

Loading Chart...

Show:

Expanded view
List view

Rotating voxels in toxiclibs' VolumetricSpace using Quaternions?

[0 Replies]
- 22-Apr-2012 11:18 AM
- Forum: Contributed Library Questions
Ok, I drew stuff in a VolumetricSpace using this blue-illuminated table tennis ball.

It looks very 2d at the beginning but just take a look at the end of the video, where I rotate it: https://vimeo.com/40036315

Ok, I rotate it. (the following is not in the video)

The problem:

Sure enough, the coordinate system of the VolumetricSpace got rotated too.

So when I draw now, my tabletennis ball and the newly drawn line won't be congruent(wont overlap) any more.

I thought if I still want them to be congruent, the VolumetricSpace shouldn't be rotated. - only the voxels inside of it should be rotated.

So I experimented with quaternions http://stackoverflow.com/questions/9843298/java-quaternion-3d-rotation-implementation

It didn't work out that well after a few hours.

I also saw there's a quaternion toxiclibs class, but I couldn't figure out how to use it for this task.

I also thought maybe I could use proscene to accomplish this task, but I don't exactly know how I would do that yet.

Could someone give me some advice?

Here is what I worked out so far for rotation of voxels in a VolumetricSpace:

You can press 'r' to invoke this function call:

rotation3D(points, Math.toRadians(10), 1, 0, 0);

It rotates the voxels 10 degrees around the x-axis.

I couldn't figure out how to rotate the cube in the example around it's own center. Furthermore, the voxel's positions get kind of messy.
2. import java.util.ArrayList;
4. import processing.core.*;
5. import processing.opengl.*;
6. import javax.media.opengl.GL;
7. import toxi.geom.*;
8. import toxi.geom.mesh.*;
9. import toxi.volume.*;
11. public class Test extends PApplet {
13. public static void main(String[] args) {
14. PApplet.main(new String[] { "--present", "Test" });
15. }
18. ArrayList<Integer> points = new ArrayList<Integer>();
20. int DIMX = 48;
21. int DIMY = 48;
22. int DIMZ = 48;
24. float ISO_THRESHOLD = 0.1f;
25. float NS = 0.03f;
26. Vec3D SCALE = new Vec3D(1, 1, 1).scaleSelf(300);
28. float currScale = 1;
30. VolumetricSpace volume = new VolumetricSpaceArray(SCALE, DIMX, DIMY, DIMZ);
31. VolumetricSpace newVolume = new VolumetricSpaceArray(SCALE, DIMX, DIMY, DIMZ);
32. TriangleMesh mesh;
34. PGraphicsOpenGL pgl;
35. GL gl;
37. // used to store mesh on GPU
38. VBO vbo;
40. public void rotation3D(ArrayList<Integer> points, double angle, int x,
41. int y, int z) {
42. // ArrayList<Integer> newpoints = points;
44. for (int i = 0; i < points.size(); i += 3) {
45. int x_old = points.get(i).intValue();
46. int y_old = points.get(i + 1).intValue();
47. int z_old = points.get(i + 2).intValue();
48. double[] initial = { 1, 0, 0, 0 };
49. double[] total = new double[4];
50. double[] local = new double[4];
52. // components for local quaternion
53. // w
54. local[0] = Math.cos(0.5 * angle);
55. // x
56. local[1] = x * Math.sin(0.5 * angle);
57. // y
58. local[2] = y * Math.sin(0.5 * angle);
59. // z
60. local[3] = z * Math.sin(0.5 * angle);
61. // local = magnitude(local);
63. // components for final quaternion Q1*Q2
64. // w = w1w2 - x1x2 - y1y2 - z1z2
65. total[0] = local[0] * initial[0] - local[1] * initial[1] - local[2]
66. * initial[2] - local[3] * initial[3];
67. // x = w1x2 + x1w2 + y1z2 - z1y2
68. total[1] = local[0] * initial[1] + local[1] * initial[0] + local[2]
69. * initial[3] - local[3] * initial[2];
70. // y = w1y2 - x1z2 + y1w2 + z1x2
71. total[2] = local[0] * initial[2] - local[1] * initial[3] + local[2]
72. * initial[0] + local[3] * initial[1];
73. // z = w1z2 + x1y2 - y1x2 + z1w2
74. total[3] = local[0] * initial[3] + local[1] * initial[2] - local[2]
75. * initial[1] + local[3] * initial[0];
77. // new x,y,z of the 3d point using rotation matrix made from the
78. // final quaternion
79. int x_new = (int) ((1 - 2 * total[2] * total[2] - 2 * total[3]
80. * total[3])
81. * x_old
82. + (2 * total[1] * total[2] - 2 * total[0] * total[3])
83. * y_old + (2 * total[1] * total[3] + 2 * total[0]
84. * total[2])
85. * z_old);
86. int y_new = (int) ((2 * total[1] * total[2] + 2 * total[0]
87. * total[3])
88. * x_old
89. + (1 - 2 * total[1] * total[1] - 2 * total[3] * total[3])
90. * y_old + (2 * total[2] * total[3] + 2 * total[0]
91. * total[1])
92. * z_old);
93. int z_new = (int) ((2 * total[1] * total[3] - 2 * total[0]
94. * total[2])
95. * x_old
96. + (2 * total[2] * total[3] - 2 * total[0] * total[1])
97. * y_old + (1 - 2 * total[1] * total[1] - 2 * total[2]
98. * total[2])
99. * z_old);
100. points.set(i, x_new);
101. points.set(i + 1, y_new);
102. points.set(i + 2, z_new);
104. }
105. }
107. public void setup() {
108. size(1024, 768, OPENGL);
110. // fill volume
111. for (int z = 0; z < DIMZ; z++) {
112. for (int y = 0; y < DIMY; y++) {
113. for (int x = 0; x < DIMX; x++) {
114. //fill volume with a box
115. if(x<24+10 && y<24+10 && z<24+10 && x>24-10 && y>24-10 && z>24-10){
116. volume.setVoxelAt(x, y, z, 1);
117. }
118. points.add(x);
119. points.add(y);
120. points.add(z);
121. }
122. }
123. }
125. prepareVolume(volume);
126. }
128. public void prepareVolume(VolumetricSpace vol){
129. vol.closeSides();
130. // store in IsoSurface and compute surface mesh for the given threshold
131. // value
132. mesh = new TriangleMesh("iso");
133. IsoSurface surface = new HashIsoSurface(vol, 0.333333f);
134. surface.computeSurfaceMesh(mesh, ISO_THRESHOLD);
136. // get opengl related references
137. pgl = (PGraphicsOpenGL) g;
138. gl = pgl.gl;
140. // update lighting information
141. mesh.computeVertexNormals();
142. // get flattened vertex array
143. float[] verts = mesh.getMeshAsVertexArray();
144. // in the array each vertex has 4 entries (XYZ + 1 spacing)
145. int numV = verts.length / 4;
147. // create a VBO instance and set buffers from mesh
148. vbo = new VBO(gl, numV);
149. vbo.updateVertices(verts);
150. vbo.updateNormals(mesh.getVertexNormalsAsArray());
151. int[] normals = new int[mesh.getVertexNormalsAsArray().length];
152. for (int i = 0; i < normals.length; i++) {
153. print(normals[i]);
154. }
155. }
156. public void draw() {
157. background(128);
158. translate(width / 2, height / 2, 0);
160. scale(currScale);
162. // need to switch to pure OpenGL mode first
163. pgl.beginGL();
164. glLights();
165. // render mesh as triangle soup
166. vbo.render(GL.GL_TRIANGLES);
167. // back to processing
168. pgl.endGL();
169. }
171. // setup some lights/material for OpenGL
172. void glLights() {
173. gl.glEnable(GL.GL_LIGHTING);
174. gl.glEnable(GL.GL_LIGHT0);
175. gl.glEnable(GL.GL_COLOR_MATERIAL);
176. gl.glEnable(GL.GL_BLEND);
177. gl.glBlendFunc(GL.GL_ONE, GL.GL_ONE);
178. gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT, new float[] {
179. -1.0f, -1.0f, 1.0f, 0.5f }, 0);
180. }
182. public void rotate() {
184. rotation3D(points, Math.toRadians(10), 1, 0, 0);
186. newVolume.clear();
187. int i = 0;
188. for (int z = 0; z < DIMZ; z++) {
189. for (int y = 0; y < DIMY; y++) {
190. for (int x = 0; x < DIMX; x++) {
191. // int xp = Math.abs(points.get(i).intValue());
192. // int yp = Math.abs(points.get(i + 1).intValue());
193. // int zp = Math.abs(points.get(i + 2).intValue());
194. int xp = points.get(i).intValue();
195. int yp = points.get(i + 1).intValue();
196. int zp = points.get(i + 2).intValue();
197. i+=3;
198. /*println("x "+xp);
199. println("y "+yp);
200. println("z "+zp);*/
201. if(xp > 0 && yp > 0 && zp > 0){
202. int ix = volume.getIndexFor(x, y, z);
203. float vox = volume.getVoxelAt(ix);
204. int newIx = newVolume.getIndexFor(xp, yp, zp);
205. newVolume.setVoxelAt(newIx,vox);
206. }
207. }
208. }
209. }
211. prepareVolume(newVolume);
212. }
214. public void keyPressed() {
215. if (key == '-')
216. currScale = max(currScale - 0.1f, 0.5f);
217. if (key == '=')
218. currScale = min(currScale + 0.1f, 10);
219. if (key == 's') {
220. // save mesh as STL or OBJ file
221. mesh.saveAsSTL(sketchPath("noise.stl"));
222. }
223. if (key == 'r') {
224. rotate();
225. }
226. }
227. }
using toxi's vbo wrapper
2. /**
3. * A reusable, barebones wrapper for OpenGL Vertex Buffer Objects. Only
4. * handles actual vertex, normal and color buffers and assumes they can be dynamically
5. * modified/updated.
6. *
7. * @author Karsten Schmidt <info at postspectacular.com>
8. */
9. import javax.media.opengl.GL;
10. import processing.opengl.*;
11. import com.sun.opengl.util.BufferUtil;
13. public class VBO {
15. final int STRIDE = BufferUtil.SIZEOF_FLOAT * 4;
17. int numVertices;
18. int[] vertID = new int[] {-1};
19. int[] normID = new int[] {-1};
20. int[] colorID = new int[] {-1};
22. private GL gl;
24. public VBO(GL gl, int num) {
25. this.gl = gl;
26. numVertices = num;
27. }
29. public void cleanup() {
30. gl.glDeleteBuffers(1, vertID, 0);
31. gl.glDeleteBuffers(1, normID, 0);
32. gl.glDeleteBuffers(1, colorID, 0);
33. }
35. void initBuffer(int[] bufferID) {
36. gl.glGenBuffers(1, bufferID, 0);
37. gl.glBindBuffer(GL.GL_ARRAY_BUFFER, bufferID[0]);
38. gl.glBufferData(GL.GL_ARRAY_BUFFER, numVertices * STRIDE, null,
39. GL.GL_DYNAMIC_DRAW);
40. gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
41. }
43. public void render(int shapeID) {
44. // gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
45. // check if we need to use normals?
46. if (normID[0] != -1) {
47. gl.glEnableClientState(GL.GL_NORMAL_ARRAY);
48. gl.glBindBuffer(GL.GL_ARRAY_BUFFER, normID[0]);
49. gl.glNormalPointer(GL.GL_FLOAT, STRIDE, 0);
50. }
51. // check if we need to use colors?
52. if (colorID[0] != -1) {
53. gl.glEnableClientState(GL.GL_COLOR_ARRAY);
54. gl.glBindBuffer(GL.GL_ARRAY_BUFFER, colorID[0]);
55. gl.glColorPointer(4, GL.GL_FLOAT, STRIDE, 0);
56. }
57. gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
58. gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vertID[0]);
59. gl.glVertexPointer(3, GL.GL_FLOAT, STRIDE, 0);
60. gl.glDrawArrays(shapeID, 0, numVertices);
61. gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
62. if (normID[0] != -1) {
63. gl.glDisableClientState(GL.GL_NORMAL_ARRAY);
64. }
65. if (colorID[0] != -1) {
66. gl.glDisableClientState(GL.GL_COLOR_ARRAY);
67. }
68. }
70. protected void updateBuffer(int id, float[] data) {
71. gl.glBindBuffer(GL.GL_ARRAY_BUFFER, id);
72. gl.glMapBuffer(GL.GL_ARRAY_BUFFER, GL.GL_WRITE_ONLY)
73. .asFloatBuffer().put(data);
74. gl.glUnmapBuffer(GL.GL_ARRAY_BUFFER);
75. gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
76. }
78. public void updateColors(float[] colors) {
79. if (colorID[0] == -1) {
80. initBuffer(colorID);
81. }
82. updateBuffer(colorID[0], colors);
83. }
85. public void updateNormals(float[] normals) {
86. if (normID[0] == -1) {
87. initBuffer(normID);
88. }
89. updateBuffer(normID[0], normals);
90. }
92. public void updateVertices(float[] vertices) {
93. if (vertID[0] == -1) {
94. initBuffer(vertID);
95. }
96. updateBuffer(vertID[0], vertices);
97. }
98. }

Processing workshops for beginners in Berlin

[3 Replies]
- 03-Jul-2011 03:23 PM
- Forum: Events and Opportunities
I proposed a class at the Public School Berlin to have weekly processing workshops for beginners starting in August. I can teach and it's free. We should also go to Processing Berlin on August the 11th.

click:

http://berlin.thepublicschool.org/class/3571

Maybe you'd like to join us?

«Prev
Next »