├── settings.txt
├── data
    └── desert_depth_4_3.png
├── license.txt
├── Pointcloud_Render.pde
├── Settings.pde
├── Controls.pde
├── Data.pde
├── Cam.pde
├── PointExport.pde
└── Encoding.pde


/settings.txt:
--------------------------------------------------------------------------------
1 | Output Filename
2 | output
3 | 
4 | Output Format (OBJ, PLY, PNG, ASC, BIN)
5 | ply


--------------------------------------------------------------------------------
/data/desert_depth_4_3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/n1ckfg/Pointcloud_Render/HEAD/data/desert_depth_4_3.png


--------------------------------------------------------------------------------
/license.txt:
--------------------------------------------------------------------------------
 1 | Pointcloud_Render was developed with support from:
 2 |    Canada Council on the Arts
 3 |    Eyebeam Art + Technology Center
 4 | 
 5 | Copyright (c) 2017 Nick Fox-Gieg
 6 | http://fox-gieg.com
 7 | 
 8 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 9 | 
10 | The MIT License <http://www.opensource.org/licenses/mit-license.php>
11 | 
12 | Permission is hereby granted, free of charge, to any person obtaining a copy
13 | of this software and associated documentation files (the "Software"), to deal
14 | in the Software without restriction, including without limitation the rights
15 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
16 | copies of the Software, and to permit persons to whom the Software is
17 | furnished to do so, subject to the following conditions:
18 | 
19 | The above copyright notice and this permission notice shall be included in
20 | all copies or substantial portions of the Software.
21 | 
22 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
25 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
28 | THE SOFTWARE.


--------------------------------------------------------------------------------
/Pointcloud_Render.pde:
--------------------------------------------------------------------------------
 1 | int sW = 640;
 2 | int sH = 360;
 3 | ArrayList imgNames;
 4 | int counter = 0;
 5 | String filePath = "render";
 6 | String fileType = "obj"; //obj, ply, png
 7 | float zscale = 3; //orig 3, 1 looks better in 2D image but 3 looks better for OBJ, PLY
 8 | float zskew = 10;
 9 | //**************************************
10 | boolean firstRun = true;
11 | 
12 | Cam cam;
13 | float[][] gray;
14 | 
15 | String[] numFiles; 
16 | 
17 | PImage img, buffer;
18 | 
19 | void setup() {
20 |   size(50, 50, P3D);
21 |   Settings settings = new Settings("settings.txt");
22 |   if (fileType.toLowerCase().equals("png")) {
23 |     zscale = 1; //looks better if saving frames
24 |   } else {
25 |     zscale = 3;
26 |   }
27 |   chooseFolderDialog();
28 |   while (firstRun) {
29 |     try {
30 |       if (imgNames.size() > 0) img = loadImage((String) imgNames.get(counter));
31 |     } catch(Exception e) { }
32 |   }
33 |   sW = img.width;
34 |   sH = img.height;
35 |   surface.setSize(sW, sH);
36 |   cam = new Cam();
37 |   gray = new float[sH][sW];
38 |   stroke(255);
39 | }
40 | 
41 | void draw() {
42 |   background(0);
43 |   img = loadImage((String) imgNames.get(counter));
44 |   exportMain();
45 |   //~~~ 
46 |   //pushMatrix();
47 |   //translate(-sW / 2, -sH / 2);  
48 |   int step = 2;
49 |   for (int y = step; y < sH; y += step) {
50 |     float planephase = 0.5 - (y - (sH / 2)) / zskew;
51 |     for (int x = step; x < sW; x += step){
52 |       stroke(gray[y][x]);
53 |       //point(x, y, (gray[y][x] - planephase) * zscale);
54 |       line(x, y, (gray[y][x] - planephase) * zscale, x+1, y, (gray[y][x] - planephase) * zscale);
55 |     }
56 |   }
57 |   //popMatrix();
58 |   
59 |   cam.run();
60 |   //~~~
61 |   if (fileType.toLowerCase().equals("png")) saveFrame(filePath + "/" + fileName + zeroPadding(counter+1,imgNames.size()) + "." + fileType);
62 |   if (counter < imgNames.size()) counter++;
63 |   if (counter == imgNames.size()) {
64 |     openAppFolderHandler();
65 |     exit();
66 |   }
67 | }
68 | 
69 | static final int getGray(color value) { 
70 |   return max((value >> 16) & 0xff, (value >> 8 ) & 0xff, value & 0xff);
71 | }
72 | 
73 | String zeroPadding(int _val, int _maxVal){
74 |   String q = ""+_maxVal;
75 |   return nf(_val,q.length());
76 | }
77 | 
78 | //~~~   END   ~~~


