void ac::ReverseSubFilterBlend(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "ReverseSubFilterBlend")
return;
cv::Mat copy1 = frame.clone(), copy2 = frame.clone();
CallFilter(subfilter, copy1);
Reverse(copy2);
CallFilter(subfilter, copy2);
AlphaBlend(copy1, copy2, frame, 0.5);
}
void ac::FilterStrobeSubFilter(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "FilterStrobeSubFilter")
return;
static bool flash = true;
if(flash == true) {
CallFilter(subfilter, frame);
Negate(frame);
flash = false;
} else {
flash = true;
CallFilter(subfilter, frame);
}
AddInvert(frame);
}
void ac::FrameMedianBlendSubFilter(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "FrameMedianBlendSubFilter")
return;
cv::Mat frame_copy;
cv::flip(frame, frame_copy, 1);
CallFilter(subfilter, frame_copy);
MedianBlend(frame_copy);
int index = 0;
for(int z = 0; z < frame.rows; ++z) {
for(int i = 0; i < frame.cols; ++i) {
cv::Vec3b &pixel = frame.at<cv::Vec3b>(z, i);
cv::Vec3b pix = frame_copy.at<cv::Vec3b>(z, i);
switch(index) {
case 0:
break;
case 1:
pixel = pix;
break;
}
++index;
if(index > 1)
index = 0;
}
}
MedianBlur(frame);
RainbowXorBlend(frame);
AddInvert(frame);
}
void ac::Blend_AlphaSubFilter(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "Blend_AlphaSubFilter")
return;
cv::Mat frame_copy1 = frame.clone();
RandomBlendFilter(frame);
CallFilter(subfilter, frame_copy1);
int index = 0;
for(int z = 0; z < frame.rows; ++z) {
for(int i = 0; i < frame.cols; ++i) {
cv::Vec3b &pixel = frame.at<cv::Vec3b>(z, i);
cv::Vec3b pix = frame_copy1.at<cv::Vec3b>(z, i);
switch(index) {
case 0:
break;
case 1:
pixel = pix;
break;
}
++index;
if(index > 1)
index = 0;
}
}
AddInvert(frame);
}
void ac::BlendAlphaSubFilter(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "BlendAlphaSubFilter")
return;
cv::Mat frame_copy = frame.clone();
CallFilter(subfilter, frame_copy);
static double alpha = 1.0, alpha_max = 4.0;
int index = 0;
for(int z = 0; z < frame.rows; ++z) {
for(int i = 0; i < frame.cols; ++i) {
cv::Vec3b &pixel = frame.at<cv::Vec3b>(z, i);
cv::Vec3b pix = frame_copy.at<cv::Vec3b>(z, i);
switch(index) {
case 0:
for(int j = 0; j < 3; ++j)
pixel[j] = static_cast<unsigned char>(pixel[j]*(alpha+1)) ^ static_cast<unsigned char>(pix[j]*alpha);
break;
case 1:
pixel = pix;
break;
}
++index;
if(index > 1)
index = 0;
}
}
static int dir = 1;
procPos(dir, alpha, alpha_max, 4.1, 0.05);
AddInvert(frame);
}
void ac::ImageBlendSubFilter(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "ImageBlendSubFilter")
return;
if(blend_set == true) {
cv::Mat frame_copy1 = frame.clone();
ExactImage(frame_copy1);
CallFilter(subfilter, frame_copy1);
int index = 0;
for(int z = 0; z < frame.rows; ++z) {
for(int i = 0; i < frame.cols; ++i) {
cv::Vec3b &pixel = frame.at<cv::Vec3b>(z, i);
cv::Vec3b pix1 = frame_copy1.at<cv::Vec3b>(z, i);
switch(index) {
case 0:
break;
case 1:
pixel = pix1;
break;
}
++index;
if(index > 1)
index = 0;
}
}
}
}
void ac::ExpandSquareSubFilter(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "ExpandSquareSubFilter")
return;
static int start_x = frame.cols/2;
static int stop_x = frame.cols/2;
static int speed = frame.cols/24;
cv::Mat frame_copy = frame.clone();
cv::Mat output;
CallFilter(subfilter, frame_copy);
for(int z = 0; z < frame.rows; ++z) {
for(int i = start_x; i < stop_x; ++i) {
cv::Vec3b &pixel = frame.at<cv::Vec3b>(z, i);
pixel = frame_copy.at<cv::Vec3b>(z, i);
}
}
static int dir = 1;
if(dir == 1) {
start_x -= speed;
stop_x += speed;
if(start_x <= 0 || stop_x > frame.cols-1) {
dir = 0;
}
} else {
start_x += speed;
stop_x -= speed;
if(start_x >= (frame.cols/2)-1 || stop_x <= (frame.cols/2)-1) {
dir = 1;
}
}
AddInvert(frame);
}
//===============================================================
UserFilterPage::UserFilterPage(QWidget *parent):QWidget(parent)
{
QGroupBox *UserFilter=new QGroupBox(tr("User's Own Filter"));
FilterName=new QLabel(tr("Filter Name:"));
FilterItem=new QComboBox;
StartButton=new QPushButton(tr("Start Call Other Filter"));
QHBoxLayout *FilterLayout=new QHBoxLayout;
FilterLayout->addWidget(FilterName);
FilterLayout->addWidget(FilterItem);
QVBoxLayout *UserLayout=new QVBoxLayout;
UserLayout->addLayout(FilterLayout);
UserLayout->addSpacing(20);
UserLayout->addWidget(StartButton);
UserFilter->setLayout(UserLayout);
QVBoxLayout *mainLayout=new QVBoxLayout;
mainLayout->addWidget(UserFilter);
mainLayout->addStretch(1);
setLayout(mainLayout);
connect(StartButton,SIGNAL(clicked()),this,SLOT(CallFilter()));
}
void ac::BlendImageWithSubFilterAlpha(cv::Mat &frame) {
if(blend_set == false || subfilter == -1 || ac::draw_strings[subfilter] == "BlendImageWithSubFilter")
return;
static double alpha = 1.0, alpha_max = 4.0;
cv::Mat copy1 = frame.clone();
cv::Mat reimage;
cv::resize(blend_image, reimage, frame.size());
CallFilter(subfilter, copy1);
for(int z = 0; z < frame.rows; ++z) {
for(int i = 0; i < frame.cols; ++i) {
cv::Vec3b &pixel = frame.at<cv::Vec3b>(z, i);
cv::Vec3b pix[3];
pix[0] = pixel;
pix[1] = copy1.at<cv::Vec3b>(z, i);
pix[2] = reimage.at<cv::Vec3b>(z, i);
unsigned int values[3] = {0,0,0};
for(int q = 0; q < 3; ++q) {
for(int j = 0; j < 3; ++j) {
values[j] += pix[q][j];
}
}
for(int j = 0; j < 3; ++j) {
values[j] /= 3;
pixel[j] = static_cast<unsigned char>(pixel[j]*(alpha+1)) ^ static_cast<unsigned char>(values[j]*alpha);
}
}
}
static int dir = 1;
procPos(dir, alpha, alpha_max, 4.1, 0.01);
AddInvert(frame);
}
void ac::Random_Filter(cv::Mat &frame) {
std::string value = solo_filter[rand()%solo_filter.size()];
// uncomment below to see what filter is currently being processed
// std::cout << "Current Filter: " << value << "\n";
CallFilter(value, frame);
AddInvert(frame);
}
void ac::ImageReverseSubFilter(cv::Mat &frame) {
if(blend_set == false || subfilter == -1 || ac::draw_strings[subfilter] == "ImageReverseSubFilter")
return;
cv::Mat reimage;
cv::resize(blend_image, reimage, frame.size());
cv::Mat all_frames[3];
cv::flip(frame, all_frames[0], -1);
cv::flip(frame, all_frames[1], 0);
cv::flip(frame, all_frames[2], 1);
cv::Mat copy1 = frame.clone(), copy2 = frame.clone();
for(int z = 0; z < copy1.rows; ++z) {
for(int i = 0; i < copy1.cols; ++i){
cv::Vec3b &pixel = copy1.at<cv::Vec3b>(z, i);
cv::Vec3b pix[4];
for(int j = 0; j < 3; ++j) {
pix[j] = all_frames[j].at<cv::Vec3b>(z, i);
}
for(int j = 0; j < 3; ++j) {
pixel[j] = pix[0][j] ^ pix[1][j] ^ pix[2][j] ^ pixel[j];
}
}
}
static MatrixCollection<8> collection;
Smooth(copy1, &collection);
CallFilter(subfilter, reimage);
Xor(reimage, copy1);
AlphaBlend(reimage, copy2, frame, 0.5);
DarkenFilter(frame);
MedianBlend(frame);
}
void ac::StretchSubFilter(cv::Mat &frame) {
if(subfilter == -1 || draw_strings[subfilter] == "StretchSubFilter")
return;
static int w = 2, h = 2, speed = 5, dir = 100;
if(dir == 1) {
w += speed;
h += speed;
if(w > (frame.cols-1) || (h > frame.rows-1)) {
dir = 0;
w = frame.cols-2;
h = frame.rows-2;
}
} else {
w -= speed;
h -= speed;
if(w <= 64 || h <= 64) {
dir = 1;
w = 64;
h = 64;
}
}
cv::Mat copy1 = frame.clone(), copy2 = frame.clone(), reimage;
cv::resize(frame, copy1, cv::Size(w, h));
CallFilter(subfilter, copy1);
cv::resize(copy1, reimage, frame.size());
AlphaBlend(copy2, reimage, frame, 0.5);
AddInvert(frame);
}
void ac::BlendImageWithSubFilter(cv::Mat &frame) {
if(blend_set == false || subfilter == -1 || ac::draw_strings[subfilter] == "BlendImageWithSubFilter")
return;
cv::Mat copy1 = frame.clone();
cv::Mat reimage;
cv::resize(blend_image, reimage, frame.size());
CallFilter(subfilter, copy1);
for(int z = 0; z < frame.rows; ++z) {
for(int i = 0; i < frame.cols; ++i) {
cv::Vec3b &pixel = frame.at<cv::Vec3b>(z, i);
cv::Vec3b pix[3];
pix[0] = pixel;
pix[1] = copy1.at<cv::Vec3b>(z, i);
pix[2] = reimage.at<cv::Vec3b>(z, i);
unsigned int values[3] = {0,0,0};
for(int q = 0; q < 3; ++q) {
for(int j = 0; j < 3; ++j) {
values[j] += pix[q][j];
}
}
for(int j = 0; j < 3; ++j) {
values[j] /= 3;
pixel[j] = pixel[j] ^ values[j];
}
}
}
AddInvert(frame);
}
void ac::AndImageSubFilterXor(cv::Mat &frame) {
if(blend_set == false || subfilter == -1 || ac::draw_strings[subfilter] == "AndImageSubFilterXor")
return;
cv::Mat copy1 = frame.clone(), reimage;
cv::resize(blend_image, reimage, frame.size());
CallFilter(subfilter, copy1);
static double alpha = 1.0, alpha_max = 4.0;
for(int z = 0; z < frame.rows; ++z) {
for(int i = 0; i < frame.cols; ++i) {
cv::Vec3b &pixel = frame.at<cv::Vec3b>(z, i);
cv::Vec3b pix[2];
pix[0] = reimage.at<cv::Vec3b>(z, i);
pix[1] = copy1.at<cv::Vec3b>(z, i);
unsigned int value = 0;
for(int j = 0; j < 3; ++j) {
value = pix[0][j] & pix[1][j];
pixel[j] = pixel[j] ^ value;
}
}
}
static int dir = 1;
procPos(dir, alpha, alpha_max, 4.1, 0.01);
AddInvert(frame);
}
void ac::OrigBlendSubFilter(cv::Mat &frame) {
if(subfilter == -1 || draw_strings[subfilter] == "OrigBlendSubFilter" || orig_frame.empty() || orig_frame.size() != frame.size())
return;
cv::Mat copy1 = frame.clone(), copy2 = orig_frame.clone();
CallFilter(subfilter, copy2);
AlphaBlend(copy1, copy2, frame, 0.5);
AddInvert(frame);
}
void ac::MirrorSwitchSubFilter(cv::Mat &frame) {
if(subfilter == -1 || draw_strings[subfilter] == "MirrorSwitchSubFilter")
return;
cv::Mat copy1 = frame.clone(), copy2 = frame.clone();
MirrorSwitch(copy1);
AlphaBlend(copy1, copy2, frame, 0.5);
CallFilter(subfilter, frame);
AddInvert(frame);
}
void ac::Random_FilterSubFilter(cv::Mat &frame) {
if(subfilter == -1 || draw_strings[subfilter] == "Random_FilterSubFilter")
return;
cv::Mat copy1 = frame.clone(), copy2 = frame.clone();
Random_Filter(copy1);
CallFilter(subfilter, copy2);
AlphaBlend(copy1, copy2, frame, 0.5);
AddInvert(frame);
}
void ac::ShuffleAlphaSubFilter(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "ShuffleAlphaSubFilter")
return;
cv::Mat copyf = frame.clone(), copyi = frame.clone();
ShuffleAlpha(copyf);
CallFilter(subfilter, copyi);
AlphaBlend(copyf, copyi, frame, 0.5);
AddInvert(frame);
}
void ac::ParticleReleaseSubFilter(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "ParticleReleaseSubFilter")
return;
cv::Mat copy1 = frame.clone(), copy2 = frame.clone();
CallFilter(subfilter, copy2);
AlphaBlend(copy1, copy2, frame, 0.5);
MedianBlend(frame);
ParticleRelease(frame);
AddInvert(frame);
}
void ac::AlphaBlendImageSubFilterXorRev(cv::Mat &frame) {
if(blend_set == false || subfilter == -1 || ac::draw_strings[subfilter] == "AlphaBlendImageSubFilterXorRev")
return;
cv::Mat reimage, copy1;
cv::resize(blend_image, reimage, frame.size());
CallFilter(subfilter, reimage);
AlphaBlend(frame, reimage, copy1, 0.5);
Xor(frame, copy1);
AddInvert(frame);
}
void ac::ImageDiffSubFilter(cv::Mat &frame) {
if(blend_set == false || subfilter == -1 || draw_strings[subfilter] == "ImageDiffSubFilter")
return;
cv::Mat copy1 = frame.clone(), reimage;
cv::resize(blend_image, reimage, frame.size());
CallFilter(subfilter, copy1);
ImageDiff(copy1);
AlphaBlend(copy1, reimage, frame, 0.5);
AddInvert(frame);
}
void ac::DoubleRandomAlphaImageSubFilter(cv::Mat &frame) {
if(blend_set == false || subfilter == -1 || draw_strings[subfilter] == "DoubleRandomAlphaImageSubFilter")
return;
cv::Mat copy1 = frame.clone(), reimage;
cv::resize(blend_image, reimage, frame.size());
Random_Filter(copy1);
Random_Filter(reimage);
AlphaBlendDouble(copy1, reimage, frame, 0.3, 0.3);
CallFilter(subfilter, frame);
AddInvert(frame);
}
void ac::ParticleReleaseImageSubFilter(cv::Mat &frame) {
if(blend_set == false || subfilter == -1 || ac::draw_strings[subfilter] == "ParticleReleaseImageSubFilter")
return;
cv::Mat copy1 = frame.clone(), reimage;
cv::resize(blend_image, reimage, frame.size());
CallFilter(subfilter, reimage);
AlphaBlend(copy1, reimage, frame, 0.5);
ParticleRelease(frame);
MedianBlend(frame);
AddInvert(frame);
}
void ac::ColormapBlendSubFilter(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "ColormapBlendSubFilter")
return;
cv::Mat copyf = frame.clone(), copyi = frame.clone();
setColorMap(rand()%11, copyf);
setColorMap(rand()%11, copyi);
RGBColorTrails(copyi);
CallFilter(subfilter, copyf);
AlphaBlend(copyf, copyi, frame, 0.5);
AddInvert(frame);
}
void ac::RandomColorMapAlphaBlendSubFilter(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "RandomColorMapAlphaBlendSubFilter")
return;
cv::Mat copy1 = frame.clone(), copy2 = frame.clone();
RandomColorMap(copy1);
CallFilter(subfilter, copy1);
static double alpha = 1.0, alpha_max = 4.0;
AlphaBlend(copy1, copy2, frame, alpha);
static int dir = 1;
procPos(dir, alpha, alpha_max, 4.1, 0.005);
AddInvert(frame);
}
void ac::MirrorOrderSubFilter(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "MirrorOrderSubFilter")
return;
cv::Mat copy1 = frame.clone(), copy2 = frame.clone();
CallFilter(subfilter, copy1);
MirrorOrder(copy2);
AlphaBlend(copy1, copy2, frame, 0.5);
SmoothTrailsBlend(frame);
DarkenImage(frame, 4);
MedianBlend(frame);
AddInvert(frame);
}
void ac::ImageDistortionSubFilter(cv::Mat &frame) {
if(blend_set == false || subfilter == -1 || ac::draw_strings[subfilter] == "ImageDistortionSubFilter")
return;
cv::Mat copy1 = frame.clone();
cv::Mat copy2;
cv::resize(blend_image,copy2,frame.size());
CallFilter(subfilter, copy1);
pushSubFilter(filter_map["ExactImage"]);
SmoothImageAlphaBlend(copy2);
popSubFilter();
AlphaBlend(copy1, copy2, frame, 0.5);
AddInvert(frame);
}
void ac::StoredFramesAlphaBlend_SubFilter(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "StoredFramesAlphaBlend_SubFilter")
return;
static MatrixCollection<8> collection;
static double alpha = 1.0, alpha_max = 4.0;
cv::Mat frame_copy = frame.clone();
CallFilter(subfilter, frame_copy);
cv::Mat fcopy = frame.clone();
AlphaBlend(fcopy, frame_copy, frame, alpha);
collection.shiftFrames(frame);
Smooth(frame, &collection);
static int dir = 1;
procPos(dir, alpha, alpha_max, 4.1, 0.05);
AddInvert(frame);
}
void ac::ImageCollectionSubFilter(cv::Mat &frame) {
if(blend_set == false || subfilter == -1 || ac::draw_strings[subfilter] == "ImageBlendXorSubFilter")
return;
static double alpha = 1.0, alpha_max = 4.0;
static int dir = 1;
cv::Mat frame_copy1 = frame.clone();
cv::Mat frame_copy2 = frame.clone();
ExactImage(frame_copy1);
AlphaBlend(frame_copy1, frame_copy2, frame, alpha);
CallFilter(subfilter, frame);
static MatrixCollection<8> collection;
collection.shiftFrames(frame);
Smooth(frame, &collection);
procPos(dir, alpha, alpha_max, 4.1, 0.05);
AddInvert(frame);
}
void ac::FrameBlurSubFilter(cv::Mat &frame) {
if(subfilter == -1 || ac::draw_strings[subfilter] == "FrameBlurSubFilter")
return;
static double alpha = 1.0, alpha_max = 4.0;
cv::Mat frame_copy1 = frame.clone();
cv::Mat frame_copy2 = frame.clone();
MedianBlur(frame_copy1);
CallFilter(subfilter, frame_copy1);
MedianBlur(frame_copy1);
MedianBlur(frame_copy2);
AlphaBlend(frame_copy1, frame_copy2, frame, alpha);
MedianBlur(frame);
static int dir = 1;
procPos(dir, alpha, alpha_max, 4.1, 0.05);
AddInvert(frame);
}
