/*------------------------------------------------------------------*
* MODIFICATIONS *
* Date Description Author *
* =========== ================================== =============== *
* *
*------------------------------------------------------------------*/
void ZUtils::MaskWidget(QWidget* pWidget, const QString& pImage)
{
QPixmap vPix;
QBitmap vBitmap;
QImage vImg(QImage::fromMimeSource(pImage));
vPix.convertFromImage(vImg);
if (!vPix.mask())
{
if (vImg.hasAlphaBuffer())
{
vBitmap = vImg.createAlphaMask();
vPix.setMask(vBitmap);
}
else
{
vBitmap = vImg.createHeuristicMask();
vPix.setMask(vBitmap);
}
}
if (vPix.mask())
pWidget->setMask(*vPix.mask());
}
/*------------------------------------------------------------------*
* MODIFICATIONS *
* Date Description Author *
* =========== ================================== =============== *
* *
*------------------------------------------------------------------*/
void ZPushButton::MaskButton(const QPixmap *pPix)
{
QPixmap vPix;
QBitmap vBitMask;
QImage vImg(pPix->convertToImage());
vPix = *pPix;
if (!vPix.mask())
{
if (vImg.hasAlphaBuffer())
{
vBitMask = vImg.createAlphaMask();
vPix.setMask(vBitMask);
}
else
{
vBitMask = vImg.createHeuristicMask();
vPix.setMask(vBitMask);
}
}
if (vPix.mask())
setMask(*vPix.mask());
}
PVideoFrame Waifu2xVideoFilter::GetFrame(int n, IScriptEnvironment* env) {
int percent = (int)((n / (double)vi.num_frames) * 100);
outputDebug([&](std::ostringstream& s) {
s << "Waifu2x GetFrame Starting: " << n << "/" << vi.num_frames << "(" << percent << "%)";
});
PVideoFrame src = child->GetFrame(n, env);
// Assume YV12, YV16 or YV24 (with chroma, planar)
// Process Y at first.
cv::Mat yImg(src->GetHeight(PLANAR_Y), src->GetRowSize(PLANAR_Y), CV_8U, (void *)src->GetReadPtr(PLANAR_Y), src->GetPitch(PLANAR_Y));
yImg.convertTo(yImg, CV_32F, 1.0 / 255.0);
if (this->nrLevel > 0) {
OutputDebugStringA("Waifu2x NR Start.");
if (!filterWithModels(this->modelsNR, yImg, yImg)) {
env->ThrowError("Waifu2x NR Failed.");
return src;
}
OutputDebugStringA("Waifu2x NR Finished.");
}
if (this->enableScaling) {
OutputDebugStringA("Waifu2x Scaling Start.");
int curRowSize = src->GetRowSize(PLANAR_Y);
int curHeight = src->GetHeight(PLANAR_Y);
for (int i = 0; i < iterTimesTwiceScaling; i++) {
curRowSize *= 2;
curHeight *= 2;
cv::resize(yImg, yImg, cv::Size(curRowSize, curHeight), 0, 0, cv::INTER_NEAREST);
if (!filterWithModels(this->modelsScale, yImg, yImg)) {
env->ThrowError("Waifu2x filtering failed.");
return src;
}
}
OutputDebugStringA("Waifu2x Scaling Finished.");
}
yImg.convertTo(yImg, CV_8U, 255.0);
// Finally process U, V
cv::Mat uImg(src->GetHeight(PLANAR_U), src->GetRowSize(PLANAR_U), CV_8U, (void *)src->GetReadPtr(PLANAR_U), src->GetPitch(PLANAR_U));
cv::Mat vImg(src->GetHeight(PLANAR_V), src->GetRowSize(PLANAR_V), CV_8U, (void *)src->GetReadPtr(PLANAR_V), src->GetPitch(PLANAR_V));
if (this->enableScaling) {
// process U and V at first (just INTER_CUBIC resize).
cv::resize(uImg, uImg, cv::Size(uImg.cols * this->scaleRatioAdjusted, uImg.rows * this->scaleRatioAdjusted), 0, 0, cv::INTER_CUBIC);
cv::resize(vImg, vImg, cv::Size(vImg.cols * this->scaleRatioAdjusted, vImg.rows * this->scaleRatioAdjusted), 0, 0, cv::INTER_CUBIC);
}
auto dst = env->NewVideoFrame(vi);
env->BitBlt(dst->GetWritePtr(PLANAR_Y), dst->GetPitch(PLANAR_Y),
yImg.data, yImg.step, yImg.cols, yImg.rows);
env->BitBlt(dst->GetWritePtr(PLANAR_U), dst->GetPitch(PLANAR_U),
uImg.data, uImg.step, uImg.cols, uImg.rows);
env->BitBlt(dst->GetWritePtr(PLANAR_V), dst->GetPitch(PLANAR_V),
vImg.data, vImg.step, vImg.cols, vImg.rows);
OutputDebugStringA("Waifu2x GetFrame Finished.");
return dst;
}