/*
Differences between OpenGL and XRender:
- differently specified rectangles (X: width/height, O: x2,y2)
- XRender uses pre-multiplied alpha
*/
void ShowFpsEffect::paintXrender(int fps)
{
xcb_pixmap_t pixmap = xcb_generate_id(xcbConnection());
xcb_create_pixmap(xcbConnection(), 32, pixmap, x11RootWindow(), FPS_WIDTH, MAX_TIME);
XRenderPicture p(pixmap, 32);
xcb_free_pixmap(xcbConnection(), pixmap);
xcb_render_color_t col;
col.alpha = int(alpha * 0xffff);
col.red = int(alpha * 0xffff); // white
col.green = int(alpha * 0xffff);
col.blue = int(alpha * 0xffff);
xcb_rectangle_t rect = {0, 0, FPS_WIDTH, MAX_TIME};
xcb_render_fill_rectangles(xcbConnection(), XCB_RENDER_PICT_OP_SRC, p, col, 1, &rect);
col.red = 0; // blue
col.green = 0;
col.blue = int(alpha * 0xffff);
rect.y = MAX_TIME - fps;
rect.width = FPS_WIDTH;
rect.height = fps;
xcb_render_fill_rectangles(xcbConnection(), XCB_RENDER_PICT_OP_SRC, p, col, 1, &rect);
col.red = 0; // black
col.green = 0;
col.blue = 0;
QVector<xcb_rectangle_t> rects;
for (int i = 10;
i < MAX_TIME;
i += 10) {
xcb_rectangle_t rect = {0, int16_t(MAX_TIME - i), uint16_t(FPS_WIDTH), 1};
rects << rect;
}
xcb_render_fill_rectangles(xcbConnection(), XCB_RENDER_PICT_OP_SRC, p, col, rects.count(), rects.constData());
xcb_render_composite(xcbConnection(), alpha != 1.0 ? XCB_RENDER_PICT_OP_OVER : XCB_RENDER_PICT_OP_SRC, p, XCB_RENDER_PICTURE_NONE,
effects->xrenderBufferPicture(), 0, 0, 0, 0, x, y, FPS_WIDTH, MAX_TIME);
// Paint FPS graph
paintFPSGraph(x + FPS_WIDTH, y);
// Paint amount of rendered pixels graph
paintDrawSizeGraph(x + FPS_WIDTH + MAX_TIME, y);
// Paint FPS numerical value
if (fpsTextRect.isValid()) {
QImage textImg(fpsTextImage(fps));
XRenderPicture textPic(textImg);
xcb_render_composite(xcbConnection(), XCB_RENDER_PICT_OP_OVER, textPic, XCB_RENDER_PICTURE_NONE,
effects->xrenderBufferPicture(), 0, 0, 0, 0, fpsTextRect.x(), fpsTextRect.y(), textImg.width(), textImg.height());
effects->addRepaint(fpsTextRect);
}
}
int readActFile(char* file, meme** memes, int memeCount)
{
char* out;
int memeNum, fontNum, textNum;
char* top;
char* bot;
image** textLines;
image* m;
char* buffer = (char*)malloc(128 * sizeof(char));
char* buffer2;
int i, x, y;
int length, size;
int charPos;
char c;
FILE* in = fopen(file, "r");
textLines = (image**)malloc(sizeof(image*));
textNum = 0;
memeNum = 0;
fontNum = 0;
if(in == 0)
{
printf("Couldn't open file at %s\n", file);
return 1;
}
c = getc(in);
while(c != EOF)
{
i = 0;
while(c != '\n' && c != EOF)
{
buffer[i] = c;
i++;
c = getc(in);
}
buffer[i] = 0;
if(c == '\n')
{
c = getc(in);
}
if(strlen(buffer) == 0)
{
continue;
}
i = 0;
while(buffer[i] != 0)
{
if(buffer[i] == ':')
{
buffer[i] = 0;
}
i++;
}
charPos = 0;
buffer2 = &(buffer[charPos]);
if(strcmp(buffer2, "OUTFILE") == 0)
{
length = strlen(buffer2);
charPos += length + 1;
buffer2 = &(buffer[charPos]);
out = (char*)malloc(strlen(buffer2) * sizeof(char));
strcpy(out, buffer2);
}
else if(strcmp(buffer2, "MEME") == 0)
{
length = strlen(buffer2);
charPos += length + 1;
buffer2 = &(buffer[charPos]);
for(memeNum; memeNum <= memeCount; memeNum++)
{
if(memeNum == memeCount) /* THIS ALSO DOESNT WORK */
{
printf("Couldn't find meme: %s\n", buffer2);
return 1;
}
if(strcmp(memes[memeNum]->name, buffer2) == 0)
{
m = open(memes[memeNum]->file);
break;
}
}
}
else if(strcmp(buffer2, "FONT") == 0)
{
length = strlen(buffer2);
charPos += length + 1;
buffer2 = &(buffer[charPos]);
for(fontNum; fontNum <= memes[memeNum]->fontCount; fontNum++)
{
if(fontNum == memes[memeNum]->fontCount)
{
printf("Couldn't find font: %s\n", buffer2);
return 1;
}
if(strcmp(memes[memeNum]->fonts[fontNum]->name, buffer2) == 0)
{
break;
}
}
}
else
{
size = memes[memeNum]->locCount;
for(i = 0; i <= size; i++)
{
if(i == size)
{
printf("%s is not a valid command\n", buffer2);
return 1;
}
if(strcmp(memes[memeNum]->loc[i]->name, buffer2) == 0)
{
length = strlen(buffer2);
charPos += length + 1;
buffer2 = &(buffer[charPos]);
textLines = realloc(textLines, sizeof(textLines) + sizeof(image*));
/* make new image with textImg() */
textLines[textNum] = (image*)malloc(sizeof(image));
textLines[textNum] = textImg(buffer2, memes[memeNum]->fonts[fontNum]);
if(textLines[textNum] == 0)
{
return 1;
}
x = memes[memeNum]->loc[i]->x - (textLines[textNum]->width / 2);
y = memes[memeNum]->loc[i]->y - (textLines[textNum]->height);
m = overlay(m, textLines[textNum], x, y);
break;
}
}
}
}
/* Overlay all of the textLines to the image file, out
* find the position by x - (textLines->width / 2) and
* y - (textLines->height / 2) (probably) */
save(m, out);
/* free(out);
freeImg(m);
free(buffer);
free(buffer2);
free(in);
for(i = 0; i < textNum; i++)
{
freeImg(textLines[i]);
}
free(textLines);
*/
return 0;
}
int main(int argc, char** argv)
{
int height ,width ,step ,channels;
int same, lighter;
float thresh;
uchar *dataB, *dataG, *dataR, *dataGray, *dataD;
uchar b1, g1, r1, b2, g2, r2;
int w = 3;
int th = 50;
int idx1, idx2;
cv::Mat img = cv::imread(argv[1]);
height = img.rows;
width = img.cols;
cv::namedWindow("Image0", cv::WINDOW_NORMAL);
cv::Mat textImg(1000, 1200, CV_8UC1, cv::Scalar(255));
cv::putText(textImg, "Original Image:", cv::Point(400, 500), cv::FONT_HERSHEY_SIMPLEX, 2, cv::Scalar(0, 0, 0));
//cv::imshow("Image0", textImg);
//cv::waitKey();
//cv::imshow("Image0", img);
//cv::waitKey();
textImg.setTo(cv::Scalar(255, 255, 255));
cv::putText(textImg, "Next: Apply SUSAN algorithm to detect edge and cross.", cv::Point(200, 500), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
cv::putText(textImg, "Press any key to continue...", cv::Point(400, 600), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
//cv::imshow("Image0", textImg);
//cv::waitKey();
std::vector<cv::Mat> imgChannels;
cv::split(img, imgChannels);
cv::Mat dstSusan(height, width, CV_8UC1, cv::Scalar(0));
cv::Mat grayImg(height, width, CV_8UC1, cv::Scalar(0));
step = imgChannels[0].step[0];
dataB = imgChannels[0].data;
dataG = imgChannels[1].data;
dataR = imgChannels[2].data;
dataGray = grayImg.data;
dataD= dstSusan.data;
for (int x = w; x < width-w; x++)
{
for (int y = w; y < height-w; y++)
{
same = 0;
idx1 = x + y * step;
b1 = dataB[idx1];
g1 = dataG[idx1];
r1 = dataR[idx1];
for (int u = 0; u < w+1; u++)
{
for (int v = 0; v < w+1; v++)
{
if (u + v == 0)
{
continue;
}
idx2 = (x+u) + (y+v) * step;
b2 = dataB[idx2];
g2 = dataG[idx2];
r2 = dataR[idx2];
if (calc_dist(b1, g1, r1, b1, g2, r2) < th)
{
same += 1;
}
idx2 = (x-u) + (y+v) * step;
b2 = dataB[idx2];
g2 = dataG[idx2];
r2 = dataR[idx2];
if (u != 0 && calc_dist(b1, g1, r1, b1, g2, r2) < th)
{
same += 1;
}
idx2 = (x+u) + (y-v) * step;
b2 = dataB[idx2];
g2 = dataG[idx2];
r2 = dataR[idx2];
if (v != 0 && calc_dist(b1, g1, r1, b1, g2, r2) < th)
{
same += 1;
}
idx2 = (x-u) + (y-v) * step;
b2 = dataB[idx2];
g2 = dataG[idx2];
r2 = dataR[idx2];
if (u != 0 && v != 0 && calc_dist(b1, g1, r1, b1, g2, r2) < th)
{
same += 1;
}
}
}
dataD[idx1] = uchar(255.0 * float(same) / ((2*w+1) * (2*w+1) - 1));
if (dataD[idx1] < 128)
{
dataD[idx1] = 255;
}
else
{
dataD[idx1] = 0;
}
}
}
//cv::imshow("Image0", dstSusan);
cv::imwrite("outimg_1.jpg", dstSusan);
textImg.setTo(cv::Scalar(255, 255, 255));
cv::putText(textImg, "Next: Apply Hough algorithm to detect lines.", cv::Point(300, 500), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
cv::putText(textImg, "Press any key to continue...", cv::Point(400, 600), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
//cv::waitKey();
//cv::imshow("Image0", textImg);
//cv::waitKey();
//Hough line detection
std::vector<cv::Vec4i> lines;
HoughLinesP(dstSusan, lines, 1, CV_PI/180, 80, 500, 20);
double thetaSum = 0.0;
int thetaNum = 0;
double theta;
for(size_t i = 0; i < lines.size(); i++)
{
cv::Vec4i l = lines[i];
cv::line(img, cv::Point(l[0], l[1]), cv::Point(l[2], l[3]), cv::Scalar(186,88,255), 1, CV_AA);
if (l[0] == l[2])
{
theta = CV_PI / 2;
}
else
{
theta = std::atan(-double(l[3]-l[1]) / (l[2] - l[0]));
}
if (theta >= -CV_PI / 4 && theta <= CV_PI / 4)
{
thetaSum += theta;
thetaNum += 1;
}
}
theta = -thetaSum / thetaNum * 180 / CV_PI;
//cv::imshow("Image0", img);
cv::imwrite("outimg_2.jpg", img);
//cv::waitKey();
textImg.setTo(cv::Scalar(255, 255, 255));
std::ostringstream textStr;
textStr << "Find " << lines.size() << " lines.";
cv::putText(textImg, textStr.str(), cv::Point(500, 400), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
textStr.str(std::string());
textStr.clear();
textStr << "Rotating angle is " << theta << " degree.";
cv::putText(textImg, textStr.str(), cv::Point(350, 500), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
cv::putText(textImg, "Next: Rotating the image.", cv::Point(400, 600), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
cv::putText(textImg, "Press any key to continue...", cv::Point(400, 700), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
//cv::imshow("Image0", textImg);
//cv::waitKey();
img.release();
img = cv::imread(argv[1]);
imgChannels[0].release();
imgChannels[1].release();
imgChannels[2].release();
imgChannels.clear();
cv::Mat rotateImg(height, width, CV_8UC3);
cv::Point2f center;
center.x = float(width / 2.0 + 0.5);
center.y = float(height / 2.0 + 0.5);
cv::Mat affineMat = getRotationMatrix2D(center, theta, 1);
cv::warpAffine(img,rotateImg, affineMat, cv::Size(width, height), CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS);
//cv::imshow("Image0", rotateImg);
cv::imwrite("outimg_3.jpg", rotateImg);
//cv::waitKey();
textImg.setTo(cv::Scalar(255, 255, 255));
cv::putText(textImg, "Next: Transform the image to gray scale.", cv::Point(300, 500), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
cv::putText(textImg, "Press any key to continue...", cv::Point(400, 600), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
//cv::imshow("Image0", textImg);
//cv::waitKey();
cv::split(rotateImg, imgChannels);
dataB = imgChannels[0].data;
dataG = imgChannels[1].data;
dataR = imgChannels[2].data;
step = imgChannels[0].step[0];
//imgChannels[2].setTo(cv::Scalar(0));
for (int x = 0; x < rotateImg.cols; x++)
{
for (int y = 0; y < rotateImg.rows; y++)
{
int idx = x + y * step;
if (dataB[idx] < dataG[idx] && dataB[idx] < dataR[idx])
{
dataG[idx] = dataB[idx];
dataR[idx] = dataB[idx];
}
if (dataG[idx] < dataB[idx] && dataG[idx] < dataR[idx])
{
dataB[idx] = dataG[idx];
dataR[idx] = dataG[idx];
}
if (dataR[idx] < dataB[idx] && dataR[idx] < dataG[idx])
{
dataB[idx] = dataR[idx];
dataG[idx] = dataR[idx];
}
}
}
cv::Mat filterRedImg(rotateImg.rows, rotateImg.cols, CV_8UC3, cv::Scalar::all(255));
cv::merge(imgChannels, filterRedImg);
cv::cvtColor(filterRedImg, grayImg, CV_BGR2GRAY);
//cv::imshow("Image0", grayImg);
cv::imwrite("outimg_4.jpg", grayImg);
//cv::waitKey();
textImg.setTo(cv::Scalar(255, 255, 255));
cv::putText(textImg, "Next: Clean the noise.", cv::Point(450, 500), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
cv::putText(textImg, "Press any key to continue...", cv::Point(400, 600), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
//cv::imshow("Image0", textImg);
//cv::waitKey();
step = grayImg.step[0];
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
int idx = x + y * step;
if (grayImg.data[idx] > 100)
//if(!is_gray(dataB[idx], dataG[idx], dataR[idx]))
{
grayImg.data[idx] = 255;
}
}
}
//cv::imshow("Image0", grayImg);
cv::imwrite("outimg_5.jpg", grayImg);
//cv::waitKey();
textImg.setTo(cv::Scalar(255, 255, 255));
cv::putText(textImg, "Next: Digitizing the curves.", cv::Point(400, 500), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
cv::putText(textImg, "Press any key to continue...", cv::Point(400, 600), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
//cv::imshow("Image0", textImg);
//cv::waitKey();
cv::Mat newImg(height, width, CV_8UC3, cv::Scalar::all(255));
SegmentFactory segFactory = SegmentFactory(0);
std::vector<Segment *> segments;
segFactory.makeSegments(grayImg, segments);
std::vector<Segment *>::iterator itr;
for (itr = segments.begin(); itr != segments.end(); itr++)
{
Segment *seg = *itr;
std::vector<SegmentLine *>::iterator itr_l;
for (itr_l = seg->m_lines.begin(); itr_l != seg->m_lines.end(); itr_l++)
{
SegmentLine *line = *itr_l;
cv::line(newImg, cv::Point(line->m_x1, line->m_y1), cv::Point(line->m_x2, line->m_y2), cv::Scalar(186,88,255), 1, CV_AA);
std::cout << line->m_x1 << ", " << line->m_y1 << ", " << line->m_x2 << ", " << line->m_y2 << std::endl;
}
}
//cv::imshow("Image0", newImg);
cv::imwrite("outimg_6.jpg", newImg);
//cv::waitKey();
textImg.setTo(cv::Scalar(255, 255, 255));
cv::putText(textImg, "Done.", cv::Point(550, 500), cv::FONT_HERSHEY_SIMPLEX, 1, cv::Scalar(0, 255, 255));
//cv::imshow("Image0", textImg);
//cv::waitKey();
return 0;
}