--------------------------------------------------------------------------------
/Settings.pde:
--------------------------------------------------------------------------------
 1 | class Settings {
 2 |   
 3 |   String[] data;
 4 |   
 5 |   Settings(String _s) {
 6 |     try {
 7 |       data = loadStrings(_s);
 8 |       for (int i=0;i<data.length;i++) {
 9 |         if (data[i].equals("Output Filename")) fileName = setString(data[i+1]);
10 |         if (data[i].equals("Output Format (OBJ, PLY, PNG, ASC, BIN)")) fileType = setString(data[i+1].toLowerCase());
11 |       }
12 |     } catch(Exception e) {
13 |       println("Couldn't load settings file. Using defaults.");
14 |     }
15 |   }
16 | 
17 |   int setInt(String _s) {
18 |     return int(_s);
19 |   }
20 | 
21 |   float setFloat(String _s) {
22 |     return float(_s);
23 |   }
24 | 
25 |   boolean setBoolean(String _s) {
26 |     return boolean(_s);
27 |   }
28 | 
29 |   String setString(String _s) {
30 |     return ""+(_s);
31 |   }
32 |   
33 |   color setColor(String _s) {
34 |     color endColor = color(0);
35 |     int commaCounter=0;
36 |     String sr = "";
37 |     String sg = "";
38 |     String sb = "";
39 |     String sa = "";
40 |     int r = 0;
41 |     int g = 0;
42 |     int b = 0;
43 |     int a = 0;
44 | 
45 |     for (int i=0;i<_s.length();i++) {
46 |         if (_s.charAt(i)!=char(' ') && _s.charAt(i)!=char('(') && _s.charAt(i)!=char(')')) {
47 |           if (_s.charAt(i)==char(',')){
48 |             commaCounter++;
49 |           }else{
50 |           if (commaCounter==0) sr += _s.charAt(i);
51 |           if (commaCounter==1) sg += _s.charAt(i);
52 |           if (commaCounter==2) sb += _s.charAt(i); 
53 |           if (commaCounter==3) sa += _s.charAt(i);
54 |          }
55 |        }
56 |      }
57 | 
58 |     if (sr!="" && sg=="" && sb=="" && sa=="") {
59 |       r = int(sr);
60 |       endColor = color(r);
61 |     }
62 |     if (sr!="" && sg!="" && sb=="" && sa=="") {
63 |       r = int(sr);
64 |       g = int(sg);
65 |       endColor = color(r, g);
66 |     }
67 |     if (sr!="" && sg!="" && sb!="" && sa=="") {
68 |       r = int(sr);
69 |       g = int(sg);
70 |       b = int(sb);
71 |       endColor = color(r, g, b);
72 |     }
73 |     if (sr!="" && sg!="" && sb!="" && sa!="") {
74 |       r = int(sr);
75 |       g = int(sg);
76 |       b = int(sb);
77 |       a = int(sa);
78 |       endColor = color(r, g, b, a);
79 |     }
80 |       return endColor;
81 |   }
82 | }


--------------------------------------------------------------------------------
/Controls.pde:
--------------------------------------------------------------------------------
 1 | import java.awt.Desktop;
 2 | 
 3 | String openFilePath = "render";
 4 | String folderPath;
 5 | String fileName = "output";
 6 | File dataFolder;
 7 | 
 8 | //~~~~~~~~~~~~~~~~~~~~~~~~
 9 | //choose folder dialog, Processing 2 version
