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; }