├── ContourGen
    ├── ContourGen.pde
    ├── buildData.pde
    ├── data
    │   └── kale.jpg
    ├── patterns.pde
    ├── sortData.pde
    └── writeData.pde
└── README.md


/ContourGen/ContourGen.pde:
--------------------------------------------------------------------------------
 1 | //=============================================================================//
 2 | // ContureGenerator
 3 | // By Bjørn Karmann, 01.03.2016
 4 | // www.bjoernkarmann.dk
 5 | // 
 6 | //Note: The resolution has to work on width
 7 | //and height.
 8 | // 800mm width x 1000mm height allow a resolution
 9 | //=============================================================================//
10 | 
11 | PImage img;
12 | int number = 0;
13 | float res = 0;
14 | PVector[] dots;
15 | float[][] sorted;
16 | int[] done;
17 | boolean targetIs = false;
18 | int sortedLength = 0;
19 | int c = 0;
20 | 
21 | //=============================================================================//
22 | //                              MACHINE SETTINGS                               //
23 | 
24 | String file        = "water-color6.jpg";  // file name (data folder)       
25 | int threshold      = 60;                  // max line (mm)
26 | int resolution     = 350;                 // bedst result
27 | int paperW         = 700;                 // mm paper width
28 | int paperH         = 1000;                // mm paper height
29 | int zHeight        = 18;                  // mm (pen lift)
30 | int zTarget        = -1;                  // mm 
31 | float stopAt       = 0.95;                // 1 = finish drawing at 100%
32 | 
33 | //                             EXAMPLE DRAW SETTINGS
34 |  
35 | float penThickness = 0.005;               // mm pen thikness
36 | boolean grid       = false;               // show grid of resolution
37 | int printSpeed     = 10;                  // lines pr. ms for draw animation
38 | 
39 | 
40 | //                                                                             //
41 | //=============================================================================//
42 | 
43 | void setup() { 
44 |   background(255);
45 |   frameRate(800);
46 |   size(700, 900);  
47 |   res = int(height/resolution);   
48 |   println(res);
49 |   threshold = 100;
50 |   buildData();
51 |   if (grid == true) {
52 |     grid();
53 |   }
54 |   sortData();
55 |   writeData();
56 |   strokeWeight(penThickness);
57 | }
58 | 
59 | void draw() {
60 |   
61 | //=============================================================================//
62 | //                                EXAMPLE DRAW                                 //
63 | 
64 |   int amount = int(sorted.length*stopAt);
65 |   
66 |   for (int i = 0; i<100; i++) {  //print speed
67 |       
68 |     float x = sorted[c][0];
69 |     float y = sorted[c][1];
70 |     float distX = sorted[c][2];
71 |     float distY = sorted[c][3];
72 | 
73 |     line(x, y, distX, distY); 
74 |     c++;
75 |   }
76 |   
77 |   if(c >= amount){
78 |     println("Drawing finished!");
79 |     String[] fileList = split(file, '.');       // save jpg file
80 |     saveFrame("gcode/"+fileList[0]+"/example_"+resolution+".jpg");
81 |     noLoop();    
82 |   }
83 | }
84 | 
85 | //=============================================================================//
86 | //                            SHOW RESOLUTION GRID                             //
87 | 
88 | void grid() {
89 | 
90 |   stroke(240);
91 |   for (int i = 0; i<width; i+=res) {
92 |     line(0, i, height, i);
93 |     line(i, 0, i, width);
94 |   }
95 | }


--------------------------------------------------------------------------------
/ContourGen/buildData.pde:
--------------------------------------------------------------------------------
 1 | void buildData() { 
 2 |   
 3 |   img = loadImage("data/"+file);
 4 |   img.resize(width, height);
 5 |   dots = new PVector[img.pixels.length];
 6 | 
 7 |   for (int y=0; y<img.height; y+=res) {             
 8 |     for (int x=0; x<img.width; x+=res) {
 9 | 
10 |       float addBrightness = 0;
11 |       int c = 0;
12 | 
13 |       for (int i = 0; i < res; i++) {
14 |         color pixel = img.get(x+i, y+i);
15 |         float bri = brightness(pixel);
16 |         addBrightness += bri;
17 |         c++;
18 |       }
19 |       
20 |       float avg = addBrightness/c;
21 |       int shade = int(map(avg, 10, 245, 12, 1));    //range of grayscale
22 |     
23 |       //------- call patterns 
24 |       patterns(shade, x, y);
25 |     }
26 |   }
27 |   done = new int[number];    //numbers
28 |   for (int i = 0; i< number; i++) {
29 |     done[i] = i;
30 |   }
31 |   println("Number of lines: "+number);
32 | }


