void TransFuncEditorIntensityPet::maxBoxChanged(int value) {
if (value-1 > currentRange_.x) {
//increment minimum of upper spin when minimum was reached and we are above lower range
if (value == upperThresholdSpin_->minimum())
upperThresholdSpin_->setMinimum(value - 1);
//update maximum of lower spin
lowerThresholdSpin_->blockSignals(true);
lowerThresholdSpin_->setMaximum(value);
lowerThresholdSpin_->blockSignals(false);
}
//increment value of lower spin when it equals value of upper spin
if (value == lowerThresholdSpin_->value()) {
lowerThresholdSpin_->blockSignals(true);
lowerThresholdSpin_->setValue(value - 1);
lowerThresholdSpin_->blockSignals(false);
}
//update doubleSlider to new maxValue
float sliderMax = (value - currentRange_.x) / static_cast<float>(currentRange_.y - currentRange_.x);
doubleSlider_->blockSignals(true);
doubleSlider_->setMaxValue(sliderMax);
doubleSlider_->blockSignals(false);
//apply threshold to both transfer functions
applyThreshold();
updateTransferFunction();
}
int main()
{
char fileName[80];
int _ret_val_0;
sprintf(fileName, "%s/%s", DATA_PATH, INPUT_FILE);
input_dsp_arg(fileName, image, N * N, 1);
#pragma polca def BLOCK_ABS
{
int thresholdValue = T;
{
int c;
int r;
int aux;
for (r = 0; r < N; r++)
{
for (c = 0; c < N; c++)
{
aux = applyThreshold(image[r][c], thresholdValue);
result[r][c] = aux;
}
}
0;
}
}
sprintf(fileName, "%s/output.dsp", DATA_PATH);
output_dsp_arg(fileName, result, N * N, 1);
_ret_val_0 = 0;
return _ret_val_0;
}
void TransFunc1DRampEditor::upperThresholdSpinChanged(int value) {
if (value-1 > 0) {
//increment minimum of upper spin when minimum was reached and we are above lower range
if (value == upperThresholdSpin_->minimum())
upperThresholdSpin_->setMinimum(value-1);
//update maximum of lower spin
lowerThresholdSpin_->blockSignals(true);
lowerThresholdSpin_->setMaximum(value);
lowerThresholdSpin_->blockSignals(false);
}
//increment value of lower spin when it equals value of upper spin
if (value == lowerThresholdSpin_->value()) {
lowerThresholdSpin_->blockSignals(true);
lowerThresholdSpin_->setValue(value-1);
lowerThresholdSpin_->blockSignals(false);
}
//update doubleSlider to new maxValue
doubleSlider_->blockSignals(true);
doubleSlider_->setMaxValue(value / static_cast<float>(maximumIntensity_));
doubleSlider_->blockSignals(false);
//apply threshold to transfer function
applyThreshold();
}
void TransFuncEditorIntensityPet::resetThresholds() {
ranges_.clear();
currentRange_ = tgt::ivec2(0, maximumIntensity_);
oldThreshold_ = tgt::vec2(0.f, 1.f);
//reset spinboxes to default
lowerThresholdSpin_->blockSignals(true);
lowerThresholdSpin_->setRange(0, maximumIntensity_ - 1);
lowerThresholdSpin_->setValue(0);
lowerThresholdSpin_->blockSignals(false);
upperThresholdSpin_->blockSignals(true);
upperThresholdSpin_->setRange(1, maximumIntensity_);
upperThresholdSpin_->setValue(maximumIntensity_);
upperThresholdSpin_->blockSignals(false);
//reset doubleslider
doubleSlider_->setMinimalAllowedSliderDistance(1.f / static_cast<float>(maximumIntensity_));
doubleSlider_->blockSignals(true);
doubleSlider_->setValues(0.f, 1.f);
doubleSlider_->blockSignals(false);
transferFuncIntensity_->setThresholds(0.f, 1.f);
transferFuncGradient_->setThresholds(0.f, 1.f);
applyThreshold();
}
void TransFuncEditorIntensityRamp::lowerThresholdSpinChanged(int value) {
if (value+1 < maximumIntensity_) {
//increment maximum of lower spin when maximum was reached and we are below upper range
if (value == lowerThresholdSpin_->maximum())
lowerThresholdSpin_->setMaximum(value+1);
//update minimum of upper spin
upperThresholdSpin_->blockSignals(true);
upperThresholdSpin_->setMinimum(value);
upperThresholdSpin_->blockSignals(false);
}
//increment value of upper spin when it equals value of lower spin
if (value == upperThresholdSpin_->value()) {
upperThresholdSpin_->blockSignals(true);
upperThresholdSpin_->setValue(value+1);
upperThresholdSpin_->blockSignals(false);
}
//update doubleSlider to new minValue
doubleSlider_->blockSignals(true);
doubleSlider_->setMinValue(value / static_cast<float>(maximumIntensity_));
doubleSlider_->blockSignals(false);
//apply threshold to transfer function
applyThreshold();
}
cv::Mat LaneDetector::getLaneBinary(cv::Mat &image) {
cv::Mat threshold_image(image.rows, image.cols, CV_8UC1, cvScalarAll(0));
cv::Mat hough_image(image.rows, image.cols, CV_8UC1, cvScalarAll(0));
threshold_image = applyThreshold(image, debug_mode);
hough_image = applyHough(threshold_image, debug_mode);
return hough_image;
} // Detect lanes and return a binary image with Lanes only
void Prewitt::save(int threshold){
if(threshold == 0){
cv::imwrite(getName(PREFIX, name, threshold), imagePrewitt);
}else{
cv::Mat img = applyThreshold(threshold);
cv::imwrite(getName(PREFIX, name, threshold), img);
}
}
cv::Mat MorphoFeatures::getEdges(const cv::Mat& image)
{
cv::Mat result;
// Take a gradient
cv::morphologyEx(image, result, cv::MORPH_GRADIENT, cv::Mat());
// Apply threshold to get binary image
applyThreshold(result);
return result;
}
BBFind::Rectangles BBFind::placePotentialBoxes(const Map3 fullMap)
{
// Takes in a map of distances to edges and greedily places
// a potential box at every local maximum. Because the distance
// map is clipped, this should place numerous small boxes
// inside the center of detected objects above the minimum size.
// These boxes are later merged to form a single larger
// bounding box for each object.
int numCategories = fullMap.size();
int mapWidth = fullMap[0][0].size();
int mapHeight = fullMap[0].size();
float val = 0.0f;
float maxVal = 0.0f;
Rectangles boundingBoxes(numCategories);
const int stride = mBBGuessSize / 8;
#ifdef PV_USE_OPENMP_THREADS
#pragma omp parallel for
#endif
for(int c = 0; c < numCategories; c++)
{
Map2 distanceMap = applyThreshold(fullMap[c], mMinBlobSize);
for(int y = 1; y < mapHeight-1; y+=stride)
{
for(int x = 1; x < mapWidth-1; x+=stride)
{
//Look at neighboring values to deduce if this is a local maximum
maxVal = distanceMap[y][x];
for(int i = -1; i <= 1; i++)
{
for(int j = -1; j <= 1; j++)
{
val = distanceMap[y+j][x+i];
maxVal = val > maxVal ? val : maxVal;
}
}
//If this was a local maximum, place a potential bounding box
if(maxVal > 0 && maxVal == distanceMap[y][x])
{
boundingBoxes[c].push_back({x, y, mBBGuessSize, mBBGuessSize});
}
}
}
}
return boundingBoxes;
}
void TransFunc1DRampEditor::thresholdChanged(float min, float max) {
//convert to integer values
int val_min = tgt::iround(min * maximumIntensity_);
int val_max = tgt::iround(max * maximumIntensity_);
//sync with spinboxes
if ((val_max != upperThresholdSpin_->value()))
upperThresholdSpin_->setValue(val_max);
if ((val_min != lowerThresholdSpin_->value()))
lowerThresholdSpin_->setValue(val_min);
//apply threshold to transfer function
applyThreshold();
}
void HSVDetector::findObjectAndServePosition() {
// If we are able to get a an image
if (image_source.getSharedMat(hsv_image)) {
addWorldReferenceFrame();
cv::cvtColor(hsv_image, hsv_image, cv::COLOR_BGR2HSV);
applyThreshold();
clarifyBlobs();
siftBlobs();
tune();
position_sink.pushObject(object_position);
}
}
void TransFuncEditorIntensityPet::restoreThresholds() {
tgt::vec2 thresh = transferFuncIntensity_->getThresholds();
resetThresholds();
// update spinboxes
int min = tgt::iround(thresh.x * (currentRange_.y - currentRange_.x) + currentRange_.x);
int max = tgt::iround(thresh.y * (currentRange_.y - currentRange_.x) + currentRange_.x);
lowerThresholdSpin_->blockSignals(true);
lowerThresholdSpin_->setValue(min);
lowerThresholdSpin_->blockSignals(false);
upperThresholdSpin_->blockSignals(true);
upperThresholdSpin_->setValue(max);
upperThresholdSpin_->blockSignals(false);
if (min + 1 < currentRange_.y) {
//increment maximum of lower spin when maximum was reached and we are below upper range
if (min == lowerThresholdSpin_->maximum())
lowerThresholdSpin_->setMaximum(min + 1);
//update minimum of upper spin
upperThresholdSpin_->blockSignals(true);
upperThresholdSpin_->setMinimum(min);
upperThresholdSpin_->blockSignals(false);
}
if (max - 1 > currentRange_.x) {
//increment minimum of upper spin when minimum was reached and we are above lower range
if (max == upperThresholdSpin_->minimum())
upperThresholdSpin_->setMinimum(max - 1);
//update maximum of lower spin
lowerThresholdSpin_->blockSignals(true);
lowerThresholdSpin_->setMaximum(max);
lowerThresholdSpin_->blockSignals(false);
}
transferFuncIntensity_->setThresholds(0.f, 1.f);
transferFuncGradient_->setThresholds(0.f, 1.f);
applyThreshold();
// update doubleSlider
doubleSlider_->blockSignals(true);
doubleSlider_->setValues(oldThreshold_.x, oldThreshold_.y);
doubleSlider_->setMinimalAllowedSliderDistance(1.f / static_cast<float>(currentRange_.y - currentRange_.x));
doubleSlider_->blockSignals(false);
}
void threshold(int input_image[N][N],
int threshold,
int output_image[N][N])
{
int c;
int r;
int aux;
for (r = 0; r < N; r++)
{
for (c = 0; c < N; c++)
{
aux = applyThreshold(input_image[r][c], threshold);
output_image[r][c] = aux;
}
}
return;
}
void TransFuncEditorIntensityPet::sliderChanged(float min, float max) {
//consider expand factor
min = min * (currentRange_.y - currentRange_.x) + currentRange_.x;
max = max * (currentRange_.y - currentRange_.x) + currentRange_.x;
//sync with spinboxes
int val = tgt::iround(max);
if ((val != upperThresholdSpin_->value()))
upperThresholdSpin_->setValue(val);
val = tgt::iround(min);
if ((val != lowerThresholdSpin_->value()))
lowerThresholdSpin_->setValue(val);
//apply threshold to both transfer functions
applyThreshold();
updateTransferFunction();
}
cv::Mat MorphoFeatures::getCorners(const cv::Mat& image)
{
cv::Mat result;
// Algorithm
// Dilate with cross
cv::dilate(image, result, cross);
// Erode with a diamond
cv::erode(result, result, diamond);
// Another result image
cv::Mat result2;
// Dilate with x
cv::dilate(image, result2, x);
// Erode with square
cv::erode(result2, result2, square);
// Corners are calculated as absdiff between result and result2
cv::absdiff(result2, result, result);
// Apply threshold
applyThreshold(result);
return result;
}
void TransFuncEditorIntensityPet::volumeChanged() {
if (volumeHandle_ && volumeHandle_->getRepresentation<Volume>()) {
int bits = volumeHandle_->getRepresentation<Volume>()->getBitsStored() / volumeHandle_->getRepresentation<Volume>()->getNumChannels();
int maxNew = static_cast<int>(pow(2.f, static_cast<float>(bits))) - 1;
if (maxNew != maximumIntensity_) {
maximumIntensity_ = maxNew;
currentRange_ = tgt::ivec2(0, maximumIntensity_);
lowerThresholdSpin_->blockSignals(true);
upperThresholdSpin_->blockSignals(true);
lowerThresholdSpin_->setRange(0, maximumIntensity_ - 1);
lowerThresholdSpin_->setValue(tgt::iround(oldThreshold_.x * maximumIntensity_));
upperThresholdSpin_->setRange(1, maximumIntensity_);
upperThresholdSpin_->setValue(tgt::iround(oldThreshold_.y * maximumIntensity_));
lowerThresholdSpin_->updateGeometry();
upperThresholdSpin_->updateGeometry();
lowerThresholdSpin_->blockSignals(false);
upperThresholdSpin_->blockSignals(false);
//set minimal distance of sliders in doubleSlider widget
doubleSlider_->setMinimalAllowedSliderDistance(1.f / static_cast<float>(maximumIntensity_));
doubleSlider_->blockSignals(true);
doubleSlider_->setValues(oldThreshold_.x, oldThreshold_.y);
doubleSlider_->blockSignals(false);
applyThreshold();
}
}
// propagate new volume to histogrampainter
histogramPainter_->setHistogram(new HistogramIntensity((volumeHandle_ ? volumeHandle_->getRepresentation<Volume>() : 0), maximumIntensity_ + 1));
// resize histogram painter
histogramPainter_->setMinimumSize(200, 150);
// clear old expand values
ranges_.clear();
}
void TransFuncEditorIntensityPet::expandGradient() {
//save old range
ranges_.push_back(currentRange_);
//new range of spinboxes
currentRange_ = tgt::ivec2(lowerThresholdSpin_->value(), upperThresholdSpin_->value());
//set minimum and maximum of thresholdspins
lowerThresholdSpin_->setMinimum(lowerThresholdSpin_->value());
lowerThresholdSpin_->setMaximum(upperThresholdSpin_->value() - 1);
upperThresholdSpin_->setMinimum(lowerThresholdSpin_->value() + 1);
upperThresholdSpin_->setMaximum(upperThresholdSpin_->value());
//reset doubleslider
doubleSlider_->blockSignals(true);
doubleSlider_->setValues(0.f, 1.f);
doubleSlider_->setMinimalAllowedSliderDistance(1.f / static_cast<float>(currentRange_.y - currentRange_.x));
doubleSlider_->blockSignals(false);
applyThreshold();
updateTransferFunction();
}
void TransFuncEditorIntensityPet::collapseGradient() {
if (ranges_.empty())
return;
//restore old range
currentRange_ = ranges_[ranges_.size() - 1];
ranges_.pop_back();
//reset minimum and maximum values of spinboxes to values before last expand
lowerThresholdSpin_->setMinimum(currentRange_.x);
lowerThresholdSpin_->setMaximum(currentRange_.y - 1);
upperThresholdSpin_->setMinimum(currentRange_.x + 1);
upperThresholdSpin_->setMaximum(currentRange_.y);
//reset double slider to range before last expand
doubleSlider_->blockSignals(true);
doubleSlider_->setMinimalAllowedSliderDistance(1.f / static_cast<float>(currentRange_.y - currentRange_.x));
doubleSlider_->setValues((lowerThresholdSpin_->value() - currentRange_.x) / static_cast<float>(currentRange_.y - currentRange_.x),
(upperThresholdSpin_->value() - currentRange_.x) / static_cast<float>(currentRange_.y - currentRange_.x));
doubleSlider_->blockSignals(false);
applyThreshold();
updateTransferFunction();
}
int main (int argc, char** argv)
{
// for storing results of argument processing
// general
bool displayInfo = true;
char* inFileName = "";
// threshold filter
bool runThreshold = false;
float threshold = THRESH_ERROR;
// crop
bool runCrop = false;
int cropWidth = CROP_DIM_ERROR;
int cropHeight = CROP_DIM_ERROR;
int cropStart[] = {0,0};
// resize
bool runResize = false;
float scaling = SCALING_ERROR;
char* resType = "";
// default output file name
char* outFileName = "out.bmp";
// process arguments, checking for errors
if (processArguments(argc, argv, &runThreshold, &runCrop, &runResize,
&displayInfo, &inFileName, &outFileName, &threshold, &cropWidth,
&cropHeight, cropStart, &scaling, &resType) != EXIT_SUCCESS)
{
fprintf(stderr, "Unable to process arguments.\n");
return EXIT_FAILURE;
}
// open the file
FILE *inFile = fopen(inFileName, "r");
// check that file opened okay
if (inFile == NULL)
{
fprintf(stderr, "Unable to open file: %s\n", inFileName);
return EXIT_FAILURE;
}
// read in the file header and check that it went okay
struct bmpFileHeader *fileHead = getFileHeader(inFile);
if (fileHead == NULL)
{
fprintf(stderr, "Unable to set up file header.\n");
return EXIT_FAILURE;
}
struct bmpInfoHeader *infoHead = getInfoHeader(inFile);
if (infoHead == NULL)
{
fprintf(stderr, "Unable to set up info header.\n");
return EXIT_FAILURE;
}
// check the format of the file
if (formatCheck(fileHead, infoHead) != EXIT_SUCCESS)
{
fprintf(stderr, "Program cannot handle this format.\n");
return EXIT_FAILURE;
}
// if we're displaying info, do so
if (displayInfo)
{
// print out header information
printInfo(fileHead, infoHead);
}
// move file pointer on to start of image, if necessary
if (fileHead->offset != (sizeof(struct bmpFileHeader) +
sizeof(struct bmpInfoHeader)))
{
fseek(inFile,
((int)fileHead->offset - (sizeof(struct bmpFileHeader) +
sizeof(struct bmpInfoHeader))), SEEK_CUR);
}
// if we're running a threshold filter, do so
if (runThreshold)
{
// apply threshold filter to image, checking for errors
if (applyThreshold(inFile, fileHead, infoHead, outFileName, threshold)
== EXIT_FAILURE)
{
fprintf(stderr, "Unable to apply threshold.\n");
return EXIT_FAILURE;
}
}
// if we're cropping the image, do so
if (runCrop)
{
// crop the image, checking for errors
if (cropImage(inFile, fileHead, infoHead, outFileName, cropWidth,
cropHeight, cropStart) == EXIT_FAILURE)
{
fprintf(stderr, "Unable to crop image.\n");
return EXIT_FAILURE;
}
}
// if we're resizing the image do so
if (runResize)
{
// resize image checking for errors
if (resizeImage(inFile, fileHead, infoHead, outFileName, scaling, resType)
== EXIT_FAILURE)
{
fprintf(stderr, "Unable to resize image.\n");
return EXIT_FAILURE;
}
}
// free up allocated memory
free(infoHead);
free(fileHead);
// close input file, checking for errors
if (fclose(inFile) != 0)
{
fprintf(stderr, "Unable to close input file.\n");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
void BBFind::detect()
{
Map3 interpMap = getInterpolatedConfs(mFramesSinceNewMap++);
int numCategories = interpMap.size();
mCurrentConfMap.resize(numCategories);
mDistMap.resize(numCategories);
// Scale maps to our internal buffer size
mCurrentConfMap = contrastAndAverage(
scale(interpMap, mInternalConfidenceWidth, mInternalConfidenceHeight, true),
mContrast,
mContrastStrength);
// Apply light thresholding to remove noise
for(int c = 0; c < numCategories; c++)
{
mCurrentConfMap[c] = applyThreshold(mCurrentConfMap[c], mThreshold / 3.0f);
}
if(mPrevInfluence > 0)
{
mCurrentConfMap = sumMaps(mCurrentConfMap, mAccumulatedConfMap, mPrevInfluence);
accumulateIntoPrev(mAccumulatedConfMap, mCurrentConfMap, mAccumulateAmount, mPrevLeakTau, -0.5f, 1.0f);
}
// Our values are all over the place right now,
// so bring them back to 0 - 1 by alternating
// a clip and squash, starting at a max of 3.5
// and gradually reaching 1.0 over 8 iterations
clipSquash(mCurrentConfMap, 8, 3.5f);
// Apply our threshold and generate our distance map,
// thresholded to the minimum blob size
for(int c = 0; c < numCategories; c++)
{
mCurrentConfMap[c] = applyThreshold(mCurrentConfMap[c], mThreshold);
mDistMap[c] = applyThreshold(
makeEdgeDistanceMap(
scale(mCurrentConfMap[c], mImageWidth, mImageHeight, true)
),
mMinBlobSize);
}
// Clip our distance map so that regions
// 2*minBlobSize pixels into an object are
// saturated
clip(mDistMap, 0.0f, mMinBlobSize * 2);
// If mDetectionWait > 0, we wait a few frames
// before generating bounding boxes. This allows us
// to use previous frames for initial detections.
if(mDetectionWaitTimer >= mDetectionWait)
{
// Detect potential boxes
mDetections = placePotentialBoxes(mDistMap);
// Join boxes that touch
joinBoundingBoxes(mDetections);
// Smooth box sizes with historical averages and join again
smoothBoundingBoxes(mDetections);
// Remove boxes that overlap by more than 75%
competeBoundingBoxes(mDetections, 0.75f);
}
else mDetectionWaitTimer++;
// Detection is finished. Use getDetections, getConfMap,
// and getDistMap to retrieve the results.
}