10 | 
11 | void chooseFolderDialog(){
12 |     if(firstRun) selectFolder("Choose a folder.","chooseFolderCallback");  // Opens file chooser
13 | }
14 | 
15 | void chooseFolderCallback(File selection){
16 |     if (selection == null) {
17 |       println("No folder was selected.");
18 |       exit();
19 |     } else {
20 |       folderPath = selection.getAbsolutePath();
21 |       println(folderPath);
22 |       countFrames(folderPath);
23 |     }
24 | }
25 | 
26 | void countFrames(String usePath) {
27 |     imgNames = new ArrayList();
28 |     //loads a sequence of frames from a folder
29 |     dataFolder = new File(usePath); 
30 |     String[] allFiles = dataFolder.list();
31 |     for (int j=0;j<allFiles.length;j++) {
32 |       if (
33 |         allFiles[j].toLowerCase().endsWith("png") ||
34 |         allFiles[j].toLowerCase().endsWith("jpg") ||
35 |         allFiles[j].toLowerCase().endsWith("jpeg") ||
36 |         allFiles[j].toLowerCase().endsWith("gif") ||
37 |         allFiles[j].toLowerCase().endsWith("tga")){
38 |           imgNames.add(usePath+"/"+allFiles[j]);
39 |         }
40 |     }
41 |     if(imgNames.size()==0){
42 |       exit();
43 |     }else{
44 |       // We need this because Processing 2, unlike Processing 1, will not automatically wait to let you pick a folder!
45 |       firstRun = false;
46 |     }
47 | }
48 | 
49 | //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
50 | //reveal folder, processing 2 version
51 | 
52 | void openAppFolderHandler(){
53 |   if(System.getProperty("os.name").equals("Mac OS X")){
54 |     try{
55 |       print("Trying OS X Finder method.");
56 |       //open(sketchPath(openFilePath));
57 |       Desktop.getDesktop().open(new File(sketchPath("") + "/" + openFilePath));
58 |     }catch(Exception e){ }
59 |   }else{
60 |     try{
61 |       print("Trying Windows Explorer method.");
62 |       Desktop.getDesktop().open(new File(sketchPath("") + "/" + openFilePath));
63 |     }catch(Exception e){ }
64 |   }
65 | }
66 | 
67 | //run at startup if you want to use app data folder--not another folder.
68 | //This accounts for different locations and OS conventions
69 | void scriptsFolderHandler(){
70 |   String s = openFilePath;
71 |   if(System.getProperty("os.name").equals("Mac OS X")){
72 |     try{
73 |       print("Trying OS X Finder method.");
74 |       openFilePath = dataPath("") + "/" + s;
75 |     }catch(Exception e){ }
76 |   }else{
77 |     try{
78 |       print("Trying Windows Explorer method.");
79 |       openFilePath = sketchPath("") + "/data/" + s;
80 |     }catch(Exception e){ }
81 |   }
82 | }


