compositor for 2d shader
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751
  1. //"rendering" in terms of "render to disk", not to screen. that is given in draw()
  2. PImage sobelEdgeImg;
  3. PImage sobelEdgeImg2;
  4. PImage cannyEdgeImg;
  5. PImage cannyEdgeImg2;
  6. PGraphics renderFiltered;
  7. PImage[] masksRender;
  8. int masksRenderAmount = 3; //for airis
  9. int masksSize = 1024;
  10. //PImage roundMaskImage; //for obs-studio greenscreenremoval // have the source be in a circle
  11. void render() {
  12. if (airisRendering) {
  13. //render grayscale image
  14. renderFiltered = createGraphics((renderer.width < renderer.height) ? int(map(renderer.width, 0, renderer.height, 0, masksSize)) : masksSize, (renderer.width < renderer.height) ? masksSize : int(map(renderer.height, 0, renderer.width, 0, masksSize)));
  15. renderFiltered.beginDraw();
  16. renderFiltered.image(renderer, 0, 0, renderFiltered.width, renderFiltered.height);
  17. renderFiltered.endDraw();
  18. //sobelEdgeImg = sobelEdge(renderFiltered);
  19. //sobelEdgeImg = sobelEdge(sobelEdgeImg);
  20. //sobelEdgeImg.filter(INVERT); //<- best sobel results here
  21. //cannyEdgeImg = cannyEdge(renderFiltered); //better look bellow
  22. renderFiltered.beginDraw();
  23. renderFiltered.filter(GRAY);
  24. renderFiltered.filter(POSTERIZE, masksRenderAmount);
  25. //renderFiltered. giers PUT A CONTRAST CORRECTION HERE!
  26. renderFiltered.loadPixels();
  27. renderFiltered.endDraw();
  28. cannyEdgeImg2 = cannyEdge(renderFiltered); //<- best canny results here
  29. //sobelEdgeImg2 = sobelEdge(renderFiltered); //better look above
  30. //render mask layers
  31. PImage imgRenderFiltered = renderFiltered.get();
  32. imgRenderFiltered.loadPixels();
  33. color[] c = new color[masksRender.length];
  34. int cc = 0;
  35. for (int i = 0; i < renderFiltered.width*renderFiltered.height; i ++) {
  36. boolean exists = false;
  37. for (int j = 0; j < c.length; j++) {
  38. if (color(renderFiltered.pixels[i]) == c[j]) exists = true;
  39. }
  40. if (!exists) {
  41. c[cc] = color(renderFiltered.pixels[i]);
  42. cc++;
  43. }
  44. }
  45. for (int i = 0; i < masksRender.length; i ++) {
  46. masksRender[i] = createImage(renderFiltered.width, renderFiltered.height, ARGB);
  47. masksRender[i].loadPixels();
  48. for (int j = 0; j < masksRender[i].width*masksRender[i].height; j++) {
  49. if (c[i] == color(imgRenderFiltered.pixels[j])) {
  50. masksRender[i].pixels[j] = color(255);
  51. } else {
  52. masksRender[i].pixels[j] = color(0);
  53. }
  54. }
  55. }
  56. // render edge image
  57. /* old, processing edge detection example
  58. float[][] kernel = {{ -1, -1, -1},
  59. { -1, 9, -1},
  60. { -1, -1, -1}};
  61. edgeImg = createImage(renderFiltered.width, renderFiltered.height, RGB);
  62. for (int y = 1; y < renderFiltered.height-1; y++) {
  63. for (int x = 1; x < renderFiltered.width-1; x++) {
  64. float sum = 0;
  65. for (int ky = -1; ky <= 1; ky++) {
  66. for (int kx = -1; kx <= 1; kx++) {
  67. int pos = (y + ky)*renderFiltered.width + (x + kx);
  68. float val = red(renderFiltered.pixels[pos]);
  69. sum += kernel[ky+1][kx+1] * val;
  70. }
  71. }
  72. edgeImg.pixels[y*renderFiltered.width + x] = color(sum, sum, sum);
  73. }
  74. }
  75. edgeImg.updatePixels();
  76. */
  77. }
  78. }
  79. void airisRender(int size) {
  80. if (!airisRendering) {
  81. airisRendering = true;
  82. previousRenderSize = renderSize;
  83. previousRecordState = recording;
  84. renderSize = size;
  85. recording = true;
  86. }
  87. }
  88. boolean airisRendering;
  89. int previousRenderSize;
  90. boolean previousRecordState;
  91. void snapshot() {
  92. frameName = str(frameCount + int(uptime));
  93. if (airisRendering) {
  94. String renderPath = dataPath("")+"/snapshots/" + frameName + "_rendered/";
  95. renderer.save(renderPath + frameName + ".png");
  96. //edgeImg.save(renderPath + frameName + "_edges.bmp");
  97. //exec(dataPath("potrace"), "--svg", renderPath + frameName + "_edges.bmp", "-o", renderPath + frameName + "_edges.svg");
  98. //sobelEdgeImg.save(renderPath + frameName + "_edgeSobel.png");
  99. //cannyEdgeImg.save(renderPath + frameName + "_edgeCanny.png");
  100. //cannyEdgeImg2.save(renderPath + frameName + "_edgeCanny2.png");
  101. cannyEdgeImg2.save(renderPath + frameName + "_edge.png");
  102. //edgeImg2.save(renderPath + frameName + "_edges2.png");
  103. //renderFiltered.save(renderPath + frameName + "_filtered.png");
  104. //pack 3 masks into one image
  105. PImage packedMasks = createImage(masksRender[0].width, masksRender[0].height, RGB);
  106. packedMasks.loadPixels();
  107. for (int i = 0; i < masksRender.length; i ++) {
  108. masksRender[i].save(renderPath + frameName + "_mask_" + i + ".png");
  109. }
  110. for (int j = 0; j < masksRender[0].pixels.length; j++) {
  111. packedMasks.pixels[j] = color(red(masksRender[0].pixels[j]), green(masksRender[1].pixels[j]), blue(masksRender[2].pixels[j]));
  112. }
  113. packedMasks.updatePixels();
  114. packedMasks.save(renderPath + frameName + "_masks_packed.png");
  115. composiorServer.write("images " + renderer.width + " " + renderer.height + " " + renderPath);
  116. println("Rendered & Message sent");
  117. } else {
  118. renderer.save(dataPath("")+"/snapshots/" + frameName + ".png");
  119. }
  120. saveData[1] = "uptime = " + frameName;
  121. println("Rendered " + frameName + ".png at " + dataPath("")+"/snapshots/ with a resolution of " + renderer.width + " x " + renderer.height);
  122. saveStrings(dataPath("saves.sav"), saveData);
  123. }
  124. //the following two effects were not implemented as fx-shaders.
  125. //these are just for iris // vector tracing
  126. /*******************************************
  127. * CANNY EDGE DETECTOR FOR VECTOR TRACING
  128. *******************************************/
  129. import java.awt.image.BufferedImage;
  130. import java.util.Arrays;
  131. PImage cannyEdge(PImage img){
  132. CannyEdgeDetector detector = new CannyEdgeDetector();
  133. detector.setLowThreshold(0.5f);
  134. detector.setHighThreshold(1f);
  135. detector.setSourceImage((java.awt.image.BufferedImage)img.getImage());
  136. detector.process();
  137. BufferedImage edges = detector.getEdgesImage();
  138. PImage changed = new PImage(edges);
  139. return changed;
  140. }
  141. // The code below is taken from "http://www.tomgibara.com/computer-vision/CannyEdgeDetector.java"
  142. // I have stripped the comments for conciseness
  143. public class CannyEdgeDetector {
  144. // statics
  145. private final static float GAUSSIAN_CUT_OFF = 0.005f;
  146. private final static float MAGNITUDE_SCALE = 100F;
  147. private final static float MAGNITUDE_LIMIT = 1000F;
  148. private final static int MAGNITUDE_MAX = (int) (MAGNITUDE_SCALE * MAGNITUDE_LIMIT);
  149. // fields
  150. private int height;
  151. private int width;
  152. private int picsize;
  153. private int[] data;
  154. private int[] magnitude;
  155. private BufferedImage sourceImage;
  156. private BufferedImage edgesImage;
  157. private float gaussianKernelRadius;
  158. private float lowThreshold;
  159. private float highThreshold;
  160. private int gaussianKernelWidth;
  161. private boolean contrastNormalized;
  162. private float[] xConv;
  163. private float[] yConv;
  164. private float[] xGradient;
  165. private float[] yGradient;
  166. // constructors
  167. /**
  168. * Constructs a new detector with default parameters.
  169. */
  170. public CannyEdgeDetector() {
  171. lowThreshold = 2.5f;
  172. highThreshold = 7.5f;
  173. gaussianKernelRadius = 2f;
  174. gaussianKernelWidth = 16;
  175. contrastNormalized = false;
  176. }
  177. public BufferedImage getSourceImage() {
  178. return sourceImage;
  179. }
  180. public void setSourceImage(BufferedImage image) {
  181. sourceImage = image;
  182. }
  183. public BufferedImage getEdgesImage() {
  184. return edgesImage;
  185. }
  186. public void setEdgesImage(BufferedImage edgesImage) {
  187. this.edgesImage = edgesImage;
  188. }
  189. public float getLowThreshold() {
  190. return lowThreshold;
  191. }
  192. public void setLowThreshold(float threshold) {
  193. if (threshold < 0) throw new IllegalArgumentException();
  194. lowThreshold = threshold;
  195. }
  196. public float getHighThreshold() {
  197. return highThreshold;
  198. }
  199. public void setHighThreshold(float threshold) {
  200. if (threshold < 0) throw new IllegalArgumentException();
  201. highThreshold = threshold;
  202. }
  203. public int getGaussianKernelWidth() {
  204. return gaussianKernelWidth;
  205. }
  206. public void setGaussianKernelWidth(int gaussianKernelWidth) {
  207. if (gaussianKernelWidth < 2) throw new IllegalArgumentException();
  208. this.gaussianKernelWidth = gaussianKernelWidth;
  209. }
  210. public float getGaussianKernelRadius() {
  211. return gaussianKernelRadius;
  212. }
  213. public void setGaussianKernelRadius(float gaussianKernelRadius) {
  214. if (gaussianKernelRadius < 0.1f) throw new IllegalArgumentException();
  215. this.gaussianKernelRadius = gaussianKernelRadius;
  216. }
  217. public boolean isContrastNormalized() {
  218. return contrastNormalized;
  219. }
  220. public void setContrastNormalized(boolean contrastNormalized) {
  221. this.contrastNormalized = contrastNormalized;
  222. }
  223. // methods
  224. public void process() {
  225. width = sourceImage.getWidth();
  226. height = sourceImage.getHeight();
  227. picsize = width * height;
  228. initArrays();
  229. readLuminance();
  230. if (contrastNormalized) normalizeContrast();
  231. computeGradients(gaussianKernelRadius, gaussianKernelWidth);
  232. int low = Math.round(lowThreshold * MAGNITUDE_SCALE);
  233. int high = Math.round( highThreshold * MAGNITUDE_SCALE);
  234. performHysteresis(low, high);
  235. thresholdEdges();
  236. writeEdges(data);
  237. }
  238. // private utility methods
  239. private void initArrays() {
  240. if (data == null || picsize != data.length) {
  241. data = new int[picsize];
  242. magnitude = new int[picsize];
  243. xConv = new float[picsize];
  244. yConv = new float[picsize];
  245. xGradient = new float[picsize];
  246. yGradient = new float[picsize];
  247. }
  248. }
  249. private void computeGradients(float kernelRadius, int kernelWidth) {
  250. //generate the gaussian convolution masks
  251. float kernel[] = new float[kernelWidth];
  252. float diffKernel[] = new float[kernelWidth];
  253. int kwidth;
  254. for (kwidth = 0; kwidth < kernelWidth; kwidth++) {
  255. float g1 = gaussian(kwidth, kernelRadius);
  256. if (g1 <= GAUSSIAN_CUT_OFF && kwidth >= 2) break;
  257. float g2 = gaussian(kwidth - 0.5f, kernelRadius);
  258. float g3 = gaussian(kwidth + 0.5f, kernelRadius);
  259. kernel[kwidth] = (g1 + g2 + g3) / 3f / (2f * (float) Math.PI * kernelRadius * kernelRadius);
  260. diffKernel[kwidth] = g3 - g2;
  261. }
  262. int initX = kwidth - 1;
  263. int maxX = width - (kwidth - 1);
  264. int initY = width * (kwidth - 1);
  265. int maxY = width * (height - (kwidth - 1));
  266. //perform convolution in x and y directions
  267. for (int x = initX; x < maxX; x++) {
  268. for (int y = initY; y < maxY; y += width) {
  269. int index = x + y;
  270. float sumX = data[index] * kernel[0];
  271. float sumY = sumX;
  272. int xOffset = 1;
  273. int yOffset = width;
  274. for (; xOffset < kwidth; ) {
  275. sumY += kernel[xOffset] * (data[index - yOffset] + data[index + yOffset]);
  276. sumX += kernel[xOffset] * (data[index - xOffset] + data[index + xOffset]);
  277. yOffset += width;
  278. xOffset++;
  279. }
  280. yConv[index] = sumY;
  281. xConv[index] = sumX;
  282. }
  283. }
  284. for (int x = initX; x < maxX; x++) {
  285. for (int y = initY; y < maxY; y += width) {
  286. float sum = 0f;
  287. int index = x + y;
  288. for (int i = 1; i < kwidth; i++)
  289. sum += diffKernel[i] * (yConv[index - i] - yConv[index + i]);
  290. xGradient[index] = sum;
  291. }
  292. }
  293. for (int x = kwidth; x < width - kwidth; x++) {
  294. for (int y = initY; y < maxY; y += width) {
  295. float sum = 0.0f;
  296. int index = x + y;
  297. int yOffset = width;
  298. for (int i = 1; i < kwidth; i++) {
  299. sum += diffKernel[i] * (xConv[index - yOffset] - xConv[index + yOffset]);
  300. yOffset += width;
  301. }
  302. yGradient[index] = sum;
  303. }
  304. }
  305. initX = kwidth;
  306. maxX = width - kwidth;
  307. initY = width * kwidth;
  308. maxY = width * (height - kwidth);
  309. for (int x = initX; x < maxX; x++) {
  310. for (int y = initY; y < maxY; y += width) {
  311. int index = x + y;
  312. int indexN = index - width;
  313. int indexS = index + width;
  314. int indexW = index - 1;
  315. int indexE = index + 1;
  316. int indexNW = indexN - 1;
  317. int indexNE = indexN + 1;
  318. int indexSW = indexS - 1;
  319. int indexSE = indexS + 1;
  320. float xGrad = xGradient[index];
  321. float yGrad = yGradient[index];
  322. float gradMag = hypot(xGrad, yGrad);
  323. //perform non-maximal supression
  324. float nMag = hypot(xGradient[indexN], yGradient[indexN]);
  325. float sMag = hypot(xGradient[indexS], yGradient[indexS]);
  326. float wMag = hypot(xGradient[indexW], yGradient[indexW]);
  327. float eMag = hypot(xGradient[indexE], yGradient[indexE]);
  328. float neMag = hypot(xGradient[indexNE], yGradient[indexNE]);
  329. float seMag = hypot(xGradient[indexSE], yGradient[indexSE]);
  330. float swMag = hypot(xGradient[indexSW], yGradient[indexSW]);
  331. float nwMag = hypot(xGradient[indexNW], yGradient[indexNW]);
  332. float tmp;
  333. if (xGrad * yGrad <= (float) 0 /*(1)*/
  334. ? Math.abs(xGrad) >= Math.abs(yGrad) /*(2)*/
  335. ? (tmp = Math.abs(xGrad * gradMag)) >= Math.abs(yGrad * neMag - (xGrad + yGrad) * eMag) /*(3)*/
  336. && tmp > Math.abs(yGrad * swMag - (xGrad + yGrad) * wMag) /*(4)*/
  337. : (tmp = Math.abs(yGrad * gradMag)) >= Math.abs(xGrad * neMag - (yGrad + xGrad) * nMag) /*(3)*/
  338. && tmp > Math.abs(xGrad * swMag - (yGrad + xGrad) * sMag) /*(4)*/
  339. : Math.abs(xGrad) >= Math.abs(yGrad) /*(2)*/
  340. ? (tmp = Math.abs(xGrad * gradMag)) >= Math.abs(yGrad * seMag + (xGrad - yGrad) * eMag) /*(3)*/
  341. && tmp > Math.abs(yGrad * nwMag + (xGrad - yGrad) * wMag) /*(4)*/
  342. : (tmp = Math.abs(yGrad * gradMag)) >= Math.abs(xGrad * seMag + (yGrad - xGrad) * sMag) /*(3)*/
  343. && tmp > Math.abs(xGrad * nwMag + (yGrad - xGrad) * nMag) /*(4)*/
  344. ) {
  345. magnitude[index] = gradMag >= MAGNITUDE_LIMIT ? MAGNITUDE_MAX : (int) (MAGNITUDE_SCALE * gradMag);
  346. //NOTE: The orientation of the edge is not employed by this
  347. //implementation. It is a simple matter to compute it at
  348. //this point as: Math.atan2(yGrad, xGrad);
  349. } else {
  350. magnitude[index] = 0;
  351. }
  352. }
  353. }
  354. }
  355. private float hypot(float x, float y) {
  356. return (float) Math.hypot(x, y);
  357. }
  358. private float gaussian(float x, float sigma) {
  359. return (float) Math.exp(-(x * x) / (2f * sigma * sigma));
  360. }
  361. private void performHysteresis(int low, int high) {
  362. Arrays.fill(data, 0);
  363. int offset = 0;
  364. for (int y = 0; y < height; y++) {
  365. for (int x = 0; x < width; x++) {
  366. if (data[offset] == 0 && magnitude[offset] >= high) {
  367. follow(x, y, offset, low);
  368. }
  369. offset++;
  370. }
  371. }
  372. }
  373. private void follow(int x1, int y1, int i1, int threshold) {
  374. int x0 = x1 == 0 ? x1 : x1 - 1;
  375. int x2 = x1 == width - 1 ? x1 : x1 + 1;
  376. int y0 = y1 == 0 ? y1 : y1 - 1;
  377. int y2 = y1 == height -1 ? y1 : y1 + 1;
  378. data[i1] = magnitude[i1];
  379. for (int x = x0; x <= x2; x++) {
  380. for (int y = y0; y <= y2; y++) {
  381. int i2 = x + y * width;
  382. if ((y != y1 || x != x1)
  383. && data[i2] == 0
  384. && magnitude[i2] >= threshold) {
  385. follow(x, y, i2, threshold);
  386. return;
  387. }
  388. }
  389. }
  390. }
  391. private void thresholdEdges() {
  392. for (int i = 0; i < picsize; i++) {
  393. data[i] = data[i] > 0 ? -1 : 0xff000000;
  394. }
  395. }
  396. private int luminance(float r, float g, float b) {
  397. return Math.round(0.299f * r + 0.587f * g + 0.114f * b);
  398. }
  399. private void readLuminance() {
  400. int type = sourceImage.getType();
  401. if (type == BufferedImage.TYPE_INT_RGB || type == BufferedImage.TYPE_INT_ARGB) {
  402. int[] pixels = (int[]) sourceImage.getData().getDataElements(0, 0, width, height, null);
  403. for (int i = 0; i < picsize; i++) {
  404. int p = pixels[i];
  405. int r = (p & 0xff0000) >> 16;
  406. int g = (p & 0xff00) >> 8;
  407. int b = p & 0xff;
  408. data[i] = luminance(r, g, b);
  409. }
  410. } else if (type == BufferedImage.TYPE_BYTE_GRAY) {
  411. byte[] pixels = (byte[]) sourceImage.getData().getDataElements(0, 0, width, height, null);
  412. for (int i = 0; i < picsize; i++) {
  413. data[i] = (pixels[i] & 0xff);
  414. }
  415. } else if (type == BufferedImage.TYPE_USHORT_GRAY) {
  416. short[] pixels = (short[]) sourceImage.getData().getDataElements(0, 0, width, height, null);
  417. for (int i = 0; i < picsize; i++) {
  418. data[i] = (pixels[i] & 0xffff) / 256;
  419. }
  420. } else if (type == BufferedImage.TYPE_3BYTE_BGR) {
  421. byte[] pixels = (byte[]) sourceImage.getData().getDataElements(0, 0, width, height, null);
  422. int offset = 0;
  423. for (int i = 0; i < picsize; i++) {
  424. int b = pixels[offset++] & 0xff;
  425. int g = pixels[offset++] & 0xff;
  426. int r = pixels[offset++] & 0xff;
  427. data[i] = luminance(r, g, b);
  428. }
  429. } else {
  430. throw new IllegalArgumentException("Unsupported image type: " + type);
  431. }
  432. }
  433. private void normalizeContrast() {
  434. int[] histogram = new int[256];
  435. for (int i = 0; i < data.length; i++) {
  436. histogram[data[i]]++;
  437. }
  438. int[] remap = new int[256];
  439. int sum = 0;
  440. int j = 0;
  441. for (int i = 0; i < histogram.length; i++) {
  442. sum += histogram[i];
  443. int target = sum*255/picsize;
  444. for (int k = j+1; k <=target; k++) {
  445. remap[k] = i;
  446. }
  447. j = target;
  448. }
  449. for (int i = 0; i < data.length; i++) {
  450. data[i] = remap[data[i]];
  451. }
  452. }
  453. private void writeEdges(int pixels[]) {
  454. if (edgesImage == null) {
  455. edgesImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
  456. }
  457. edgesImage.getWritableTile(0, 0).setDataElements(0, 0, width, height, pixels);
  458. }
  459. }
  460. /***************************************
  461. * SOBELEDGE DETECTION FOR VECTOR TRACING
  462. ***************************************/
  463. SobelEdgeDetection sobel;
  464. PImage sobelEdge(PImage img) {
  465. PImage g_img = sobel.findEdgesAll(img, 90);
  466. g_img = sobel.noiseReduction(g_img, 1);
  467. return(g_img);
  468. }
  469. class SobelEdgeDetection
  470. {
  471. // Sobel Edge Detection strandard, this applies the edge detection algorithm across the entire image and returns the edge image
  472. public PImage findEdgesAll(PImage img, int tolerance)
  473. {
  474. PImage buf = createImage( img.width, img.height, ARGB );
  475. int GX[][] = new int[3][3];
  476. int GY[][] = new int[3][3];
  477. int sumRx = 0;
  478. int sumGx = 0;
  479. int sumBx = 0;
  480. int sumRy = 0;
  481. int sumGy = 0;
  482. int sumBy = 0;
  483. int finalSumR = 0;
  484. int finalSumG = 0;
  485. int finalSumB = 0;
  486. // 3x3 Sobel Mask for X
  487. GX[0][0] = -1;
  488. GX[0][1] = 0;
  489. GX[0][2] = 1;
  490. GX[1][0] = -2;
  491. GX[1][1] = 0;
  492. GX[1][2] = 2;
  493. GX[2][0] = -1;
  494. GX[2][1] = 0;
  495. GX[2][2] = 1;
  496. // 3x3 Sobel Mask for Y
  497. GY[0][0] = 1;
  498. GY[0][1] = 2;
  499. GY[0][2] = 1;
  500. GY[1][0] = 0;
  501. GY[1][1] = 0;
  502. GY[1][2] = 0;
  503. GY[2][0] = -1;
  504. GY[2][1] = -2;
  505. GY[2][2] = -1;
  506. buf.loadPixels();
  507. for(int y = 0; y < img.height; y++)
  508. {
  509. for(int x = 0; x < img.width; x++)
  510. {
  511. if(y==0 || y==img.height-1) {
  512. }
  513. else if( x==0 || x == img.width-1 ) {
  514. }
  515. else
  516. {
  517. // Convolve across the X axis and return gradiant aproximation
  518. for(int i = -1; i <= 1; i++)
  519. for(int j = -1; j <= 1; j++)
  520. {
  521. color col = img.get(x + i, y + j);
  522. float r = red(col);
  523. float g = green(col);
  524. float b = blue(col);
  525. sumRx += r * GX[ i + 1][ j + 1];
  526. sumGx += g * GX[ i + 1][ j + 1];
  527. sumBx += b * GX[ i + 1][ j + 1];
  528. }
  529. // Convolve across the Y axis and return gradiant aproximation
  530. for(int i = -1; i <= 1; i++)
  531. for(int j = -1; j <= 1; j++)
  532. {
  533. color col = img.get(x + i, y + j);
  534. float r = red(col);
  535. float g = green(col);
  536. float b = blue(col);
  537. sumRy += r * GY[ i + 1][ j + 1];
  538. sumGy += g * GY[ i + 1][ j + 1];
  539. sumBy += b * GY[ i + 1][ j + 1];
  540. }
  541. finalSumR = abs(sumRx) + abs(sumRy);
  542. finalSumG = abs(sumGx) + abs(sumGy);
  543. finalSumB = abs(sumBx) + abs(sumBy);
  544. // I only want to return a black or a white value, here I determine the greyscale value,
  545. // and if it is above a tolerance, then set the colour to white
  546. float gray = (finalSumR + finalSumG + finalSumB) / 3;
  547. if(gray > tolerance)
  548. {
  549. finalSumR = 0;
  550. finalSumG = 0;
  551. finalSumB = 0;
  552. }
  553. else
  554. {
  555. finalSumR = 255;
  556. finalSumG = 255;
  557. finalSumB = 255;
  558. }
  559. buf.pixels[ x + (y * img.width) ] = color(finalSumR, finalSumG, finalSumB);
  560. sumRx=0;
  561. sumGx=0;
  562. sumBx=0;
  563. sumRy=0;
  564. sumGy=0;
  565. sumBy=0;
  566. }
  567. }
  568. }
  569. buf.updatePixels();
  570. return buf;
  571. }
  572. public PImage noiseReduction(PImage img, int kernel)
  573. {
  574. PImage buf = createImage( img.width, img.height, ARGB );
  575. buf.loadPixels();
  576. for(int y = 0; y < img.height; y++)
  577. {
  578. for(int x = 0; x < img.width; x++)
  579. {
  580. int sumR = 0;
  581. int sumG = 0;
  582. int sumB = 0;
  583. // Convolute across the image, averages out the pixels to remove noise
  584. for(int i = -kernel; i <= kernel; i++)
  585. {
  586. for(int j = -kernel; j <= kernel; j++)
  587. {
  588. color col = img.get(x+i,y+j);
  589. float r = red(col);
  590. float g = green(col);
  591. float b = blue(col);
  592. if(r==255) sumR++;
  593. if(g==255) sumG++;
  594. if(b==255) sumB++;
  595. }
  596. }
  597. int halfKernel = (((kernel*2)+1) * ((kernel*2)+1)) / 2 ;
  598. if(sumR > halfKernel ) sumR=255;
  599. else sumR= 0;
  600. if(sumG > halfKernel ) sumG=255;
  601. else sumG= 0;
  602. if(sumB > halfKernel ) sumB=255;
  603. else sumB= 0;
  604. buf.pixels[ x + (y * img.width) ] = color(sumR, sumG, sumB);
  605. }
  606. }
  607. buf.updatePixels();
  608. return buf;
  609. }
  610. }