void TextureResourceLoader::divideBackgroundGraphs(const Image& baseImage)
{
const auto bkSize = Vec2(321.0f, 241.0f);
this->bkFrontSun = Texture(clipImage(baseImage, RectF(Vec2( 334.0, 10.0), bkSize), tsTransColor));
this->bkSun = Texture(clipImage(baseImage, RectF(Vec2(1630.0, 10.0), Vec2(97.0, 97.0)), tsTransColor));
this->bkBehindSun = Texture(clipImage(baseImage, RectF(Vec2( 658.0, 10.0), bkSize), tsTransColor));
this->bkBuildings.emplace_back(clipImage(baseImage, RectF(Vec2( 982.0, 10.0), bkSize), tsTransColor));
this->bkBuildings.emplace_back(clipImage(baseImage, RectF(Vec2(1306.0, 10.0), bkSize), tsTransColor));
}
void TextureResourceLoader::divideMapchipGraphs(const Image& baseImage)
{
const auto mcSize = Vec2(17.0, 17.0);
this->mcTop = Texture(clipImage(baseImage, RectF(Vec2(5.0, 5.0), mcSize), tsTransColor));
this->mcRoad = Texture(clipImage(baseImage, RectF(Vec2(5.0 + 20.0, 5.0), mcSize), tsTransColor));
this->mcGrass = Texture(clipImage(baseImage, RectF(Vec2(5.0 + 40.0, 5.0), mcSize), tsTransColor));
this->mcGrassUnder = Texture(clipImage(baseImage, RectF(Vec2(5.0 + 60.0, 5.0), mcSize), tsTransColor));
this->mcUnder = Texture(clipImage(baseImage, RectF(Vec2(5.0 + 80.0, 5.0), mcSize), tsTransColor));
}
void
GradientsHdrCompression::hdrCompression(realType_t maxGradient_p, realType_t minGradient_p, realType_t expGradient_p,
bool bRescale01_p, imageType_t &rResultImage_p) const
{
TimeMessage startHdrCompression("Gradient Domain HDR Compression");
imageType_t li;
{
TimeMessage startClipValue("Determine clip values for gradients");
imageType_t dx(m_imageDx);
imageType_t dy(m_imageDy);
// now clip values
realType_t minGradientX,maxGradientX;
minMaxValImage(dx,minGradientX,maxGradientX);
realType_t minGradientY,maxGradientY;
minMaxValImage(dy,minGradientY,maxGradientY);
realType_t minValue=Min(minGradientX, minGradientY);
realType_t maxValue=Max(maxGradientX, maxGradientY);
double rangeValue=Max(-minValue, maxValue);
realType_t const clipRange=rangeValue*maxGradient_p;
realType_t const zeroRange=rangeValue*minGradient_p;
startClipValue.Stop();
TimeMessage startClip("Clipping Gradients");
clipImage(dx,-clipRange,clipRange);
zeroRangeImage(dx,-zeroRange,zeroRange);
clipImage(dy,-clipRange,clipRange);
zeroRangeImage(dy,-zeroRange,zeroRange);
startClip.Stop();
if(expGradient_p!=1.0){
TimeMessage start("Pow() transformation of gradients");
absPowImage(dx,expGradient_p);
absPowImage(dy,expGradient_p);
}
TimeMessage startLaplace("Computing 2nd derivative");
createLaplaceVonNeumannImage(dx,dy,li);
}
TimeMessage startSolve("Solving image");
solveImage(li,rResultImage_p);
startSolve.Stop();
TimeMessage startRescale("Rescaling image");
if(bRescale01_p){
rResultImage_p.Rescale(0.0,1.0);
} else {
rResultImage_p.Rescale(m_dMinVal,m_dMaxVal);
}
}
void fullscreen::screencutSave()
{
QImage img(clipImage(screen, currentRect));
QString filename;
filename = QFileDialog::getSaveFileName(this,tr("Save picture"),QDir::currentPath(),tr("Images (*.jpg *.png *.bmp)"));
if(filename!=NULL)img.save(filename);
this->close();
}
int loadFont(Font *Font, char *fileName, int width, int height)
{
Font->bitmap = loadImage(fileName);
if(Font->bitmap == NULL)
{
fprintf(stderr, "ERROR (loadFont): Failed to load font file: %s\n", fileName);
return 1;
}
Font->width = width;
Font->height = height;
clipImage(Font->clip, Font->width, Font->height, 16, 256);
return 0;
}
ChannelFeatures* ChannelFeatures::ApproxChannel(const cv::Mat& Image, int shrinking, float scaleN, float scaleR)
{
std::vector<float*> Feats;
cv::Mat clippedImage = clipImage(Image, shrinking);
int width = round(clippedImage.cols * scaleN / shrinking);
int height = round(clippedImage.rows * scaleN / shrinking);
float ratioLUV = pow(scaleN / scaleR, ColorChannel::getLambda());
float ratioGradMag = pow(scaleN / scaleR, GradMagChannel::getLambda());
float ratioGradHist = pow(scaleN / scaleR, GradHistChannel::getLambda());
//Color channels
for (int C = 0; C < 3; C++) {
float* Data = (float*)malloc(sizeof(float) * height * width);
resample<float>(Features[C], Data, this->getChannelHeight(), height, this->getChannelWidth(), width, 1, ratioLUV);
Feats.push_back(Data);
}
//Gradient Magnitude
for (int C = 3; C < 4; C++) {
float* Data = (float*)malloc(sizeof(float) * height * width);
resample<float>(Features[C], Data, this->getChannelHeight(), height, this->getChannelWidth(), width, 1, ratioGradMag);
Feats.push_back(Data);
}
// Gradient Histograms
for (int C = 4; C < 10; C++) {
float* Data = (float*)malloc(sizeof(float) * height * width);
resample<float>(Features[C], Data, this->getChannelHeight(), height, this->getChannelWidth(), width, 1, ratioGradHist);
Feats.push_back(Data);
}
// memcpy(D,data+c*this->Channelheight*this->Channelwidth,sizeof(float)*this->Channelheight*this->Channelwidth);
ChannelFeatures* R = new ChannelFeatures(width, height, Feats);
return R;
}
void initAnim(struct animStruct *anim, char *filename, int tileWidth, int tileHeight, int row, int numOfTiles)
{
//anim->animIMG = NULL;
anim->animIMG = loadImage(filename);
clipImage(anim->animClip, tileWidth, tileHeight, row, numOfTiles);
}
void TextureResourceLoader::divideHurdleGraphs(const Image& baseImage)
{
const auto hdSize = Vec2(17.0, 17.0);
this->hurdles.emplace_back(clipImage(baseImage, RectF(Vec2(6.0, 6.0), hdSize), tsTransColor));
}
void TextureResourceLoader::dividePlayerGraphs(const Image& baseImage)
{
this->playerPattern = Texture(clipImage(baseImage, RectF(Vec2( 6.0, 6.0), Vec2(25.0, 17.0)), tsTransColor));
this->playerHumanPattern = Texture(clipImage(baseImage, RectF(Vec2(35.0, 6.0), Vec2(24.0, 27.0)), tsTransColor));
}