--------------------------------------------------------------------------------
/Data.pde:
--------------------------------------------------------------------------------
  1 | import java.io.File;
  2 | 
  3 | ///////////////////////////
  4 | // DATA CLASS
  5 | // Marius Watz - http://workshop.evolutionzone.com
  6 | 
  7 | class Data {
  8 |   ArrayList datalist;
  9 |   String filename,data[];
 10 |   int datalineId;
 11 |  
 12 |   // begin data saving
 13 |   void beginSave() {
 14 |     datalist=new ArrayList();
 15 |   }
 16 |  
 17 |   void add(String s) {
 18 |     datalist.add(s);
 19 |   }
 20 |  
 21 |   void add(float val) {
 22 |     datalist.add(""+val);
 23 |   }
 24 |  
 25 |   void add(int val) {
 26 |     datalist.add(""+val);
 27 |   }
 28 |  
 29 |   void add(boolean val) {
 30 |     datalist.add(""+val);
 31 |   }
 32 |  
 33 |   void endSave(String _filename) {
 34 |     filename=_filename;
 35 |  
 36 |     data=new String[datalist.size()];
 37 |     data=(String [])datalist.toArray(data);
 38 |  
 39 |     saveStrings(filename, data);
 40 |     println("Saved data to '"+filename+
 41 |       "', "+data.length+" lines.");
 42 |   }
 43 |  
 44 |   void load(String _filename) {
 45 |     filename=_filename;
 46 |  
 47 |     datalineId=0;
 48 |     data=loadStrings(filename);
 49 |     println("Loaded data from '"+filename+
 50 |       "', "+data.length+" lines.");
 51 |   }
 52 |  
 53 |   float readFloat() {
 54 |     return float(data[datalineId++]);
 55 |   }
 56 |  
 57 |   int readInt() {
 58 |     return int(data[datalineId++]);
 59 |   }
 60 |  
 61 |   boolean readBoolean() {
 62 |     return boolean(data[datalineId++]);
 63 |   }
 64 |  
 65 |   String readString() {
 66 |     return data[datalineId++];
 67 |   }
 68 |  
 69 |   // Utility function to auto-increment filenames
 70 |   // based on filename templates like "name-###.txt" 
 71 |  
 72 |   public String getIncrementalFilename(String templ) {
 73 |     String s="",prefix,suffix,padstr,numstr;
 74 |     int index=0,first,last,count;
 75 |     File f;
 76 |     boolean ok;
 77 |  
 78 |     first=templ.indexOf('#');
 79 |     last=templ.lastIndexOf('#');
 80 |     count=last-first+1;
 81 |  
 82 |     if( (first!=-1)&& (last-first>0)) {
 83 |       prefix=templ.substring(0, first);
 84 |       suffix=templ.substring(last+1);
 85 |  
 86 |       // Comment out if you want to use absolute paths
 87 |       // or if you're not using this inside PApplet
 88 |       //if(sketchPath!=null) prefix=savePath(prefix);
 89 |  
 90 |       index=0;
 91 |       ok=false;
 92 |  
 93 |       do {
 94 |         padstr="";
 95 |         numstr=""+index;
 96 |         for(int i=0; i< count-numstr.length(); i++) padstr+="0";
 97 |         s=prefix+padstr+numstr+suffix;
 98 |  
 99 |         f=new File(s);
100 |         ok=!f.exists();
101 |         index++;
102 |  
103 |         // Provide a panic button. If index > 10000 chances are it's an
104 |         // invalid filename.
105 |         if(index>10000) ok=true;
106 |  
107 |       }
108 |       while(!ok);
109 |  
110 |       // Panic button - comment out if you know what you're doing
111 |       if(index> 10000) {
112 |         println("getIncrementalFilename thinks there is a problem - "+
113 |           "Is there  more than 10000 files already in the sequence "+
114 |           " or is the filename invalid?");
115 |         println("Returning "+prefix+"ERR"+suffix);
116 |         return prefix+"ERR"+suffix;
117 |       }
118 |     }
119 |  
120 |     return s;
121 |   }
122 |  
123 | }