--------------------------------------------------------------------------------
/ContourGen/data/kale.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bjoernkarmann/linePlotter_to_gCode/6e1329260daca5a59aa372df0e16d56c22c5f998/ContourGen/data/kale.jpg


--------------------------------------------------------------------------------
/ContourGen/patterns.pde:
--------------------------------------------------------------------------------
  1 | void patterns(int shade, int x, int y){
  2 |       
  3 |       int rows = 5;
  4 |       float t = res/rows;
  5 |       
  6 |       //================================================//
  7 |       //                    SHADE 1                     //
  8 |       if (shade == 1) {
  9 |         int[][] matrix = { {0, 0, 0, 0, 0}, 
 10 |                            {0, 0, 0, 0, 0},  
 11 |                            {0, 0, 1, 0, 0},  
 12 |                            {0, 0, 0, 0, 0}, 
 13 |                            {0, 0, 0, 0, 0} };
 14 |                       
 15 |         printPatterns(matrix,rows,x,y,t);          
 16 |       }
 17 |       //                      END                       //
 18 |       //================================================//
 19 |       
 20 |       //================================================//
 21 |       //                    SHADE 2                     //
 22 |       if (shade == 2) {
 23 |         int[][] matrix = { {0, 0, 0, 0, 0}, 
 24 |                            {0, 1, 0, 0, 0},  
 25 |                            {0, 0, 0, 0, 0},  
 26 |                            {0, 0, 0, 1, 0}, 
 27 |                            {0, 0, 0, 0, 0} };
 28 |                       
 29 |         printPatterns(matrix,rows,x,y,t);         
 30 |       }
 31 |       //                      END                       //
 32 |       //================================================//
 33 |       
 34 | 
 35 |       //================================================//
 36 |       //                    SHADE 3                     //
 37 |       if (shade == 3) {
 38 |         int[][] matrix = { {0, 0, 0, 0, 0}, 
 39 |                            {0, 0, 0, 1, 0},  
 40 |                            {0, 0, 0, 0, 0},  
 41 |                            {0, 1, 0, 0, 0}, 
 42 |                            {0, 0, 0, 0, 1} };
 43 |                       
 44 |         printPatterns(matrix,rows,x,y,t);          
 45 |       }
 46 |       //                      END                       //
 47 |       //================================================//
 48 |       
 49 |       
 50 |       //================================================//
 51 |       //                    SHADE 4                     //
 52 |       if (shade == 4) {
 53 |         int[][] matrix = { {0, 0, 0, 0, 0}, 
 54 |                            {0, 0, 0, 1, 0},  
 55 |                            {1, 0, 0, 0, 0},  
 56 |                            {0, 0, 0, 0, 0}, 
 57 |                            {0, 0, 1, 0, 1} };
 58 |                       
 59 |         printPatterns(matrix,rows,x,y,t);        
 60 |       }
 61 |       //                      END                       //
 62 |       //================================================//
 63 |       
 64 |       //================================================//
 65 |       //                    SHADE 5                     //
 66 |       if (shade == 5) {
 67 |         int[][] matrix = { {0, 0, 0, 1, 0}, 
 68 |                            {0, 1, 0, 0, 1},  
 69 |                            {0, 0, 0, 0, 0},  
 70 |                            {0, 0, 1, 0, 0}, 
 71 |                            {0, 0, 0, 0, 1} };
 72 |                       
 73 |         printPatterns(matrix,rows,x,y,t);          
 74 |       }
 75 |       //                      END                       //
 76 |       //================================================//
 77 |       
 78 |       //================================================//
 79 |       //                    SHADE 6                     //
 80 |       if (shade == 6) {
 81 |         int[][] matrix = { {0, 1, 0, 1, 0}, 
 82 |                            {0, 0, 0, 0, 0},  
 83 |                            {1, 0, 0, 0, 1},  
 84 |                            {0, 0, 1, 0, 0}, 
 85 |                            {0, 0, 0, 0, 1} };
 86 |                       
 87 |         printPatterns(matrix,rows,x,y,t);          
 88 |       }
 89 |       //                      END                       //
 90 |       //================================================//
 91 |       
 92 |       //================================================//
 93 |       //                    SHADE 7                     //
 94 |       if (shade == 7) {
 95 |         int[][] matrix = { {0, 0, 0, 1, 0}, 
 96 |                            {0, 1, 0, 0, 1},  
 97 |                            {0, 0, 0, 0, 0},  
 98 |                            {1, 0, 1, 0, 0}, 
 99 |                            {0, 1, 0, 0, 1} };
100 |                       
101 |         printPatterns(matrix,rows,x,y,t);          
102 |       }
103 |       //                      END                       //
104 |       //================================================//    
105 | 
106 |       //================================================//
107 |       //                    SHADE 8                     //
108 |       if (shade == 8) {
109 |         int[][] matrix = { {0, 1, 0, 0, 0}, 
110 |                            {1, 0, 1, 0, 1},  
111 |                            {0, 1, 0, 1, 0},  
112 |                            {0, 0, 1, 0, 1}, 
113 |                            {1, 0, 0, 1, 0} };
114 |         
115 |          printPatterns(matrix,rows,x,y,t);      
116 |       }
117 |       //                      END                       //
118 |       //================================================// 
119 | 
120 | 
121 |       //================================================//
122 |       //                    SHADE 9                    //
123 |       if (shade == 9) {
124 |         int[][] matrix = { {1, 0, 1, 0, 1}, 
125 |                            {0, 1, 0, 1, 0},  
126 |                            {0, 0, 1, 0, 1},  
127 |                            {0, 1, 0, 1, 0}, 
128 |                            {1, 0, 1, 0, 1} };
129 |                       
130 |         printPatterns(matrix,rows,x,y,t);          
131 |       }
132 |       //                      END                       //
133 |       //================================================//
134 |       
135 |       
136 |       //================================================//
137 |       //                    SHADE 10                   //
138 |       if (shade == 10) {
139 |         int[][] matrix = { {1, 1, 1, 0, 1}, 
140 |                            {1, 1, 1, 1, 0},  
141 |                            {1, 1, 1, 1, 1},  
142 |                            {0, 1, 0, 1, 1}, 
143 |                            {1, 1, 1, 0, 1} };
144 |                       
145 |         printPatterns(matrix,rows,x,y,t);        
146 |       }
147 |       //                      END                       //
148 |       //================================================//
149 |       
150 |       //================================================//
151 |       //                    SHADE 11                   //
152 |       if (shade == 11) {
153 |         int[][] matrix = { {1, 1, 1, 1, 1}, 
154 |                            {0, 0, 0, 0, 0},  
155 |                            {1, 1, 1, 1, 1},  
156 |                            {0, 0, 0, 0, 0}, 
157 |                            {1, 1, 1, 1, 1} };
158 |                       
159 |         printPatterns(matrix,rows,x,y,t);        
160 |       }
161 |       //                      END                       //
162 |       //================================================//
163 |       
164 |       //================================================//
165 |       //                    SHADE 12                   //
166 |       if (shade == 12) {
167 |         int[][] matrix = { {1, 1, 1, 1, 1}, 
168 |                            {1, 1, 1, 1, 1},  
169 |                            {1, 1, 1, 1, 1},  
170 |                            {1, 1, 1, 1, 1}, 
171 |                            {1, 1, 1, 1, 1} };
172 |                       
173 |         printPatterns(matrix,rows,x,y,t);        
174 |       }
175 |       //                      END                       //
176 |       //================================================//
177 | 
178 |       
179 |       
180 | }
181 | 
182 | void printPatterns(int[][] matrix, int rows, int x, int y, float t){
183 |   
184 |     int r = int(random(1,3));  
185 |     for (int i = 0; i < rows; i++) {
186 |       for (int j = 0; j < rows; j++){
187 |         if( r == 1){
188 |           if(matrix[j][i] == 1){
189 |             //point(x+(t*i+1), y+(t*j+1)); 
190 |             dots[number] = new PVector(x+(t*i+1), y+(t*j+1));  
191 |             number++;
192 |           }
193 |         }else{
194 |           if(matrix[i][j] == 1){
195 |             //point(x+(t*i+1), y+(t*j+1));  
196 |             dots[number] = new PVector(x+(t*i+1), y+(t*j+1)); 
197 |             number++;
198 |           }
199 |         }
200 |       }
201 |    }  
202 | }


