sigonasr2
/
olcPixelGameEngine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added 8Bits Image Processing Video

Browse Source
pull/113/head
Javidx9 6 years ago committed by GitHub
parent 7a84b90858
commit b611a826c8
1 changed files with 504 additions and 0 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 504
      OneLoneCoder_PGE_8BitsImProc.cpp

504
OneLoneCoder_PGE_8BitsImProc.cpp
Unescape View File

@ -0,0 +1,504 @@
/*
8-Bits Of Image Processing You Should Know
"Colin, at least you'll always get 700s now..." - javidx9
License (OLC-3)
~~~~~~~~~~~~~~~
Copyright 2018-2019 OneLoneCoder.com
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions or derivations of source code must retain the above
copyright notice, this list of conditions and the following disclaimer.
2. Redistributions or derivative works in binary form must reproduce
the above copyright notice. This list of conditions and the following
disclaimer must be reproduced in the documentation and/or other
materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Instructions:
~~~~~~~~~~~~~
Choose algorithm 1-8, instructions on screen
Relevant Video: https://youtu.be/mRM5Js3VLCk
Links
~~~~~
YouTube: https://www.youtube.com/javidx9
https://www.youtube.com/javidx9extra
Discord: https://discord.gg/WhwHUMV
Twitter: https://www.twitter.com/javidx9
Twitch: https://www.twitch.tv/javidx9
GitHub: https://www.github.com/onelonecoder
Patreon: https://www.patreon.com/javidx9
Homepage: https://www.onelonecoder.com
Author
~~~~~~
David Barr, aka javidx9, ©OneLoneCoder 2019
*/
#define OLC_PGE_APPLICATION
#include "olcPixelGameEngine.h"
#include "escapi.h"
int nFrameWidth = 320;
int nFrameHeight = 240;
struct frame
{
float *pixels = nullptr;
frame()
{
pixels = new float[nFrameWidth * nFrameHeight];
}
~frame()
{
delete[] pixels;
}
float get(int x, int y)
{
if (x >= 0 && x < nFrameWidth && y >= 0 && y < nFrameHeight)
{
return pixels[y*nFrameWidth + x];
}
else
return 0.0f;
}
void set(int x, int y, float p)
{
if (x >= 0 && x < nFrameWidth && y >= 0 && y < nFrameHeight)
{
pixels[y*nFrameWidth + x] = p;
}
}
void operator=(const frame &f)
{
memcpy(this->pixels, f.pixels, nFrameWidth * nFrameHeight * sizeof(float));
}
};
class WIP_ImageProcessing : public olc::PixelGameEngine
{
public:
WIP_ImageProcessing()
{
sAppName = "WIP_ImageProcessing";
}
union RGBint
{
int rgb;
unsigned char c[4];
};
int nCameras = 0;
SimpleCapParams capture;
public:
bool OnUserCreate() override
{
// Initialise webcam to screen dimensions
nCameras = setupESCAPI();
if (nCameras == 0) return false;
capture.mWidth = nFrameWidth;
capture.mHeight = nFrameHeight;
capture.mTargetBuf = new int[nFrameWidth * nFrameHeight];
if (initCapture(0, &capture) == 0) return false;
return true;
}
void DrawFrame(frame &f, int x, int y)
{
for (int i = 0; i < nFrameWidth; i++)
for (int j = 0; j < nFrameHeight; j++)
{
int c = (int)std::min(std::max(0.0f, f.pixels[j*nFrameWidth + i] * 255.0f), 255.0f);
Draw(x + i, y + j, olc::Pixel(c, c, c));
}
}
enum ALGORITHM
{
THRESHOLD, MOTION, LOWPASS, CONVOLUTION,
SOBEL, MORPHO, MEDIAN, ADAPTIVE,
};
enum MORPHOP
{
DILATION,
EROSION,
EDGE
};
frame input, output, prev_input, activity, threshold;
// Algorithm Currently Running
ALGORITHM algo = THRESHOLD;
MORPHOP morph = DILATION;
int nMorphCount = 1;
float fThresholdValue = 0.5f;
float fLowPassRC = 0.1f;
float fAdaptiveBias = 1.1f;
float *pConvoKernel = kernel_blur;
float kernel_blur[9] =
{
0.0f, 0.125, 0.0f,
0.125f, 0.5f, 0.125f,
0.0f, 0.125f, 0.0f,
};
float kernel_sharpen[9] =
{
0.0f, -1.0f, 0.0f,
-1.0f, 5.0f, -1.0f,
0.0f, -1.0f, 0.0f,
};
float kernel_sobel_v[9] =
{
-1.0f, 0.0f, +1.0f,
-2.0f, 0.0f, +2.0f,
-1.0f, 0.0f, +1.0f,
};
float kernel_sobel_h[9] =
{
-1.0f, -2.0f, -1.0f,
0.0f, 0.0f, 0.0f,
+1.0f, +2.0f, +1.0f,
};
bool OnUserUpdate(float fElapsedTime) override
{
// CAPTURING WEBCAM IMAGE
prev_input = input;
doCapture(0); while (isCaptureDone(0) == 0) {}
for (int y = 0; y < capture.mHeight; y++)
for (int x = 0; x < capture.mWidth; x++)
{
RGBint col;
int id = y * capture.mWidth + x;
col.rgb = capture.mTargetBuf[id];
input.pixels[y*nFrameWidth + x] = (float)col.c[1] / 255.0f;
}
if (GetKey(olc::Key::K1).bReleased) algo = THRESHOLD;
if (GetKey(olc::Key::K2).bReleased) algo = MOTION;
if (GetKey(olc::Key::K3).bReleased) algo = LOWPASS;
if (GetKey(olc::Key::K4).bReleased) algo = CONVOLUTION;
if (GetKey(olc::Key::K5).bReleased) algo = SOBEL;
if (GetKey(olc::Key::K6).bReleased) algo = MORPHO;
if (GetKey(olc::Key::K7).bReleased) algo = MEDIAN;
if (GetKey(olc::Key::K8).bReleased) algo = ADAPTIVE;
switch (algo)
{
case THRESHOLD:
// Respond to user input
if (GetKey(olc::Key::Z).bHeld) fThresholdValue -= 0.1f * fElapsedTime;
if (GetKey(olc::Key::X).bHeld) fThresholdValue += 0.1f * fElapsedTime;
if (fThresholdValue > 1.0f) fThresholdValue = 1.0f;
if (fThresholdValue < 0.0f) fThresholdValue = 0.0f;
// Perform threshold per pixel
for (int i = 0; i < nFrameWidth; i++)
for (int j = 0; j < nFrameHeight; j++)
output.set(i, j, input.get(i, j) >= fThresholdValue ? 1.0f : 0.0f);
break;
case MOTION:
// Returns the absolute difference between successive frames per pixel
for (int i = 0; i < nFrameWidth; i++)
for (int j = 0; j < nFrameHeight; j++)
output.set(i, j, fabs(input.get(i, j) - prev_input.get(i, j)));
break;
case LOWPASS:
// Respond to user input
if (GetKey(olc::Key::Z).bHeld) fLowPassRC -= 0.1f * fElapsedTime;
if (GetKey(olc::Key::X).bHeld) fLowPassRC += 0.1f * fElapsedTime;
if (fLowPassRC > 1.0f) fLowPassRC = 1.0f;
if (fLowPassRC < 0.0f) fLowPassRC = 0.0f;
// Pass each pixel through a temporal RC filter
for (int i = 0; i < nFrameWidth; i++)
for (int j = 0; j < nFrameHeight; j++)
{
float dPixel = input.get(i, j) - output.get(i, j);
dPixel *= fLowPassRC;
output.set(i, j, dPixel + output.get(i, j));
}
break;
case CONVOLUTION:
// Respond to user input
if (GetKey(olc::Key::Z).bHeld) pConvoKernel = kernel_blur;
if (GetKey(olc::Key::X).bHeld) pConvoKernel = kernel_sharpen;
for (int i = 0; i < nFrameWidth; i++)
for (int j = 0; j < nFrameHeight; j++)
{
float fSum = 0.0f;
for (int n = -1; n < +2; n++)
for (int m = -1; m < +2; m++)
fSum += input.get(i + n, j + m) * pConvoKernel[(m + 1) * 3 + (n + 1)];
output.set(i, j, fSum);
}
break;
case SOBEL:
for (int i = 0; i < nFrameWidth; i++)
for (int j = 0; j < nFrameHeight; j++)
{
float fKernelSumH = 0.0f;
float fKernelSumV = 0.0f;
for (int n = -1; n < +2; n++)
for (int m = -1; m < +2; m++)
{
fKernelSumH += input.get(i + n, j + m) * kernel_sobel_h[(m + 1) * 3 + (n + 1)];
fKernelSumV += input.get(i + n, j + m) * kernel_sobel_v[(m + 1) * 3 + (n + 1)];
}
output.set(i, j, fabs((fKernelSumH + fKernelSumV) / 2.0f));
}
break;
case MORPHO:
// Respond to user input
if (GetKey(olc::Key::Z).bHeld) morph = DILATION;
if (GetKey(olc::Key::X).bHeld) morph = EROSION;
if (GetKey(olc::Key::C).bHeld) morph = EDGE;
if (GetKey(olc::Key::A).bReleased) nMorphCount--;
if (GetKey(olc::Key::S).bReleased) nMorphCount++;
if (nMorphCount > 10.0f) nMorphCount = 10.0f;
if (nMorphCount < 1.0f) nMorphCount = 1.0f;
// Threshold First to binarise image
for (int i = 0; i < nFrameWidth; i++)
for (int j = 0; j < nFrameHeight; j++)
{
activity.set(i, j, input.get(i, j) > fThresholdValue ? 1.0f : 0.0f);
}
threshold = activity;
switch (morph)
{
case DILATION:
for (int n = 0; n < nMorphCount; n++)
{
output = activity;
for (int i = 0; i < nFrameWidth; i++)
for (int j = 0; j < nFrameHeight; j++)
{
if (activity.get(i, j) == 1.0f)
{
output.set(i, j, 1.0f);
output.set(i - 1, j, 1.0f);
output.set(i + 1, j, 1.0f);
output.set(i, j - 1, 1.0f);
output.set(i, j + 1, 1.0f);
output.set(i - 1, j - 1, 1.0f);
output.set(i + 1, j + 1, 1.0f);
output.set(i + 1, j - 1, 1.0f);
output.set(i - 1, j + 1, 1.0f);
}
}
activity = output;
}
break;
case EROSION:
for (int n = 0; n < nMorphCount; n++)
{
output = activity;
for (int i = 0; i < nFrameWidth; i++)
for (int j = 0; j < nFrameHeight; j++)
{
float sum = activity.get(i - 1, j) + activity.get(i + 1, j) + activity.get(i, j - 1) + activity.get(i, j + 1) +
activity.get(i - 1, j - 1) + activity.get(i + 1, j + 1) + activity.get(i + 1, j - 1) + activity.get(i - 1, j + 1);
if (activity.get(i, j) == 1.0f && sum < 8.0f)
{
output.set(i, j, 0.0f);
}
}
activity = output;
}
break;
case EDGE:
output = activity;
for (int i = 0; i < nFrameWidth; i++)
for (int j = 0; j < nFrameHeight; j++)
{
float sum = activity.get(i - 1, j) + activity.get(i + 1, j) + activity.get(i, j - 1) + activity.get(i, j + 1) +
activity.get(i - 1, j - 1) + activity.get(i + 1, j + 1) + activity.get(i + 1, j - 1) + activity.get(i - 1, j + 1);
if (activity.get(i, j) == 1.0f && sum == 8.0f)
{
output.set(i, j, 0.0f);
}
}
break;
}
break;
case MEDIAN:
for (int i = 0; i < nFrameWidth; i++)
for (int j = 0; j < nFrameHeight; j++)
{
std::vector<float> v;
for (int n = -2; n < +3; n++)
for (int m = -2; m < +3; m++)
v.push_back(input.get(i + n, j + m));
std::sort(v.begin(), v.end(), std::greater<float>());
output.set(i, j, v[12]);
}
break;
case ADAPTIVE:
// Respond to user input
if (GetKey(olc::Key::Z).bHeld) fAdaptiveBias -= 0.1f * fElapsedTime;
if (GetKey(olc::Key::X).bHeld) fAdaptiveBias += 0.1f * fElapsedTime;
if (fAdaptiveBias > 1.5f) fAdaptiveBias = 1.5f;
if (fAdaptiveBias < 0.5f) fAdaptiveBias = 0.5f;
for (int i = 0; i < nFrameWidth; i++)
for (int j = 0; j < nFrameHeight; j++)
{
float fRegionSum = 0.0f;
for (int n = -2; n < +3; n++)
for (int m = -2; m < +3; m++)
fRegionSum += input.get(i + n, j + m);
fRegionSum /= 25.0f;
output.set(i, j, input.get(i, j) > (fRegionSum * fAdaptiveBias) ? 1.0f : 0.0f);
}
break;
}
// DRAW STUFF ONLY HERE
Clear(olc::DARK_BLUE);
DrawFrame(algo == MORPHO ? threshold : input, 10, 10);
DrawFrame(output, 340, 10);
DrawString(150, 255, "INPUT");
DrawString(480, 255, "OUTPUT");
DrawString(10, 275, "1) Threshold");
DrawString(10, 285, "2) Absolute Motion");
DrawString(10, 295, "3) Low-Pass Temporal Filtering");
DrawString(10, 305, "4) Convolution (Blurring/Sharpening)");
DrawString(10, 315, "5) Sobel Edge Detection");
DrawString(10, 325, "6) Binary Morphological Operations (Erosion/Dilation)");
DrawString(10, 335, "7) Median Filter");
DrawString(10, 345, "8) Adaptive Threshold");
switch (algo)
{
case THRESHOLD:
DrawString(10, 375, "Change threshold value with Z and X keys");
DrawString(10, 385, "Current value = " + std::to_string(fThresholdValue));
break;
case LOWPASS:
DrawString(10, 375, "Change RC constant value with Z and X keys");
DrawString(10, 385, "Current value = " + std::to_string(fLowPassRC));
break;
case CONVOLUTION:
DrawString(10, 375, "Change convolution kernel with Z and X keys");
DrawString(10, 385, "Current kernel = " + std::string((pConvoKernel == kernel_blur) ? "Blur" : "Sharpen"));
break;
case MORPHO:
DrawString(10, 375, "Change operation with Z and X and C keys");
if (morph == DILATION) DrawString(10, 385, "Current operation = DILATION");
if (morph == EROSION) DrawString(10, 385, "Current operation = EROSION");
if (morph == EDGE) DrawString(10, 385, "Current operation = EDGE");
DrawString(10, 395, "Change Iterations with A and S keys");
DrawString(10, 405, "Current iteration count = " + std::to_string(nMorphCount));
break;
case ADAPTIVE:
DrawString(10, 375, "Change adaptive threshold bias with Z and X keys");
DrawString(10, 385, "Current value = " + std::to_string(fAdaptiveBias));
break;
default:
break;
}
if (GetKey(olc::Key::ESCAPE).bPressed) return false;
return true;
}
};
int main()
{
WIP_ImageProcessing demo;
if (demo.Construct(670, 460, 2, 2))
demo.Start();
return 0;
}
Write Preview
Loading…
Cancel
Save