--------------------------------------------------------------------------------
/Cam.pde:
--------------------------------------------------------------------------------
  1 | // https://processing.org/reference/camera_.html
  2 | class Cam {
  3 | 
  4 |   PVector pos = new PVector(0,0,0);
  5 |   PVector poi = new PVector(0,0,0);
  6 |   PVector up = new PVector(0,0,0);
  7 | 
  8 |   PVector mouse = new PVector(0,0,0);
  9 |   PGraphics3D p3d;
 10 |   PMatrix3D proj, cam, modvw, modvwInv, screen2Model;
 11 |   
 12 |   String displayText = "";
 13 |   PFont font;
 14 |   int fontSize = 12;
 15 | 
 16 |   void init() {
 17 |     p3d = (PGraphics3D) g;
 18 |     //proj = new PMatrix3D();
 19 |     cam = new PMatrix3D();
 20 |     //modvw = new PMatrix3D();
 21 |     modvwInv = new PMatrix3D();
 22 |     screen2Model = new PMatrix3D();
 23 |     
 24 |     font = createFont("Arial", fontSize);
 25 |   }
 26 |   
 27 |   PVector screenToWorldCoords(PVector p) {
 28 |     //proj = p3d.projection.get();
 29 |     cam = p3d.modelview.get(); //camera.get();
 30 |     //modvw = p3d.modelview.get();
 31 |     modvwInv = p3d.modelviewInv.get();
 32 |     screen2Model = modvwInv;
 33 |     screen2Model.apply(cam);
 34 |     float screen[] = { p.x, p.y, p.z };
 35 |     float model[] = { 0, 0, 0 };
 36 |     model = screen2Model.mult(screen, model);
 37 |     
 38 |     return new PVector(model[0] + (poi.x - width/2), model[1] + (poi.y - height/2), model[2]);
 39 |   }
 40 |   
 41 |   void screenToWorldMouse() {
 42 |     mouse = screenToWorldCoords(new PVector(mouseX, mouseY, poi.z));
 43 |   }
 44 |   
 45 |   Cam() {
 46 |     defaultPos();
 47 |     defaultPoi();
 48 |     defaultUp();
 49 |     init();
 50 |   }
 51 |   
 52 |   Cam(PVector _pos) {
 53 |     pos = _pos;
 54 |     defaultPoi();
 55 |     defaultUp();
 56 |     init();
 57 |   }
 58 |   
 59 |   Cam(PVector _pos, PVector _poi) {
 60 |     pos = _pos;
 61 |     poi = _poi;
 62 |     defaultUp();
 63 |     init();
 64 |   }
 65 |   
 66 |   Cam(PVector _pos, PVector _poi, PVector _up) {
 67 |     pos = _pos;
 68 |     poi = _poi;
 69 |     up = _up;
 70 |     init();
 71 |   }
 72 |   
 73 |   void update() {
 74 |     screenToWorldMouse();
 75 |   }
 76 |   
 77 |   void draw() {
 78 |     camera(pos.x, pos.y, pos.z, poi.x, poi.y, poi.z, up.x, up.y, up.z);
 79 |     drawText();
 80 |   }
 81 |   
 82 |   void run() {
 83 |     update();
 84 |     draw();
 85 |   }
 86 |   
 87 |   void move(float x, float y, float z) {
 88 |     PVector p = new PVector(x,y,z);
 89 |     pos = pos.add(p);
 90 |     poi = poi.add(p);
 91 |   }
 92 |   
 93 |   void defaultPos() {
 94 |     pos.x = width/2.0;
 95 |     pos.y = height/2.0;
 96 |     pos.z = (height/2.0) / tan(PI*30.0 / 180.0);
 97 |   }
 98 |   
 99 |   void defaultPoi() {
100 |     poi.x = width/2.0;
101 |     poi.y = height/2.0;
102 |     poi.z = 0;
103 |   }
104 |   
105 |   void defaultUp() {
106 |     up.x = 0;
107 |     up.y = 1;
108 |     up.z = 0;
109 |   }
110 |   
111 |   void reset() {
112 |     defaultPos();
113 |     defaultPoi();
114 |     defaultUp();
115 |   }
116 |   
117 |   void drawText() {
118 |     if (!displayText.equals("")) {
119 |       pushMatrix();  
120 |       translate((pos.x - (width/2)) + (fontSize/2), (pos.y - (height/2)) + fontSize, poi.z);
121 |       textFont(font, fontSize);
122 |       text(displayText, 0, 0);
123 |       popMatrix();
124 |     }
125 |   }
126 |   
127 | }
128 | 
129 | // TODO
130 | // https://processing.org/reference/frustum_.html
131 | // https://processing.org/reference/beginCamera_.html
132 | // https://processing.org/reference/endCamera_.html