--------------------------------------------------------------------------------
/ContourGen/sortData.pde:
--------------------------------------------------------------------------------
 1 | int skipLine = 0;
 2 | 
 3 | void sortData() {
 4 |   
 5 |   sorted = new float[done.length][4];
 6 |   float record = 1000000;
 7 |   int start = 0;
 8 |   int slut = 0;
 9 |   int prosSteps = 0;
10 |   int orderCount = 0;
11 |   
12 |   //--------- FIND START BEGIN ---------//
13 |   for (int i = 0; i<done.length; i++) {
14 |     float middel = dist(0, height, dots[i].x, dots[i].y);  
15 |     if (middel<record) {
16 |       record = middel; 
17 |       start = i;
18 |     }
19 |   }
20 |   //--------- FIND START END ---------//
21 |   
22 |   
23 |   ellipse(dots[start].x, dots[start].y, 10, 10);
24 |   done[start]=0;
25 |   int count = 0;
26 |   for (int i = 2; i<done.length; i++) {
27 |     //stroke(i, 200, 200);
28 |     for (int j = 0; j<done.length; j++) {
29 |       int check = done[j];
30 |       if (check != 0) {
31 |         float distance = dist(dots[start].x, dots[start].y, dots[check].x, dots[check].y);  
32 |         if (distance<record) {
33 |           record = distance; 
34 |           slut = j;
35 |         }
36 |       }
37 |       
38 |       if (j==done.length-1) {
39 |         done[slut]=0;
40 |         if(record<threshold){
41 |           sorted[orderCount][0] = dots[start].x;
42 |           sorted[orderCount][1] = dots[start].y;
43 |           sorted[orderCount][2] = dots[slut].x;
44 |           sorted[orderCount][3] = dots[slut].y;         
45 |           orderCount++;
46 |         }else{
47 |           skipLine++; 
48 |         }
49 |         record = 1000000;
50 |         start = slut;
51 |       }
52 |     }
53 |     count++;
54 |     int pros = (100*count)/number;
55 |     
56 |     if(count == 1){
57 |     println("____________________________________");  
58 |     print("Processing:");
59 |     }
60 |     if(pros>prosSteps){
61 |       print("/");
62 |       prosSteps += 4;
63 |     }
64 |   }
65 |   println();
66 |   print("Lines skipped: "+skipLine);
67 |   print("\t");
68 |   println("Threshold: "+threshold+"mm");
69 | }


