A Blog Exploring Digital Art

How to export from processing to povray

2012-01-29T17:26:00.000Z

When using toxiclibs libraries:-

If you are up for a bit of hacking you could recompile toxiclibscore.jar to include my POVWriter.java and a modified TriangleMesh.java library classes code available as a gist https://gist.github.com/1639360. Depends on creation of mesh.

When using hemesh libraries:-

If you are up for a bit of hacking you could recompile hemesh.jar to include my HET_POVWriter.java a modified HET_Export.java library classes code available as a gist https://gist.github.com/1658952. Depends on creation of mesh.

In both these cases the geometry is exported as 1 or more "declared" mesh2 objects in a povray inc, so a pov file needs to be created to include and use the mesh2 objects and to set the scene (camera, background etc) and to add texture. It doesn't harm to create an ini file to call the pov file (the ini file can be used to set the quality etc). It may be necessary to scale/and or translate the mesh2 objects in the pov file.Otherwise upto and including processing-1.5.1 use my custom povwriter library (most 3d sketches, captures color information) get the povwriter library here https://github.com/monkstone/povrender

What to expect, rendering using my povwriter library use a union of triangles, usefully lines/stroke can be output as a blob (a cylinder with a sphere at either end. You see triangle facets. The library is designed to allow for ray-tracing direct from the processing ide, currently both geometry and scene description are output to a pov file (with camera adjusted to aspect ratio using a declared variable in the ini file), the quality settings (accessible in the processing ide as enum constant) are output to an ini file.

Using my modified hemesh and toxiclibs library the mesh is exported in povray mesh2 format, and the default is include normals, hence output is rendered as a smooth surface, but ther is the option to not include the normals and facets are visible.

Here's my latest experiment exploring toxis implicit mesh function.

Exporting Hemesh HE_Mesh directly as PovRAY mesh2

2012-01-22T21:08:00.001Z

Well there is another library that I've hacked to export directly as a PovRAY mesh2.
Here is the result of the TwinIso example from the hemesh library (albeit slightly modified) exported as a PovRAY mesh2, here's the additional/modified code.

Here is the sketch code:-

PovRAY rendered with silver and copper textures

Twin toxiclibs Voxelizer sketches, united in one PovRAY scene

2012-01-19T22:08:00.000Z

Most kudos to Karsten Schmidt for his excellent toxiclibs libraries. I have hacked the toxiclibs core library to export PovRAY mesh2, and I think the results are excellent. Here's toxi voxelizer sketch (well twice run actually) rendered with Povray 3.7 as red marble. The mesh2 matches PovRAY internals and render pretty quickly. This is the result of combing two "inc" one for each run of the processing sketch, into 1 pov file. Run was controlled by an ini file. I know Karsten has experimented with Luxrender, but I like PovRAY the 3.7 beta version is multithreaded, and there is lot of stuff that is out there (textures/tutorials etc).

Applying the FTest to my TriangleMesh to PovRAY export

2012-01-19T20:03:00.001Z

If you've seen anything to to with my previous raytracing experiments, you will have come accross my FTest, here I have translated it to work with toxilibs mesh classes (using my totally custom version of toxiclibscore.jar which allows export as PovRAY mesh). As you will see from my "F" coding I'm not really that familiar with toxicilibs, Karsten would probably have a laugh:-

   1 import java.io.FileNotFoundException;
   2 import java.io.FileOutputStream;
   3 import java.io.PrintWriter;
   4 import java.util.logging.Level;
   5 import java.util.logging.Logger;
   6 import toxi.geom.AABB;
   7 import toxi.geom.Vec3D;
   8 import toxi.geom.mesh.TriangleMesh;
   9 import toxi.processing.*;
  10 
  11 
  12 /**
  13  * <p>FtestPOV demonstrates how to save a model as PovRAY mesh2
  14  * format to a generic Java PrintWriter (nested BufferedWriter/FileWriter would be better)
  15  * backend. inside the sketch folder.</p>
  16  */
  17 
  18 /*
  19 * Copyright (c) 2012 Martin Prout
  20  *
  21  * This library is free software; you can redistribute it and/or modify it
  22  * under the terms of the GNU Lesser General Public License as published by
  23  * the Free Software Foundation; either version 2.1 of the License, or (at
  24  * your option) any later version.
  25  *
  26  * http://creativecommons.org/licenses/LGPL/2.1/
  27  *
  28  * This library is distributed in the hope that it will be useful, but
  29  * WITHOUT ANY WARRANTY; without even the implied warranty of
  30  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
  31  * General Public License for more details.
  32  *
  33  * You should have received a copy of the GNU Lesser General Public License
  34  * along with this library; if not, write to the Free Software Foundation,
  35  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  36  */
  37 TriangleMesh mesh;
  38 ToxiclibsSupport gfx;
  39 
  40 void setup() {
  41   size(200, 200, P3D);
  42   gfx = new ToxiclibsSupport(this);
  43   // define a rounded cube using the SuperEllipsoid surface function
  44   AABB vert = AABB.fromMinMax(new Vec3D(-1.0f, -4.5f, -1.0f), new Vec3D(1.0f, 3.5f, 1.0f));
  45   AABB box = AABB.fromMinMax(new Vec3D(1.0f, 1.5f, -1.0f), new Vec3D(3.0f, 3.5f, 1.0f));
  46   AABB box2 = AABB.fromMinMax(new Vec3D(1.0f, -2.5f, -1.0f), new Vec3D(3.0f, -0.5f, 1.0f));
  47   mesh = (TriangleMesh) box.toMesh();
  48   mesh.addMesh((TriangleMesh) vert.toMesh());
  49   mesh.addMesh((TriangleMesh) box2.toMesh());
  50 }
  51 
  52 void draw() {
  53   translate(width/2, height/2);
  54   scale(15);
  55   rotateY(radians(-10));
  56   gfx.mesh(mesh);
  57 }
  58 
  59 void keyPressed() {
  60   if (key == 'e') {
  61     // attempt to create a PrintWriter and save to it 
  62     PrintWriter pw = null;
  63     try {
  64       String fileID = "FTest";//+(System.currentTimeMillis()/1000);
  65       pw = new PrintWriter(sketchPath(fileID + ".inc"));
  66       mesh.saveAsPOV(pw);
  67     } 
  68     catch (FileNotFoundException ex) {
  69       Logger.getLogger(ftest.class.getName()).log(Level.SEVERE, null, ex);
  70     } 
  71     finally {
  72       pw.flush();
  73       pw.close();
  74     }
  75     exit();
  76   }
  77     if (key == 's') {
  78     saveFrame("/home/tux/Fpde.png");
  79   }
  80 }
  81

This was always going to produce an upside 'F' an indeed it does here is the screen image:-

Saved sketch


PovRAY traced (no normals)

However as expected the raytraced image is the right way up, so now I will try and make the raytraced image upside down to match the sketch. (exported normals play badly with this sketch, so I have removed them here). This has now been done (by mutliplying y and z coordinates by -1 during PovRAY export) here is the resulting PovRAY traced image:-

Raytraced image with corrected library

Processing-2.0 PovRAY export Noise Surface Sketch

2012-01-18T20:30:00.000Z

As a proof of concept I re compiled my modified toxiclibs (supports export to PovRAY mesh2) against the latest version of processing-2.0 (svn 9103). I fired up the new version of processing (ant run) and ran a modified version of the toxicilibs Noise Surface Example sketch.

   1 import toxi.geom.*;
   2 import toxi.geom.mesh.*;
   3 import toxi.volume.*;
   4 import toxi.math.noise.*;
   5 import toxi.processing.*;
   6 
   7 /**
   8  * NoiseSurface demo showing how to utilize the IsoSurface class to
   9  * efficiently visualise volumetric data, in this case using 3D
  10  * SimplexNoise. The demo also shows how to save the generated mesh as
  11  * PovRAY inc file for later use in a PovRAY scene
  12  * Controls: Click mouse button to toggle rendering style between
  13  * shaded/wireframe. Press 's' to save generated mesh as PovRAY inc file
  14  */
  15 
  16 /*
  17  * Copyright (c) 2010 Karsten Schmidt. Modified 2012 by Martin Prout for 
  18  * PovRAY export instead of STL export
  19  *
  20  * This demo & library is free software; you can redistribute it and/or
  21  * modify it under the terms of the GNU Lesser General Public License as
  22  * published by the Free Software Foundation; either version 2.1 of the
  23  * License, or (at your option) any later version.
  24  *
  25  * http://creativecommons.org/licenses/LGPL/2.1/
  26  *
  27  * This library is distributed in the hope that it will be useful, but
  28  * WITHOUT ANY WARRANTY; without even the implied warranty of
  29  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
  30  * General Public License for more details.
  31  *
  32  * You should have received a copy of the GNU Lesser General Public License
  33  * along with this library; if not, write to the Free Software Foundation,
  34  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  35  */
  36 int DIMX = 192;
  37 int DIMY = 32;
  38 int DIMZ = 64;
  39 float ISO_THRESHOLD = 0.1;
  40 float NS = 0.03f;
  41 Vec3D SCALE = new Vec3D(3, 0.5, 1).scaleSelf(300);
  42 IsoSurface surface;
  43 TriangleMesh mesh;
  44 boolean isWireframe = false;
  45 float currScale = 1;
  46 ToxiclibsSupport gfx;
  47 
  48 void setup() {
  49   size(1024, 768, P3D);
  50   gfx = new ToxiclibsSupport(this);
  51   strokeWeight(0.5f);
  52   VolumetricSpace volume = new VolumetricSpaceArray(SCALE, DIMX, DIMY, DIMZ);
  53   // fill volume with noise
  54   for (int z = 0; z < DIMZ; z++) {
  55     for (int y = 0; y < DIMY; y++) {
  56       for (int x = 0; x < DIMX; x++) {
  57         volume.setVoxelAt(x, y, z, (float) SimplexNoise.noise(x * NS, y * NS, z * NS) * 0.5);
  58       }
  59     }
  60   }
  61   volume.closeSides();
  62   long t0 = System.nanoTime();
  63   // store in IsoSurface and compute surface mesh for the given threshold value
  64   mesh = new TriangleMesh("iso");
  65   surface = new HashIsoSurface(volume, 0.333333);
  66   surface.computeSurfaceMesh(mesh, ISO_THRESHOLD);
  67   float timeTaken = (System.nanoTime() - t0) * 1e-6f;
  68   println(timeTaken + "ms to compute " + mesh.getNumFaces() + " faces");
  69 }
  70 
  71 
  72 void draw() {
  73   background(128);
  74   translate(width / 2, height / 2, 0);
  75   rotateX(mouseY * 0.01);
  76   rotateY(mouseX * 0.01);
  77   scale(currScale);
  78   ambientLight(48, 48, 48);
  79   lightSpecular(230, 230, 230);
  80   directionalLight(255, 255, 255, 0, -0.5, -1);
  81   specular(255, 255, 255);
  82   shininess(16.0f);
  83   beginShape(TRIANGLES);
  84   if (isWireframe) {
  85     stroke(255);
  86     noFill();
  87   } 
  88   else {
  89     noStroke();
  90     fill(255);
  91   }
  92   gfx.mesh(mesh);
  93 }
  94 
  95 void mousePressed() {
  96   isWireframe = !isWireframe;
  97 }
  98 
  99 void keyPressed() {
 100   if (key == '-') {
 101     currScale = max(currScale - 0.1, 0.5);
 102   }
 103   if (key == '=') {
 104     currScale = min(currScale + 0.1, 10);
 105   }
 106   if (key == 's') {
 107     PrintWriter pw = createWriter(sketchPath("noise_surface.inc"));
 108     mesh.saveAsPOV(pw);
 109     pw.flush();
 110     pw.close();
 111     exit();
 112   }
 113 }
 114

NB now using PrintWriter............. see gist here

PovRAY rendered sketch

Exporting toxi TriangleMesh to PovRAY Mesh2 as an inc file

2012-01-18T11:45:00.001Z

This is a completly different approach to my previous exporting PovRAY from processing (but is very similar to the toxiclibs STL/OBJ export). The beauty of this approach it is not reliant on the processing renderer (my povwriter library relies on PGraphics3D, which seems to have gone away in processing-2.0). Further the generated mesh2 should be handled more efficiently by PovRAY than a union of triangles.
Here is a brief outline of the story so far:-

1. I did a "hg clone https://bitbucket.org/postspectacular/toxiclibs"
2. Set up a NetBeans Project with the source (including processing-1.5.1 core.jar as a library)
3. I copied OBJWriter (with refactoring) to POVWriter (see gist)
4. I modified the TriangleMesh class to include copies of OBJWriter methods as POVWriter methods (see gist)
5. I wrote tests based on the SuperEllipsoid example (see gist)
6. I wrote pov file to #include "SuperEllisoid.inc"

There was a mystery to solve the face indices were out of range, it was difficult to pinpoint too many faces/vertices.

Update 21/Jan/2012 from PovRAY tutorial
http://www.povray.org/documentation/view/3.6.1/293/
The indexes are ZERO-BASED! So the first item in each list has an index of zero.
Presumably list in wavefront obj are not see 7 and toxis code, seems strange though?

Update 22/Jan/2012 from obj specification

The indices start at ONE (thought comes to mind I could now probably hack the joons sunflow-renderer, to export everything bar spheres (and possibly cube) as a PovRAY mesh2 object).

7. I wrote a really simple test based the mesh of a single cube (and created a pov file to include "cube.pov") (see gist)

There is some kludge (which is presumably be required for STL or OBJ export) where faces indices are incremented by one. I removed this adjustment and the problem seemed to be solved (see update above).

8. I ran the SuperEllisoid example again, and here is the resulting PovRAY rendered sketch.

Update 25 Jan (I deleted old code) see revised code here which has been re factored to use PrintWriter, rather than OutputStream.

Rendered with PovRAY 3.7beta

Looks pretty good to me, unlike the cube where the normals seem to be odd, more work to be done there (normalizing the normals did not seem to help). From further reading calculating normals is not trivial.

Carried away with the success I thought I would have a go with the implicit function test, here is the result, intestingly I had to do this adjustment to fit the object in the scene scale<0.009, 0.009, 0.009>:-

Now rendered with Radiosity on took a bit longer, but it was worth it

Here is pretty funky red marble rendering

Context Free Art cfdg version 3 ( A charcoal drawing?)

2012-01-01T11:43:00.003Z

// original by bluesky translated for CF3 

startshape trunk
CF::Size = 1280, 1024
CF::ColorDepth = 16
CF::Color = 0
shape trunk
{ branch [s .5 b 0   h 20 sat 0 ]  }

shape branch
rule { branch [r 30  ] }
rule 0.01 { line [] }

shape line
{loop 300  [[r .1 x 2]] dot [] }

shape dot
rule { dot [y .1  ]  }
rule { 
  trail [ r 90 ] 
  trail[] }
rule 0.002 {line [r 90 h 0 ]  }
rule 0.002 {branch [r 90 h 30]  }
 
shape trail
{ loop 200 [[y 2 a -0.02]] grain [a -.1] }

shape grain
{ gr [] }

shape gr
rule { gr [ x 1 ] }
rule { gr [ x -1] } 
rule {SQUARE []}

As a Movie:-
ffmpeg -f image2 -i %3dcharcoal.png movie.mp4

Direct Writing of a processing Sphere as a PovRAY Sphere

2012-01-01T08:46:00.008Z

Here I have been experimenting again with how I could implement a PovRAY sphere, from a processing sketch. PovRAY handles the sphere primitive so well it makes any mesh exports look poor. However up till now the combination of the contrary coordinate systems, and camera conventions have defeated me, with this processing sketch I can see progress:-

   1 final float ADJ = 0.288675;  // this constant * width = processing depth adjustment
   2 List<String> arrayPOV;
   3 String light0 = String.format("light_source { <%.1f, %.1f, %.1f> colour White }", 100.0, 500.0, -300.0);
   4 String ground0 = "plane { <0.0, 1.0, 0.0>, 0.0\n\tpigment { NeonBlue }\n\tfinish {reflection 0.15}\n}";
   5 
   6 
   7 /**
   8 * Implements the direct write of a sketch sphere as a PovRAY sphere
   9 */
  10 void drawSphere(float sz) {
  11   PMatrix3D matrix = (PMatrix3D)this.g.getMatrix();
  12   float[] pos = matrix.get(new float[16]);
  13   sphere(sz);
  14   arrayPOV.add(String.format("sphere{<%.1f, %.1f, %.1f>,%.1f", pos[3], sz - pos[7], -pos[11], sz));
  15   arrayPOV.add("\ttexture{ pigment{ color White }");
  16   arrayPOV.add("\tfinish{ finish0 }\n}\n}");
  17 }
  18 
  19 void setup() {
  20   size(300, 200, P3D);
  21   camera(30.0, 100.0, 220.0, // eyeX, eyeY, eyeZ
  22   0.0, 0.0, 0.0, // centerX, centerY, centerZ
  23   0.0, 1.0, 0.0);
  24   arrayPOV = new ArrayList<String>();
  25   arrayPOV.add(String.format("#version %.1f;", 3.7));
  26   arrayPOV.add(String.format("global_settings {assumed_gamma %.1f}", 1.0));
  27   arrayPOV.add(String.format("#include \"%s\"", "colors.inc"));
  28   arrayPOV.add(String.format("#include \"%s\"", "skies.inc"));
  29   arrayPOV.add(String.format("#declare finish0 = finish{emission %.1f phong %.1f phong_size %.1f}", 0.1, 0.5, 10.0));
  30   arrayPOV.add(String.format("camera{\n\tlocation< %f, %f, -%f >", 30.0, 100.0, 220.0));
  31   arrayPOV.add(String.format("\tlook_at<0, 0, %.4f>", width*ADJ)); // Apply processing depth adjustment 
  32   arrayPOV.add(String.format("\tright<0, 0, %.4f>\n}", width * 1.0/height));
  33   arrayPOV.add(String.format("%s", light0));
  34   arrayPOV.add(String.format("sky_sphere {%s}", "S_Cloud3"));
  35   arrayPOV.add(String.format("%s", ground0));
  36   drawSphere(70);
  37   translate(125, 0, 0);
  38   drawSphere(60);
  39   try {
  40     PrintWriter pw = new PrintWriter(new FileWriter(dataPath("test.pov")));
  41     for (String line: arrayPOV) {
  42       pw.println(line);
  43     }
  44     pw.close();
  45   }
  46   catch (IOException e) {
  47   }
  48 }

The output PovRAY file is here:-

   1 #version 3.7;
   2 global_settings {assumed_gamma 1.0}
   3 #include "colors.inc"
   4 #include "skies.inc"
   5 #declare finish0 = finish{emission 0.1 phong 0.5 phong_size 10.0}
   6 camera{
   7         location< 30.000000, 100.000000, -220.000000 >
   8         look_at<0, 0, 86.6025>
   9         right<0, 0, 1.5000>
  10 }
  11 light_source { <100.0, 500.0, -300.0> colour White }
  12 sky_sphere {S_Cloud3}
  13 plane { <0.0, 1.0, 0.0>, 0.0
  14         pigment { NeonBlue }
  15         finish {reflection 0.15}
  16 }
  17 sphere{<0.0, 70.0, 243.5>,70.0
  18         texture{ pigment{ color White }
  19         finish{ finish0 }
  20 }
  21 }
  22 sphere{<123.9, 66.9, 228.1>,60.0
  23         texture{ pigment{ color White }
  24         finish{ finish0 }
  25 }
  26 }

PovRAY rendered balls on reflective plane (slightly fused)

In my view quite unnecessarily quirky in the PMatrix3D documentation m[3] is m03, m[7] is m13 and m[11] is m23 (seems to follow java 3*3 Matrix3D format?). Perhaps no more quirky than *.net where m11 is the value of the first row and first column of the Matrix3D structure (this at least is if for benefit of human we dispense with begin count of zero for benefit of computer?). ActionScript 3.0 has another convention, letters a ... l for first 3 rows of 4*4 matrix hence more readable transform formulae:-
x' = ax + by + cz + d
y' = ex + fy + gz + h
z' = ix + jy + kz + l