--------------------------------------------------------------------------------
/PointExport.pde:
--------------------------------------------------------------------------------
  1 | Data dataVert, dataMain;
  2 | ArrayList<Float> lidarPoints;
  3 | int vertCounter = 0;
  4 | String url = "";
  5 | 
  6 | void exportMain() {
  7 |   url = filePath + "/" + fileName + zeroPadding(counter+1,imgNames.size()) + "." + fileType;
  8 |   vertCounter = 0; 
  9 |   
 10 |   dataMain = new Data();
 11 |   dataMain.beginSave();
 12 |   dataVert = new Data();
 13 |   dataVert.beginSave();
 14 |   lidarPoints = new ArrayList<Float>();
 15 |   
 16 |   buffer = img;
 17 |   for (int y = 0; y < sH; y++) {
 18 |     for (int x = 0; x < sW; x++) {
 19 |       // FIXME: this loses Z-resolution about tenfold ...
 20 |       //       -> should grab the real distance instead...
 21 |       color argb = buffer.pixels[y*width+x];
 22 |       gray[y][x] = getGray(argb);
 23 |       if (gray[y][x] > 0) {
 24 |         vertCounter++;
 25 |         if (fileType.toLowerCase().equals("obj")) {
 26 |           objVert(x,y);
 27 |         } else if (fileType.toLowerCase().equals("ply")) {
 28 |           plyVert(x,y);
 29 |         } else if (fileType.toLowerCase().equals("asc")) {
 30 |           ascVert(x,y);
 31 |         } else if (fileType.toLowerCase().equals("bin")) {
 32 |           binVert(x,y);
 33 |         }
 34 |       }
 35 |     }
 36 |   }
 37 |   if (fileType.toLowerCase().equals("obj")) {
 38 |     objHeader();
 39 |     compileVert();
 40 |     objFooter();
 41 |     writeAscii();
 42 |   } else if (fileType.toLowerCase().equals("ply")) {
 43 |     plyHeader();
 44 |     compileVert(); // ply doesn't need a footer
 45 |     writeAscii();
 46 |   } else if (fileType.toLowerCase().equals("asc")) {
 47 |     compileVert(); // asc doesn't need header or footer
 48 |     writeAscii();
 49 |   } else if (fileType.toLowerCase().equals("bin")) {
 50 |     writeBin();
 51 |   }
 52 | }
 53 | 
 54 | void writeAscii() {
 55 |   dataMain.endSave(url);
 56 | }
 57 | 
 58 | void writeBin() {
 59 |   float[] floats = floatListToArray(lidarPoints);
 60 |   floatsToBytes(floats, url); 
 61 | }
 62 | 
 63 | float[] floatListToArray(ArrayList<Float> list) {
 64 |   float[] floats = new float[list.size()];
 65 |   for (int i=0; i<floats.length; i++) {
 66 |     floats[i] = list.get(i);
 67 |   }
 68 |   return floats;
 69 | }
 70 | 
 71 | void compileVert() {
 72 |   for (int i=0; i<dataVert.datalist.size(); i++) {
 73 |     String s = (String) dataVert.datalist.get(i);
 74 |     dataMain.add(s);
 75 |   }
 76 | }
 77 | 
 78 | //~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
 79 | // OBJ
 80 | void objHeader() {
 81 |   dataMain.add("####");
 82 |   dataMain.add("#");
 83 |   dataMain.add("# Vertices: "+ vertCounter);
 84 |   dataMain.add("# Faces: 0");
 85 |   dataMain.add("#");
 86 |   dataMain.add("####");
 87 | }
 88 | 
 89 | void objVert(int x, int y) {
 90 |   dataVert.add("v " + x + " " + y + " " + gray[y][x]);
 91 | }
 92 | 
 93 | void objFooter() {
 94 |   dataMain.add("# " + vertCounter +" vertices, 0 vertex normals");
 95 |   dataMain.add("");
 96 |   dataMain.add("# 0 faces, 0 texture coords");
 97 |   dataMain.add("");
 98 |   dataMain.add("# End of File");
 99 | }