--------------------------------------------------------------------------------
/ContourGen/writeData.pde:
--------------------------------------------------------------------------------
 1 | PrintWriter output;
 2 | 
 3 | void writeData() {  
 4 |   String[] fileList = split(file, '.');
 5 |   output = createWriter("gcode/"+fileList[0]+"/"+fileList[0]+"_"+resolution+".nc");  // nc for gcode file
 6 |   output.println("G0 Z"+zHeight);
 7 |   int amount = int(sorted.length*stopAt);
 8 |   for (int i = 0; i<amount; i++) {  //print speed
 9 |     
10 |     //float distanceCheck = dist(sorted[i][0],sorted[i][1],sorted[i][2],sorted[i][3]);
11 |     
12 |     float x =     map(sorted[i][0], 0,width,0,paperW);
13 |     float y =     map(sorted[i][1], 0,height,paperH,0);
14 |     float distX = map(sorted[i][2], 0,width,0,paperW);
15 |     float distY = map(sorted[i][3], 0,height,paperH,0);
16 |     
17 |     float distance = dist(x,y,distX,distY);
18 |     distance = map(distance,0,paperH,0,width);
19 |     
20 |     if(i==0){                                     // lift when going to start
21 |       output.println("G0"+" X"+x+" Y"+y);
22 |       output.println("G0 Z"+zTarget);
23 |    /* }else if(distanceCheck > threshold){        // lift for travels
24 |       output.println("G0 Z"+zHeight);
25 |       output.println("G0"+" X"+x+" Y"+y);  */            
26 |     }else if(i==sorted.length-stopAt){            // lift when done and save file
27 |       output.println("G0 Z"+zHeight);
28 |       output.flush(); 
29 |       output.close(); // Finishes the file 
30 |       println("File saved: "+"gcode/"+fileList[0]+"/"+fileList[0]+"_"+resolution+".nc");
31 |       
32 |     }else{         // print 
33 |       output.println("G0"+" X"+x+" Y"+y);         // draw lines
34 |     }
35 |   }
36 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # linePlotter_to_gCode
2 | A processing sketch that converts any image into a custom line trace and outputs gCode
3 | 


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