IntensityImage * DefaultPreProcessing::stepEdgeDetection(const IntensityImage &src) const {
// Maak een basetimer aan. De basetimer wordt gebruikt om de tijd bij te houden
// die de implementatie gebruikt.
BaseTimer basetimer;
// Start de basetimer.
basetimer.start();
cv::Mat OverHillOverDale;
HereBeDragons::HerLoveForWhoseDearLoveIRiseAndFall(src, OverHillOverDale);
//cv::medianBlur(*image, *image, 3);
//cv::GaussianBlur(*image, *image, cv::Size(3, 3), 0, 0, cv::BORDER_DEFAULT);
cv::Mat ThoroughBushThoroughBrier = (cv::Mat_<float>(9, 9) << 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, -4, -4, -4, 1, 1, 1, 1, 1, 1, -4, -4, -4, 1, 1, 1, 1, 1, 1, -4, -4, -4, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0);
cv::Mat OverParkOverPale;
filter2D(OverHillOverDale, OverParkOverPale, CV_8U, ThoroughBushThoroughBrier, cv::Point(-1, -1), 0, cv::BORDER_DEFAULT);
IntensityImage * ThoroughFloodThoroughFire = ImageFactory::newIntensityImage();
HereBeDragons::NoWantOfConscienceHoldItThatICall(OverParkOverPale, *ThoroughFloodThoroughFire);
// Stop de timer
basetimer.stop();
// Schrijf de tijd dat nodig is geweest naar een output file.
std::ofstream myfile;
myfile.open("tijdedge.txt", std::ofstream::ate);
myfile << "EdgeDetectionDefault convert tijd in s: " << basetimer.elapsedSeconds() << " tijd ms:"
<< basetimer.elapsedMilliSeconds() << " tijd us" << basetimer.elapsedMicroSeconds();
myfile.close();
// return de gemaakte afbeelding.
return ThoroughFloodThoroughFire;
}
void Test::RunCannyTest(const RGBImage* in) {
Gaussian smoother;
Sobel sobel;
Canny canny;
StudentPreProcessing converter;
double sigma = 1.6;
int kernelSize = 5;
// Convert RGB to Intensity
IntensityImage* grey = ImageFactory::newIntensityImage(in->getWidth(), in->getHeight());
grey = converter.stepToIntensityImage(*in);
BaseTimer timer;
int total = 0;
for (int i = 0; i < 10; ++i) {
timer.start();
/* Start of Canny */
// 1. Smooth Intensity with Gaussian
IntensityImage* gaussian = ImageFactory::newIntensityImage(in->getWidth() - kernelSize, in->getHeight() - kernelSize);
smoother.smoothImage(grey, gaussian, sigma, kernelSize);
// 2. Find edges with Sobel (convolve X and Y separately for Canny)
int sobelKernelSize = 3;
IntensityImage* sobelX = ImageFactory::newIntensityImage(gaussian->getWidth() - sobelKernelSize, gaussian->getHeight() - sobelKernelSize);
IntensityImage* sobelY = ImageFactory::newIntensityImage(gaussian->getWidth() - sobelKernelSize, gaussian->getHeight() - sobelKernelSize);
sobel.filterXY(gaussian, sobelX, sobelY);
// 3. Apply non-maximum suppresion
IntensityImage* nonMaxSuppression = ImageFactory::newIntensityImage(sobelX->getWidth(), sobelX->getHeight());
canny.nonMaximumSurpression(sobelX, sobelY, nonMaxSuppression);
// 4. Apply hysteresis threshold
IntensityImage* hysteresisThreshold = ImageFactory::newIntensityImage(sobelX->getWidth(), sobelX->getHeight());
canny.threshold(nonMaxSuppression, hysteresisThreshold, 60, 70);
timer.stop();
std::cout << timer.elapsedMilliSeconds() << " ms" << std::endl;
total += timer.elapsedMilliSeconds();
timer.reset();
if (i == 9)
ImageIO::saveIntensityImage(*hysteresisThreshold, ImageIO::getDebugFileName("Canny.png"));
}
std::cout << "Average time per Canny edge detection: " << (total / 10) << " ms" << std::endl;
std::cout << "Press the X in the console window to exit program" << std::endl;
}
void Test::RunScaleTest(RGBImage* in) {
StudentPreProcessing sPre;
IntensityImage* grey = ImageFactory::newIntensityImage(in->getWidth(), in->getHeight());
grey = sPre.stepToIntensityImage(*in);
IntensityImage* scale;
BaseTimer timer;
int total = 0;
for (int i = 0; i < 10; ++i) {
timer.start();
scale = sPre.stepScaleImage(*grey);
timer.stop();
std::cout << timer.elapsedMicroSeconds() << " us" << std::endl;
total += timer.elapsedMicroSeconds();
timer.reset();
}
std::cout << "Gemiddelde tijd: " << (total / 10) << " us" << std::endl;
}
IntensityImage * DefaultPreProcessing::stepThresholding(const IntensityImage &src) const {
// Maak een basetimer aan. De basetimer wordt gebruikt om de tijd bij te houden
// die de implementatie gebruikt.
BaseTimer basetimer;
// Start de basetimer.
basetimer.start();
cv::Mat OverHillOverDale;
HereBeDragons::HerLoveForWhoseDearLoveIRiseAndFall(src, OverHillOverDale);
cv::threshold(OverHillOverDale, OverHillOverDale, 220, 255, cv::THRESH_BINARY_INV);
IntensityImage * ThoroughBushThoroughBrier = ImageFactory::newIntensityImage();
HereBeDragons::NoWantOfConscienceHoldItThatICall(OverHillOverDale, *ThoroughBushThoroughBrier);
// Stop de timer
basetimer.stop();
// Schrijf de tijd dat nodig is geweest naar een output file.
std::ofstream myfile;
myfile.open("tijdtresholding.txt", std::ofstream::ate);
myfile << "ThresholdingDefault convert tijd in s: " << basetimer.elapsedSeconds() << " tijd ms:"
<< basetimer.elapsedMilliSeconds() << " tijd us" << basetimer.elapsedMicroSeconds();
myfile.close();
return ThoroughBushThoroughBrier;
}
bool executeSteps(DLLExecution * executor) {
//Execute the four Pre-processing steps
if (!executor->executePreProcessingStep1(false)) {
std::cout << "Pre-processing step 1 failed!" << std::endl;
return false;
}
if (!executor->executePreProcessingStep2(false)) {
std::cout << "Pre-processing step 2 failed!" << std::endl;
return false;
}
ImageIO::saveIntensityImage(*executor->resultPreProcessingStep2, ImageIO::getDebugFileName("Pre-processing-2.png"));
if (!executor->executePreProcessingStep3(false)) {
std::cout << "Pre-processing step 3 failed!" << std::endl;
return false;
}
ImageIO::saveIntensityImage(*executor->resultPreProcessingStep3, ImageIO::getDebugFileName("Pre-processing-3.png"));
if (!executor->executePreProcessingStep4(false)) {
std::cout << "Pre-processing step 4 failed!" << std::endl;
return false;
}
ImageIO::saveIntensityImage(*executor->resultPreProcessingStep4, ImageIO::getDebugFileName("Pre-processing-4.png"));
//Execute the localization steps
if (!executor->prepareLocalization()) {
std::cout << "Localization preparation failed!" << std::endl;
return false;
}
std::vector<long long> time;
for (int i = 0; i < 10000; ++i){
bt.start();
if (!executor->executeLocalizationStep1(true)) {
std::cout << "Localization step 1 failed!" << std::endl;
return false;
}
bt.stop();
time.push_back(bt.elapsedMicroSeconds()); \
bt.reset();
}
long long total = 0;
for (int i = 0; i < time.size(); ++i){
total = total + time[i];
}
long long average = total / time.size();
std::cout << average;
if (!executor->executeLocalizationStep2(false)) {
std::cout << "Localization step 2 failed!" << std::endl;
return false;
}
if (!executor->executeLocalizationStep3(false)) {
std::cout << "Localization step 3 failed!" << std::endl;
return false;
}
if (!executor->executeLocalizationStep4(false)) {
std::cout << "Localization step 4 failed!" << std::endl;
return false;
}
if (!executor->executeLocalizationStep5(false)) {
std::cout << "Localization step 5 failed!" << std::endl;
return false;
}
//Execute the extraction steps
if (!executor->prepareExtraction()) {
std::cout << "Extraction preparation failed!" << std::endl;
return false;
}
if (!executor->executeExtractionStep1(false)) {
std::cout << "Extraction step 1 failed!" << std::endl;
return false;
}
if (!executor->executeExtractionStep2(false)) {
std::cout << "Extraction step 2 failed!" << std::endl;
return false;
}
if (!executor->executeExtractionStep3(false)) {
std::cout << "Extraction step 3 failed!" << std::endl;
return false;
}
//Post processing and representation
if (!executor->executePostProcessing()) {
std::cout << "Post-processing failed!" << std::endl;
return false;
}
drawFeatureDebugImage(*executor->resultPreProcessingStep1, executor->featuresScaled);
if (!executor->executeRepresentation()) {
std::cout << "Representation failed!" << std::endl;
return false;
}
return true;
}
bool StudentLocalization::stepFindChinContours(const IntensityImage &image, FeatureMap &features) const {
// Maak een basetimer object om de tijd bij te houden dat de implementatie nodig heeft.
BaseTimer basetimer;
// Start de basetimer.
basetimer.start();
// test getal
int startStep = 15;
bool first = true;
// Sla het middenpunt van de mond op.
Point2D<double> MouthCenterPoint = features.getFeature(Feature::FEATURE_MOUTH_CENTER).getPoints()[0];
// Sla het kin punt op.
Point2D<double> ChinPoint = features.getFeature(Feature::FEATURE_CHIN).getPoints()[0];
int range = MouthCenterPoint.getY() - ChinPoint.getY();
// Object om kincountoer punten in op te slaan.
Feature output = Feature(Feature::FEATURE_CHIN_CONTOUR);
int degrees;
int steps = 15;
int lastdif;
double correction = -1;
int lastSteps = 0;
int vorigeX = 0;
// Bereken 20 punten van de kin.
for (int i = 0; i < 19; i++)
{
bool ireg = false;
if (i>9)
{
correction = 1;
}
else if (i < 9)
{
correction =0;
}
// Sla middelpunt mond x op.
int checkX = MouthCenterPoint.getX();
// Sla middelpunt mond y op.
int checkY = MouthCenterPoint.getY();
double gradenInRad = (-90+(i * 10)) *(PI/180);
steps = startStep;
Point2D<double> gevondenPunt;
// Middelste punt van de kin is als het goed is bekend. Dit is punt nummer 9 dus zal worden overgeslagen.
if (i != 9)
{
while (true)
{
if (!first&&steps > startStep + 10)
{
lastdif / i;
ireg = true;
gevondenPunt.set(MouthCenterPoint.getX() + ((lastSteps + correction)* std::sin(gradenInRad)), MouthCenterPoint.getY() + ((lastSteps + correction) * std::cos(gradenInRad)));
steps = lastSteps + correction;
break;
}
checkX = MouthCenterPoint.getX()+ (steps * std::sin(gradenInRad));
checkY = MouthCenterPoint.getY()+(steps * std::cos(gradenInRad));
Intensity pixel = image.getPixel(std::round(checkX), std::round(checkY));
if (int(pixel) == 0)
{
if (checkX - vorigeX <2)
{
lastdif / i;
ireg = true;
gevondenPunt.set(MouthCenterPoint.getX() + ((lastSteps + correction)* std::sin(gradenInRad)), MouthCenterPoint.getY() + ((lastSteps + correction) * std::cos(gradenInRad)));
steps = lastSteps + correction;
break;
}
ireg=false;
gevondenPunt.set(checkX, checkY); break;
}
steps++;
}
vorigeX = checkX;
std::cout << gevondenPunt <<"\n";
startStep = steps - 5;
output.addPoint(Point2D<double>(gevondenPunt.x,gevondenPunt.y));
first=false;
if (ireg)
{
startStep = steps-5;
lastSteps = steps;
}
else
{
lastdif = lastSteps - steps;
lastSteps = steps;
}
}
else
{
output.addPoint(ChinPoint);
}
}
features.putFeature(output);
basetimer.stop();
std::ofstream myfile;
myfile.open("tijd.txt", std::ofstream::ate);
myfile << "Chincontours convert tijd in s: " << basetimer.elapsedSeconds() << " tijd ms:" << basetimer.elapsedMilliSeconds() << " tijd us" << basetimer.elapsedMicroSeconds();
myfile.close();
return true;
}
