cv::Rect CropTransformer::GetCropRect(CropType type, int crow, int ccol,
double cropRatio, std::mt19937 &rng)
{
assert(crow > 0);
assert(ccol > 0);
assert(0 < cropRatio && cropRatio <= 1.0);
int cropSize = static_cast<int>(std::min(crow, ccol) * cropRatio);
int xOff = -1;
int yOff = -1;
switch (type)
{
case CropType::Center:
xOff = (ccol - cropSize) / 2;
yOff = (crow - cropSize) / 2;
break;
case CropType::Random:
xOff = UniIntT(0, ccol - cropSize)(rng);
yOff = UniIntT(0, crow - cropSize)(rng);
break;
default:
assert(false);
}
assert(0 <= xOff && xOff <= ccol - cropSize);
assert(0 <= yOff && yOff <= crow - cropSize);
return cv::Rect(xOff, yOff, cropSize, cropSize);
}
cv::Rect CropTransformer::GetCropRectRandomArea(int crow, int ccol, std::mt19937 &rng)
{
assert(m_useAreaRatio);
cv::Rect rc = GetCropRectCenter(crow, ccol, rng);
int xOff = UniIntT(0, ccol - rc.width)(rng);
int yOff = UniIntT(0, crow - rc.height)(rng);
return cv::Rect(xOff, yOff, rc.width, rc.height);
}
void ScaleTransformer::Apply(cv::Mat &mat)
{
// If matrix has not been converted to the right type, do it now as rescaling
// requires floating point type.
//
if (mat.type() != CV_MAKETYPE(m_dataType, m_imgChannels))
{
mat.convertTo(mat, m_dataType);
}
auto seed = GetSeed();
auto rng = m_rngs.pop_or_create(
[seed]()
{
return std::make_unique<std::mt19937>(seed);
});
auto index = UniIntT(0, static_cast<int>(m_interp.size()) - 1)(*rng);
assert(m_interp.size() > 0);
cv::resize(
mat, mat,
cv::Size(static_cast<int>(m_imgWidth), static_cast<int>(m_imgHeight)), 0,
0, m_interp[index]);
m_rngs.push(std::move(rng));
}
cv::Rect CropTransformer::GetCropRect(CropType type, int viewIndex, int crow, int ccol,
double cropRatio, std::mt19937 &rng)
{
assert(crow > 0);
assert(ccol > 0);
assert(0 < cropRatio && cropRatio <= 1.0);
// Get square crop size that preserves aspect ratio.
int cropSize = (int)(std::min(crow, ccol) * cropRatio);
int cropSizeX = cropSize;
int cropSizeY = cropSize;
// Change aspect ratio, if this option is enabled.
if (m_curAspectRatioRadius > 0)
{
double factor = 1.0 + UniRealT(-m_curAspectRatioRadius, m_curAspectRatioRadius)(rng);
double area = cropSize * cropSize;
double newArea = area * factor;
if (std::bernoulli_distribution()(rng))
{
cropSizeX = (int)std::sqrt(newArea);
cropSizeY = (int)(area / cropSizeX);
}
else
{
cropSizeY = (int)std::sqrt(newArea);
cropSizeX = (int)(area / cropSizeY);
}
// This clamping should be ok if jittering ratio is not too big.
cropSizeX = std::min(cropSizeX, ccol);
cropSizeY = std::min(cropSizeY, crow);
}
int xOff = -1;
int yOff = -1;
switch (type)
{
case CropType::Center:
assert(viewIndex == 0);
xOff = (ccol - cropSizeX) / 2;
yOff = (crow - cropSizeY) / 2;
break;
case CropType::Random:
assert(viewIndex == 0);
xOff = UniIntT(0, ccol - cropSizeX)(rng);
yOff = UniIntT(0, crow - cropSizeY)(rng);
break;
case CropType::MultiView10:
{
assert(0 <= viewIndex && viewIndex < 10);
// 0 - 4: 4 corners + center crop. 5 - 9: same, but with a flip.
int isubView = viewIndex % 5;
switch (isubView)
{
// top-left
case 0:
xOff = 0;
yOff = 0;
break;
// top-right
case 1:
xOff = ccol - cropSizeX;
yOff = 0;
break;
// bottom-left
case 2:
xOff = 0;
yOff = crow - cropSizeY;
break;
// bottom-right
case 3:
xOff = ccol - cropSizeX;
yOff = crow - cropSizeY;
break;
// center
case 4:
xOff = (ccol - cropSizeX) / 2;
yOff = (crow - cropSizeY) / 2;
break;
}
break;
}
default:
assert(false);
}
assert(0 <= xOff && xOff <= ccol - cropSizeX);
assert(0 <= yOff && yOff <= crow - cropSizeY);
return cv::Rect(xOff, yOff, cropSizeX, cropSizeY);
}
