nou/tenmon
1
0
Fork 1
Code Issues Pull Requests Projects Releases 33 Wiki Activity

Support really big images 50000px

Browse Source
This commit is contained in:
Dušan Poizl
2024-11-30 21:51:47 +01:00
parent 9b7837e9fb
commit be1e65251d
3 changed files with 66 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rawimage.cpp
+46 -28
View File
@@ -45,7 +45,7 @@ void RawImage::allocate(uint32_t w, uint32_t h, uint32_t ch, DataType type)
m_channels = ch;
m_ch = ch == 3 ? 4 : ch;
m_origType = m_type = type;
m_pixels = std::make_unique<PixelType[]>(m_width * m_height * m_ch * typeSize(type));
m_pixels = std::make_unique<PixelType[]>((size_t)m_width * m_height * m_ch * typeSize(type));
}
RawImage::RawImage()
@@ -60,7 +60,7 @@ RawImage::RawImage(uint32_t w, uint32_t h, uint32_t ch, DataType type)
RawImage::RawImage(const RawImage &d)
{
allocate(d.m_width, d.m_height, d.m_channels, d.m_type);
std::memcpy(m_pixels.get(), d.m_pixels.get(), m_width * m_height * m_ch * typeSize(m_type));
std::memcpy(m_pixels.get(), d.m_pixels.get(), (size_t)m_width * m_height * m_ch * typeSize(m_type));
m_stats = d.m_stats;
}
@@ -118,6 +118,24 @@ RawImage::RawImage(const QImage &img)
for(int i=0; i<img.height(); i++)
std::memcpy(data(i), img.scanLine(i), img.width()*2);
}
else if(img.format() == QImage::Format_RGB32 || img.format() == QImage::Format_ARGB32)
{
allocate(img.width(), img.height(), 4, UINT8);
for(int i=0; i<img.height(); i++)
{
uint32_t *src = (uint32_t*)img.scanLine(i);
uint32_t *dst = (uint32_t*)data(i);
for(int o=0; o<img.width(); o++)
{
uint32_t p = src[o];
#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
dst[o] = (p & 0xff000000) | (p >> 16 & 0xff) | (p & 0xff00) | (p << 16 & 0xff0000);
#else
dst[o] = (p >> 24) | (p << 8 & 0xffffff00);
#endif
}
}
}
else
{
QImage tmp = img.convertToFormat(QImage::Format_RGBA8888);
@@ -294,9 +312,9 @@ uint32_t RawImage::channels() const
return m_channels;
}
uint32_t RawImage::size() const
uint64_t RawImage::size() const
{
return width()*height();
return (uint64_t)width()*height();
}
RawImage::DataType RawImage::type() const
@@ -336,12 +354,12 @@ const void *RawImage::data() const
void *RawImage::data(uint32_t row, uint32_t col)
{
return m_pixels.get() + (m_width * row * m_ch + col * m_ch) * typeSize(m_type);
return m_pixels.get() + ((size_t)m_width * row * m_ch + (size_t)col * m_ch) * typeSize(m_type);
}
const void *RawImage::data(uint32_t row, uint32_t col) const
{
return m_pixels.get() + (m_width * row * m_ch + col * m_ch) * typeSize(m_type);
return m_pixels.get() + ((size_t)m_width * row * m_ch + (size_t)col * m_ch) * typeSize(m_type);
}
const void *RawImage::origData() const
@@ -356,12 +374,12 @@ const void *RawImage::origData(uint32_t row, uint32_t col) const
{
if(m_original)
{
col = col * m_origWidth / m_width;
row = row * m_origHeight / m_height;
return m_original.get() + (m_origWidth * row * m_ch + col * m_ch) * typeSize(m_origType);
col = (uint64_t)col * m_origWidth / m_width;
row = (uint64_t)row * m_origHeight / m_height;
return m_original.get() + ((size_t)m_origWidth * row * m_ch + (size_t)col * m_ch) * typeSize(m_origType);
}
else
return m_pixels.get() + (m_width * row * m_ch + col * m_ch) * typeSize(m_type);
return m_pixels.get() + ((size_t)m_width * row * m_ch + (size_t)col * m_ch) * typeSize(m_type);
}
bool RawImage::planar() const
@@ -381,12 +399,12 @@ void RawImage::convertToThumbnail()
auto loop = [&](F16 *out, auto *in, float scale)
{
for(int i=0; i<THUMB_SIZE; i++)
for(int64_t i=0; i<THUMB_SIZE; i++)
{
for(int o=0; o<THUMB_SIZE; o++)
for(int64_t o=0; o<THUMB_SIZE; o++)
{
int idx = (i*THUMB_SIZE + o)*4;
int idx2 = ((i * m_height / THUMB_SIZE * m_width) + (o * m_width / THUMB_SIZE)) * m_ch;
int64_t idx = (i*THUMB_SIZE + o)*4;
int64_t idx2 = ((i * m_height / THUMB_SIZE * m_width) + (o * m_width / THUMB_SIZE)) * m_ch;
if(m_channels == 1)
{
@@ -442,21 +460,21 @@ void RawImage::convertToGLFormat()
}
template<typename T, typename U>
void convertType2(uint32_t size, const T *src, U *dst)
void convertType2(size_t size, const T *src, U *dst)
{
if constexpr((std::is_floating_point_v<T> || std::is_same_v<T, F16>) && (std::is_floating_point_v<U> || std::is_same_v<T, F16>))
{
for(uint32_t i = 0; i < size; i++)
for(size_t i = 0; i < size; i++)
dst[i] = src[i];
}
if constexpr(std::is_integral_v<T> && std::is_integral_v<U>)
{
if constexpr(sizeof(T) > sizeof(U))
for(uint32_t i = 0; i < size; i++)
for(size_t i = 0; i < size; i++)
dst[i] = src[i] >> ((sizeof(T) - sizeof(U)) * 8);
else
for(uint32_t i = 0; i < size; i++)
for(size_t i = 0; i < size; i++)
dst[i] = static_cast<U>(src[i]) << ((sizeof(U) - sizeof(T)) * 8);
}
@@ -464,20 +482,20 @@ void convertType2(uint32_t size, const T *src, U *dst)
{
U max = std::numeric_limits<U>::max();
T scale = (T)(max);
for(uint32_t i = 0; i < size; i++)
for(size_t i = 0; i < size; i++)
dst[i] = src[i] * scale;
}
if constexpr(std::is_integral_v<T> && (std::is_floating_point_v<U> || std::is_same_v<U, F16>))
{
U scale = (U)(1.0 / (double)std::numeric_limits<T>::max());
for(uint32_t i = 0; i < size; i++)
for(size_t i = 0; i < size; i++)
dst[i] = (U)src[i] * scale;
}
}
template<typename T>
void convertType(uint32_t size, RawImage::DataType dstType, const T *src, void *dst)
void convertType(size_t size, RawImage::DataType dstType, const T *src, void *dst)
{
switch(dstType)
{
@@ -514,7 +532,7 @@ void RawImage::convertToType(DataType type)
allocate(m_width, m_height, m_channels, type);
m_origType = origType;
uint32_t s = size() * m_ch;
size_t s = size() * m_ch;
switch(m_origType)
{
case UINT8:
@@ -656,15 +674,15 @@ void boxResample(uint32_t w, uint32_t h, uint32_t ch, uint32_t oldw, uint32_t ol
float sx = (float)w / oldw;
float sy = (float)h / oldh;
for(uint32_t y = 0; y < h; y++)//iterate over destination Y
for(uint64_t y = 0; y < h; y++)//iterate over destination Y
{
for(uint32_t x = 0; x < w; x++)//iterate over destination X
for(uint64_t x = 0; x < w; x++)//iterate over destination X
{
U p[4] = {0.0f};
uint32_t xx = x * oldw / w;//calculate source rect
uint32_t yy = y * oldh / h;
uint32_t xe = std::min((x + 1) * oldw / w, oldw - 1);
uint32_t ye = std::min((y + 1) * oldh / h, oldh - 1);
uint64_t xx = x * oldw / w;//calculate source rect
uint64_t yy = y * oldh / h;
uint64_t xe = std::min((x + 1) * oldw / w, (uint64_t)oldw - 1);
uint64_t ye = std::min((y + 1) * oldh / h, (uint64_t)oldh - 1);
for(uint32_t o = yy; o <= ye; o++)//iterate over source Y
{
float cy = o * sy - y;