100 | 
101 | //~ ~ ~ ~ ~
102 | // PLY
103 | void plyHeader() {
104 |   dataMain.add("ply");
105 |   dataMain.add("format ascii 1.0");
106 |   dataMain.add("comment VCGLIB generated");
107 |   dataMain.add("element vertex " + vertCounter);
108 |   dataMain.add("property float x");
109 |   dataMain.add("property float y");
110 |   dataMain.add("property float z");
111 |   dataMain.add("property uchar red");
112 |   dataMain.add("property uchar green");
113 |   dataMain.add("property uchar blue");
114 |   dataMain.add("property uchar alpha");
115 |   dataMain.add("element face 0");
116 |   dataMain.add("property list uchar int vertex_indices");
117 |   dataMain.add("end_header");
118 | }
119 | 
120 | void plyVert(int x, int y) {
121 |   dataVert.add(x + " " + y + " " + gray[y][x] + " 192 192 192 255 "); //hard-coded vertex color for now. Trailing space is on purpose.
122 | }
123 | 
124 | //~ ~ ~ ~ ~
125 | // ASC
126 | void ascVert(int x, int y) {
127 |   dataVert.add(x + " " + y + " " + gray[y][x]);
128 | }
129 | 
130 | //~ ~ ~ ~ ~
131 | // BIN (Velodyne)
132 | void binVert(int x, int y) {
133 |   lidarPoints.add(float(x));
134 |   lidarPoints.add(float(y));
135 |   lidarPoints.add(gray[y][x]);
136 |   lidarPoints.add(gray[y][x]);
137 | }


