void test_makeHistogram()
{
int i;
int histogram[26] = { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0};
int *newHistogram;
if ((((makeHistogram("Cat"))) != ((void *)0))) {} else {UnityFail( (" Expected Non-NULL"), (_U_UINT)(_U_UINT)(_U_UINT)19);;};
newHistogram = makeHistogram("cat");
for (i = 0; i < 26; i++) {
UnityAssertEqualNumber((_U_SINT)((histogram[i])), (_U_SINT)((newHistogram[i])), (((void *)0)), (_U_UINT)24, UNITY_DISPLAY_STYLE_INT);
}
}
void test_makeHistogram()
{
int i;
int histogram[26] = { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0};
int *newHistogram;
TEST_ASSERT_NOT_NULL(makeHistogram("Cat"));
newHistogram = makeHistogram("cat");
for (i = 0; i < 26; i++) {
TEST_ASSERT_EQUAL_INT(histogram[i], newHistogram[i]);
}
}
int main(int argc, char **argv)
{
gchar *file_contents = openFile("huckfinn.txt");
gchar **split_file = split(file_contents);
GHashTable *map = makeHistogram(split_file);
GList *sorted = sortWords(map);
printSortedMap(sorted,map);
return 0;
}
void MainWindow::applyFilter(int i)
{
if(!activeMdiChild()) return;
CvGlWidget *actCV = activeMdiChild();
if(actCV->cvImage.data == NULL) return;
k2D.filter(actCV->cvImage, i);
actCV->showImage(actCV->cvImage);
makeHistogram();
}
void MainWindow::on_actionBlack_Hat_triggered()
{
if(!activeMdiChild()) return;
CvGlWidget *actCV = activeMdiChild();
morpher->setElemNSize(morphUI->elementType, morphUI->kernelSize, morphUI->iteration);
morpher->Morph( actCV->cvImage, 6);
actCV->showImage(actCV->cvImage);
actCV->setWindowTitle("dilate - ");
actCV->buildHistogram();
makeHistogram();
}
void MainWindow::addImage()
{
if(!activeMdiChild()) return;
CvGlWidget *actCV = activeMdiChild();
double alpha = 0.75;
double beta = ( 1.0 - alpha );
addWeighted( actCV->cvImage, alpha, actCV->inputImage, beta, 0.0, actCV->cvImage);
actCV->showImage(actCV->cvImage);
actCV->setWindowTitle("Blended");
actCV->buildHistogram();
makeHistogram();
}
void MainWindow::on_actionEqualize_triggered()
{
if(!activeMdiChild()) return;
CvGlWidget *actCV = activeMdiChild();
if(actCV->cvImage.channels() == 1){
equalizeHist(actCV->cvImage, actCV->cvImage);
actCV->showImage(actCV->cvImage);
actCV->buildHistogram();
makeHistogram();
}
}
void MainWindow::on_actionMake_Border_triggered()
{
if(!activeMdiChild()) return;
CvGlWidget *actCV = activeMdiChild();
cv::Mat paddedImage;
int top = 20, bottom = 20, left = 20, right = 20;
int borderType = BORDER_CONSTANT; //BORDER_REPLICATE BORDER_REFLECT101
copyMakeBorder(actCV->cvImage, paddedImage, top, bottom, left, right, borderType, Scalar(0));
actCV->showImage(paddedImage);
actCV->setWindowTitle("Padded Image");
actCV->buildHistogram();
makeHistogram();
}
void MainWindow::on_actionBinary_triggered()
{
if(!activeMdiChild()) return;
CvGlWidget *actCV = activeMdiChild();
if(actCV->cvImage.data == NULL) return;
if(actCV->cvImage.channels() == 1) return;
cv::Mat image;
cv::cvtColor(actCV->inputImage, image, CV_BGR2HSV_FULL);
actCV->showImage(image);
actCV->buildHistogram();
makeHistogram();
}
void rgb_stretch(QImage &img, const QRect &rect)
{
int rmin, rmax;
int gmin, gmax;
int bmin, bmax;
makeHistogram(img, rect, getRed, 256, &rmin, &rmax);
makeHistogram(img, rect, getGreen, 256, &gmin, &gmax);
makeHistogram(img, rect, getBlue, 256, &bmin, &bmax);
RGBV lo(rmin/255.0, gmin/255.0, bmin/255.0);
RGBV stretch(rmax==rmin? 1.0 : 255.0/(rmax-rmin),
gmax==gmin? 1.0 : 255.0/(gmax-gmin),
bmax==bmin? 1.0 : 255.0/(bmax-bmin));
for (int y=rect.top(); y<=rect.bottom(); y++)
for (int x=rect.left(); x<=rect.right(); x++)
{
RGBV c(img.pixel(x, y));
c.addk(lo, -1);
c.mulv(stretch);
c.clamp();
img.setPixel(x, y, c.toQRgb());
}
}
void HistogramFilter::generateHistogram()
{
if(!m_frame)
return;
QImage image = frameImage();
QImage histo = makeHistogram(image);
VideoFrame *frame = new VideoFrame(histo,m_frame->holdTime());
if(m_includeOriginalImage)
frame->setCaptureTime(m_frame->captureTime());
enqueue(frame);
}
void MainWindow::on_actionOriginal_triggered()
{
if(!activeMdiChild()) return;
CvGlWidget *actCV = activeMdiChild();
cv::Mat image;
actCV->inputImage.copyTo(image);
QString fname = actCV->windowTitle();
CvGlWidget *originalWindow = new CvGlWidget(this);
ui->mdiArea->addSubWindow(originalWindow);
originalWindow->setWindowTitle("original - " +fname );
image.copyTo(originalWindow->inputImage);
originalWindow->showImage(image);
originalWindow->buildHistogram();
originalWindow->show();
makeHistogram();
}
void MainWindow::on_actionGray_triggered()
{
if(!activeMdiChild()) return;
CvGlWidget *actCV = activeMdiChild();
if(actCV->cvImage.data == NULL) return;
// if(actCV->cvImage.channels() == 1) return;
cv::Mat image;
cv::cvtColor(actCV->inputImage, image, CV_BGR2GRAY);
actCV->showImage(image);
actCV->buildHistogram();
makeHistogram();
//cv::imshow("asdf", gray);
}
void luma_stretch(QImage &img, const QRect &rect)
{
int qmin, qmax;
makeHistogram(img, rect, getLuma, 256, &qmin, &qmax);
double ymin = qmin/255.0;
double k = qmax==qmin? 1.0 : 255.0/(qmax-qmin);
for (int y=rect.top(); y<=rect.bottom(); y++)
for (int x=rect.left(); x<=rect.right(); x++)
{
RGBV c(img.pixel(x, y));
double yval = getLuma(img.pixel(x, y)); // Current luminance
double ytgt = (yval - ymin)*k; // Target luminance
c.mul(ytgt/yval);
c.clamp();
img.setPixel(x, y, c.toQRgb());
}
}
void MainWindow::on_actionOpen_triggered()
{
cvWindow = new CvGlWidget(this);
ui->mdiArea->addSubWindow(cvWindow);
cv::Mat image;
QString filename = QFileDialog::getOpenFileName(this,
tr("Open Image file"), "..//vrml", tr("JPG image (*.jpg);;Portable Network Graphics(*.png)"));
image = cv::imread(filename.toStdString());
if(!image.data) return;
cvWindow->setWindowTitle(filename + " -original");
image.copyTo(cvWindow->inputImage);
cvWindow->showImage(image);
cvWindow->buildHistogram();
cvWindow->show();
makeHistogram();
}
void MainWindow::on_actionLocal_threshold_triggered()
{
if(!activeMdiChild()) return;
CvGlWidget *actCV = activeMdiChild();
cv::Mat paddedImage;
int kSize = threshUI->kernelSize;
int UIT = threshUI->localThresh;
int top = kSize, bottom = kSize, left = kSize, right = kSize;
int borderType = threshUI->borderType; //BORDER_REPLICATE BORDER_REFLECT101
copyMakeBorder(actCV->cvImage, paddedImage, top, bottom, left, right, borderType, Scalar(0));
int r = actCV->cvImage.rows; int c = actCV->cvImage.cols;
// paddedImage.convertTo(paddedImage, CV_64FC1);
// actCV->cvImage.convertTo(actCV->cvImage, CV_64FC1);
cv::Mat t_im = Mat::zeros(r, c, CV_8UC1);
cv::Mat sum;
integral(actCV->cvImage, sum, CV_64FC1);
for(int i = 0; i < r; i++){
for(int j = 0; j < c; j++){
float sum = 0;
// int it = 0;
//run the kernel now
for(int u = -(kSize - 1)/2; u <= (kSize - 1)/2; u++)
for(int v = -(kSize - 1)/2; v <=(kSize -1)/2; v++){
sum += (float)paddedImage.at<uchar>(i +kSize+ u,j +kSize+ v);
}
//threshold here; 7 is ok
float t = (float)sum/(kSize*kSize) - 7;
if((float)actCV->cvImage.at<uchar>(i, j) > t) t_im.at<uchar>(i, j) = 255;
else t_im.at<uchar>(i, j) = 0;
}
}
actCV->showImage(t_im);
actCV->buildHistogram();
makeHistogram();
}
void MainWindow::subwindowChanged(QMdiSubWindow *currentSubWindow)
{
CvGlWidget *actCV = qobject_cast<CvGlWidget *>(currentSubWindow);
makeHistogram();
}
float DAM(float *data, int length, int resolution)
{
float max, min;
unsigned int *quant = Quantization(data, length, resolution, &max, &min);
unsigned int *hist = makeHistogram(quant, length, resolution);
// Discriminant Analysis
int t, i;
float sep_max = 0.0f;
float sep;
unsigned int num[2];
float avr[2];
float var[2];
int threshold = 1;
for (t = 1; t < resolution - 1; t++) {
// Init
num[0] = 0;
num[1] = 0;
avr[0] = 0.0;
avr[1] = 0.0;
var[0] = 0.0;
var[1] = 0.0;
// Get Num and Average
for (i = 0; i < resolution; i++) {
if (i < t) {
num[0] += hist[i];
avr[0] += (float)(hist[i] * i);
} else {
num[1] += *(hist + i);
avr[1] += (float)(*(hist + i) * i);
}
}
if (num[0] != 0 && num[1] != 0) {
avr[0] = avr[0] / num[0];
avr[1] = avr[1] / num[1];
} else {
num[0] = 1;
num[1] = 1;
continue;
}
// Get Variance
for (i = 0; i < resolution; i++) {
if (i < t) {
var[0] += ((float)i - avr[0]) * ((float)i - avr[0]) * (hist[i]) / num[0];
} else {
var[1] += ((float)i - avr[1]) * ((float)i - avr[1]) * (hist[i]) / num[1];
}
}
// Calc Separation
sep = (float)num[0] * num[1] * (avr[0] - avr[1]) * (avr[0] - avr[1])
/ ((num[0] + num[1]) * (num[0] * var[0] + num[1] * var[1]));
if (sep > sep_max) {
sep_max = sep;
threshold = t;
}
}
free(quant);
free(hist);
return (float)threshold / (float)resolution * (max - min) + min;
// return 30.0f;
}