--------------------------------------------------------------------------------
/Encoding.pde:
--------------------------------------------------------------------------------
  1 | import java.awt.image.BufferedImage;
  2 | import java.io.ByteArrayInputStream;
  3 | import java.io.ByteArrayOutputStream;
  4 | import java.io.File;
  5 | import java.io.IOException;
  6 | import java.io.InputStream;
  7 | import javax.imageio.ImageIO;
  8 | import java.util.Base64;
  9 | 
 10 | // ~ ~ ~ ASCII ~ ~ ~
 11 | // http://ascii.cl/control-characters.htm
 12 | // https://stackoverflow.com/questions/36519977/how-to-convert-string-into-a-7-bit-binary
 13 | // http://www.dcode.fr/ascii-code
 14 | // https://forum.processing.org/one/topic/need-help-in-converting-data-types.html
 15 | 
 16 | byte[] readNBits(String str, int n) {
 17 |     byte[] bytes = new byte[str.length() * n];
 18 |     for (int i = 0; i < str.length(); i++) {
 19 |         char ch = str.charAt(i);
 20 |         assert ch < int(pow(2,n));
 21 |         for (int j = 0; j < n; j++) 
 22 |             bytes[i * n + j] = (byte) ((ch >> (n - j)) & 1);
 23 |     }
 24 |     return bytes;
 25 | }
 26 | 
 27 | String[] decodeNBits(byte[] b, int n) {
 28 |   ArrayList stringsL= new ArrayList();
 29 |   for (int i=0; i<b.length; i+=n) {
 30 |     String s = "";
 31 |     for (int j=0; j<n; j++) {
 32 |       s += b[i+j];
 33 |     }
 34 |     stringsL.add(getCharFromInt(s, n));
 35 |   }
 36 |   String[] strings = new String[stringsL.size()];
 37 |   for (int i=0; i<strings.length; i++) {
 38 |     strings[i] = (String) stringsL.get(i);
 39 |   }
 40 |   return strings;
 41 | }
 42 | 
 43 | String getCharFromInt(String s, int n) {
 44 |   String returns = "";   
 45 |   char nextChar;
 46 |   // We want [0, 7], [9, 16], etc (increment index by 9 if bytes are space-delimited).
 47 |   for (int i = 0; i <= s.length()-n; i += n+1) {
 48 |        nextChar = (char) Integer.parseInt(s.substring(i, i+n), 2);
 49 |        returns += nextChar;
 50 |   }
 51 |   return returns;
 52 | }
 53 | 
 54 | String[] splitByNum(String s, int n) {
 55 |     return s.split("(?<=\\G.{" + n + "})");
 56 | }
 57 | 
 58 | String[] splitByChar(String[] s, String delim) {
 59 |     return splitTokens(join(s, ""), delim);
 60 | }
 61 | 
 62 | // ~ ~ ~ BASE64 ~ ~ ~
 63 | // https://forum.processing.org/two/discussion/6958/pimage-base64-encode-and-decode
 64 | // https://www.mkyong.com/java/how-to-convert-byte-to-bufferedimage-in-java/
 65 | // https://stackoverflow.com/questions/2305966/why-do-i-get-the-unhandled-exception-type-ioexception
 66 | 
 67 | PImage decodePImageFromBase64(String i_Image64) {
 68 |   PImage returns = null;
 69 |   try {
 70 |     byte[] decodedBytes = Base64.getDecoder().decode(i_Image64);
 71 |     ByteArrayInputStream in = new ByteArrayInputStream(decodedBytes);
 72 |     BufferedImage bImageFromConvert = ImageIO.read(in);
 73 |     BufferedImage convertedImg = new BufferedImage(bImageFromConvert.getWidth(), bImageFromConvert.getHeight(), BufferedImage.TYPE_INT_ARGB);
 74 |     convertedImg.getGraphics().drawImage(bImageFromConvert, 0, 0, null);
 75 |     returns = new PImage(convertedImg); 
 76 |   } catch (IOException ie) { }
 77 |   return returns;
 78 | }
 79 | 
 80 | String decodeStringFromBase64(String input) {
 81 |   String returns = null;
 82 |   byte[] decodedBytes = Base64.getDecoder().decode(input);
 83 |   ByteArrayInputStream in = new ByteArrayInputStream(decodedBytes);
 84 |   returns = in.toString();
 85 |   return returns;
 86 | }
 87 | 
 88 | // https://stackoverflow.com/questions/4513498/java-bytes-to-floats-ints
 89 | int asInt(byte[] bytes) {
 90 |   return (bytes[0] & 0xFF) 
 91 |          | ((bytes[1] & 0xFF) << 8) 
 92 |          | ((bytes[2] & 0xFF) << 16) 
 93 |          | ((bytes[3] & 0xFF) << 24);
 94 | }
 95 | 
 96 | float asFloat(byte[] bytes) {
 97 |   return Float.intBitsToFloat(asInt(bytes));
 98 | }
 99 | 
100 | // https://forum.processing.org/two/discussion/23446/saving-multi-dimensional-arrays
101 | // https://forum.processing.org/one/topic/writing-and-reading-a-mixture-of-ints-and-float-to-from-a-file.html
102 | void serializeFloats(float[] _floats, String _fileName) {
103 |   try {
104 |     java.io.FileOutputStream fileOut = new java.io.FileOutputStream(sketchPath("") + "/" + _fileName);
105 |     java.io.ObjectOutputStream out = new java.io.ObjectOutputStream(fileOut);
106 |     out.writeObject(_floats);
107 |     out.close();
108 |     fileOut.close();
109 |   } catch(IOException i) {
110 |     i.printStackTrace();
111 |   }
112 | }
113 | 
114 | // http://forum.arduino.cc/index.php?topic=180456.0
115 | void floatsToBytes(float[] floats, String _fileName) {
116 |   byte[] bytes = new byte[floats.length * 4];
117 |   
118 |   for(int i=0; i<floats.length; i++) {
119 |     int fi = Float.floatToIntBits(floats[i]);
120 |     bytes[(i*4)] = byte(fi & 0xFF);
121 |     bytes[(i*4)+1] = byte((fi >> 8) & 0xFF);
122 |     bytes[(i*4)+2] = byte((fi >> 16) & 0xFF);
123 |     bytes[(i*4)+3] = byte((fi >> 24) & 0xFF);
124 |   }
125 |   
126 |   saveBytes(_fileName, bytes);
127 | }


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