679 lines
19 KiB
C++
679 lines
19 KiB
C++
#include "rawimage.h"
|
|
#include <QDebug>
|
|
#include <cstring>
|
|
#include <QElapsedTimer>
|
|
|
|
int THUMB_SIZE = 128;
|
|
int THUMB_SIZE_BORDER = 138;
|
|
int THUMB_SIZE_BORDER_Y = 158;
|
|
double SATURATION = 0.95;
|
|
|
|
template<typename T, int ch>
|
|
void fromPlanarSSE(const void *in, void *out, size_t count);
|
|
|
|
size_t RawImage::typeSize(RawImage::DataType type)
|
|
{
|
|
switch(type)
|
|
{
|
|
case RawImage::UINT8:
|
|
return 1;
|
|
case RawImage::UINT16:
|
|
return 2;
|
|
case RawImage::UINT32:
|
|
case RawImage::FLOAT32:
|
|
return 4;
|
|
case RawImage::FLOAT64:
|
|
return 8;
|
|
default: return 1;
|
|
}
|
|
}
|
|
|
|
void RawImage::allocate(uint32_t w, uint32_t h, uint32_t ch, DataType type)
|
|
{
|
|
m_width = w;
|
|
m_height = h;
|
|
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));
|
|
}
|
|
|
|
RawImage::RawImage()
|
|
{
|
|
}
|
|
|
|
RawImage::RawImage(uint32_t w, uint32_t h, uint32_t ch, DataType type)
|
|
{
|
|
allocate(w, h, ch, 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));
|
|
m_stats = d.m_stats;
|
|
}
|
|
|
|
RawImage::RawImage(RawImage &&d)
|
|
{
|
|
m_pixels = std::move(d.m_pixels);
|
|
m_original = std::move(d.m_original);
|
|
m_width = d.m_width;
|
|
m_height = d.m_height;
|
|
m_channels = d.m_channels;
|
|
m_ch = d.m_ch;
|
|
m_type = d.m_type;
|
|
m_origType = d.m_origType;
|
|
m_stats = d.m_stats;
|
|
m_thumbAspect = d.m_thumbAspect;
|
|
}
|
|
|
|
RawImage::RawImage(const QImage &img)
|
|
{
|
|
qDebug() << img;
|
|
if(img.format() == QImage::Format_RGBX8888)
|
|
{
|
|
allocate(img.width(), img.height(), 3, UINT8);
|
|
for(int i=0; i<img.height(); i++)
|
|
std::memcpy(data(i), img.scanLine(i), img.width()*4);
|
|
}
|
|
else if(img.format() == QImage::Format_RGBA8888)
|
|
{
|
|
allocate(img.width(), img.height(), 4, UINT8);
|
|
for(int i=0; i<img.height(); i++)
|
|
std::memcpy(data(i), img.scanLine(i), img.width()*4);
|
|
}
|
|
else if(img.format() == QImage::Format_RGBX64)
|
|
{
|
|
allocate(img.width(), img.height(), 3, UINT16);
|
|
for(int i=0; i<img.height(); i++)
|
|
std::memcpy(data(i), img.scanLine(i), img.width()*8);
|
|
}
|
|
else if(img.format() == QImage::Format_RGBA64)
|
|
{
|
|
allocate(img.width(), img.height(), 4, UINT16);
|
|
for(int i=0; i<img.height(); i++)
|
|
std::memcpy(data(i), img.scanLine(i), img.width()*8);
|
|
}
|
|
else if(img.format() == QImage::Format_Grayscale8)
|
|
{
|
|
allocate(img.width(), img.height(), 1, UINT8);
|
|
for(int i=0; i<img.height(); i++)
|
|
std::memcpy(data(i), img.scanLine(i), img.width());
|
|
}
|
|
else if(img.format() == QImage::Format_Grayscale16)
|
|
{
|
|
allocate(img.width(), img.height(), 1, UINT16);
|
|
for(int i=0; i<img.height(); i++)
|
|
std::memcpy(data(i), img.scanLine(i), img.width()*2);
|
|
}
|
|
else
|
|
{
|
|
QImage tmp = img.convertToFormat(QImage::Format_RGBA8888);
|
|
allocate(img.width(), img.height(), 4, UINT8);
|
|
for(int i=0; i<tmp.height(); i++)
|
|
std::memcpy(data(i), tmp.scanLine(i), tmp.width()*4);
|
|
}
|
|
m_stats.m_stats = false;
|
|
}
|
|
|
|
const RawImage::Stats& RawImage::imageStats()
|
|
{
|
|
return m_stats;
|
|
}
|
|
|
|
template<typename T, typename U, int ch>
|
|
void calcStats(const T *data, size_t n, size_t w, RawImage::Stats &stats)
|
|
{
|
|
U sum[4] = {0};
|
|
U sumSq[4] = {0};
|
|
T min[4] = {std::numeric_limits<T>::max(), std::numeric_limits<T>::max(), std::numeric_limits<T>::max(), std::numeric_limits<T>::max()};
|
|
T max[4] = {std::numeric_limits<T>::min(), std::numeric_limits<T>::min(), std::numeric_limits<T>::min(), std::numeric_limits<T>::min()};
|
|
uint32_t histSize = 65536;
|
|
if constexpr(std::is_same<T, uint8_t>::value)histSize = 256;
|
|
uint32_t histogram[4][65536] = {};
|
|
T sat = SATURATION * std::numeric_limits<T>::max();
|
|
if constexpr(!std::numeric_limits<T>::is_integer)sat = SATURATION;
|
|
uint32_t saturated[4] = {0};
|
|
|
|
auto statsFunc = [&](T d, int x)
|
|
{
|
|
sum[x] += d;
|
|
sumSq[x] += (U)d * d;
|
|
min[x] = std::min(min[x], d);
|
|
max[x] = std::max(max[x], d);
|
|
uint16_t idx;
|
|
if constexpr(std::is_same<T, uint32_t>::value)idx = d >> 16;
|
|
if constexpr(std::is_same<T, uint8_t>::value || std::is_same<T, uint16_t>::value)idx = d;
|
|
if constexpr(!std::numeric_limits<T>::is_integer)idx = std::clamp((T)d * histSize, (T)0.0, (T)65535.0);
|
|
histogram[x][idx]++;
|
|
if(d > sat)saturated[x]++;
|
|
};
|
|
|
|
auto findMedian = [histSize](uint32_t histogram[], size_t n) -> size_t
|
|
{
|
|
size_t histSum = 0;
|
|
for(size_t o=0; o < histSize; o++)
|
|
{
|
|
histSum += histogram[o];
|
|
if(histSum >= n/2)
|
|
return o;
|
|
}
|
|
return 0;
|
|
};
|
|
|
|
size_t na[4] = {n, n, n, n};
|
|
if constexpr(ch == 1)
|
|
{
|
|
na[1] /= 4;
|
|
na[2] /= 2;
|
|
na[3] /= 4;
|
|
}
|
|
for(size_t i = 0; i < n; i++)
|
|
{
|
|
statsFunc(data[i*ch], 0);
|
|
if constexpr(ch >= 3)
|
|
{
|
|
statsFunc(data[i*ch + 1], 1);
|
|
statsFunc(data[i*ch + 2], 2);
|
|
}
|
|
if constexpr(ch == 1)
|
|
{
|
|
int bayer = (i % w & 1) + (i / w & 1) + 1;
|
|
statsFunc(data[i], bayer);
|
|
}
|
|
}
|
|
|
|
for(int i = 0; i < 4; i++)
|
|
{
|
|
stats.m_min[i] = min[i];
|
|
stats.m_max[i] = max[i];
|
|
stats.m_mean[i] = (double)sum[i] / na[i];
|
|
stats.m_saturated[i] = saturated[i];
|
|
double sum2 = (double)sum[i] * sum[i];
|
|
stats.m_stdDev[i] = std::sqrt((sumSq[i] - sum2 / na[i]) / (na[i] - 1));
|
|
|
|
uint32_t median = findMedian(histogram[i], na[i]);
|
|
stats.m_median[i] = median;
|
|
uint32_t madHist[65536] = {0};
|
|
madHist[0] = histogram[i][median];
|
|
for(size_t o = 1; o < histSize; o++)
|
|
{
|
|
if(median + o < histSize)madHist[o] += histogram[i][median + o];
|
|
if(o <= median)madHist[o] += histogram[i][median - o];
|
|
}
|
|
stats.m_mad[i] = findMedian(madHist, na[i]);
|
|
if constexpr(!std::numeric_limits<T>::is_integer)
|
|
{
|
|
stats.m_median[i] /= 65535.0;
|
|
stats.m_mad[i] /= 65535.0;
|
|
}
|
|
}
|
|
|
|
stats.m_histogram.resize(histSize, 0);
|
|
for(size_t i = 0; i < histSize; i++)
|
|
for(size_t o = 0; o < ch; o++)
|
|
stats.m_histogram[i] += histogram[o][i];
|
|
}
|
|
|
|
void RawImage::calcStats()
|
|
{
|
|
if(m_stats.m_stats)return;
|
|
m_stats.m_stats = true;
|
|
|
|
switch(m_origType)
|
|
{
|
|
case UINT8:
|
|
if(channels()==1)
|
|
::calcStats<uint8_t, uint64_t, 1>(static_cast<const uint8_t*>(origData()), size(), width(), m_stats);
|
|
else
|
|
::calcStats<uint8_t, uint64_t, 4>(static_cast<const uint8_t*>(origData()), size(), width(), m_stats);
|
|
break;
|
|
case UINT16:
|
|
if(channels()==1)
|
|
::calcStats<uint16_t, uint64_t, 1>(static_cast<const uint16_t*>(origData()), size(), width(), m_stats);
|
|
else
|
|
::calcStats<uint16_t, uint64_t, 4>(static_cast<const uint16_t*>(origData()), size(), width(), m_stats);
|
|
break;
|
|
case UINT32:
|
|
if(channels()==1)
|
|
::calcStats<uint32_t, double, 1>(static_cast<const uint32_t*>(origData()), size(), width(), m_stats);
|
|
else
|
|
::calcStats<uint32_t, double, 4>(static_cast<const uint32_t*>(origData()), size(), width(), m_stats);
|
|
break;
|
|
case FLOAT32:
|
|
if(channels()==1)
|
|
::calcStats<float, double, 1>(static_cast<const float*>(origData()), size(), width(), m_stats);
|
|
else
|
|
::calcStats<float, double, 4>(static_cast<const float*>(origData()), size(), width(), m_stats);
|
|
break;
|
|
case FLOAT64:
|
|
if(channels()==1)
|
|
::calcStats<double, double, 1>(static_cast<const double*>(origData()), size(), width(), m_stats);
|
|
else
|
|
::calcStats<double, double, 4>(static_cast<const double*>(origData()), size(), width(), m_stats);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void RawImage::rect(int &x, int &y, int w, int h, std::vector<double> &r) const
|
|
{
|
|
/*r.resize(w*h);
|
|
x -= w/2;
|
|
y -= h/2;
|
|
if(x<0)x = 0;
|
|
if(y<0)y = 0;
|
|
if(x+w >= m_img.cols)x = m_img.cols-w;
|
|
if(y+h >= m_img.rows)y = m_img.rows-h;
|
|
cv::Mat roiImg(m_img, cv::Rect(x, y, w, h));
|
|
cv::Mat doubleMat;
|
|
roiImg.convertTo(doubleMat, CV_64F);
|
|
r = std::vector<double>(doubleMat.begin<double>(), doubleMat.end<double>());*/
|
|
}
|
|
|
|
int RawImage::findPeaks(double background, double distance, std::vector<Peak> &peaks) const
|
|
{
|
|
/*std::vector<std::vector<cv::Point>> contours;
|
|
|
|
cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(distance, distance));
|
|
|
|
cv::Mat img, mask, dilate, locMax, result;
|
|
if(m_img.channels() == 1)img = m_img;
|
|
else cv::cvtColor(m_img, img, cv::COLOR_RGB2GRAY);
|
|
|
|
cv::dilate(img, dilate, kernel);
|
|
cv::compare(img, dilate, locMax, cv::CMP_GE);
|
|
cv::compare(img, cv::Scalar(background), mask, cv::CMP_GT);
|
|
cv::bitwise_and(locMax, mask, result);
|
|
|
|
cv::findContours(result, contours, cv::noArray(), cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
|
|
peaks.reserve(contours.size());
|
|
for(auto contour : contours)
|
|
{
|
|
peaks.push_back(Peak(1, contour[0].x, contour[0].y));
|
|
}
|
|
|
|
return peaks.size();*/
|
|
}
|
|
|
|
uint32_t RawImage::width() const
|
|
{
|
|
return m_width;
|
|
}
|
|
|
|
uint32_t RawImage::height() const
|
|
{
|
|
return m_height;
|
|
}
|
|
|
|
uint32_t RawImage::channels() const
|
|
{
|
|
return m_channels;
|
|
}
|
|
|
|
uint32_t RawImage::size() const
|
|
{
|
|
return width()*height();
|
|
}
|
|
|
|
RawImage::DataType RawImage::type() const
|
|
{
|
|
return m_type;
|
|
}
|
|
|
|
uint32_t RawImage::norm() const
|
|
{
|
|
switch(m_type)
|
|
{
|
|
case UINT8:
|
|
return UINT8_MAX;
|
|
case UINT16:
|
|
return UINT16_MAX;
|
|
case UINT32:
|
|
return UINT32_MAX;
|
|
default:
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
void* RawImage::data()
|
|
{
|
|
return m_pixels.get();
|
|
}
|
|
|
|
const void *RawImage::data() const
|
|
{
|
|
return m_pixels.get();
|
|
}
|
|
|
|
void *RawImage::data(uint32_t row, uint32_t col)
|
|
{
|
|
return m_pixels.get() + (m_width * row * m_ch + 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);
|
|
}
|
|
|
|
const void *RawImage::origData() const
|
|
{
|
|
if(m_original)
|
|
return m_original.get();
|
|
else
|
|
return m_pixels.get();
|
|
}
|
|
|
|
const void *RawImage::origData(uint32_t row, uint32_t col) const
|
|
{
|
|
if(m_original)
|
|
return m_original.get() + (m_width * row * m_ch + col * m_ch) * typeSize(m_origType);
|
|
else
|
|
return m_pixels.get() + (m_width * row * m_ch + col * m_ch) * typeSize(m_type);
|
|
}
|
|
|
|
void RawImage::convertToThumbnail()
|
|
{
|
|
m_thumbAspect = (float)width() / height();
|
|
std::unique_ptr<PixelType[]> outptr = std::make_unique<PixelType[]>(THUMB_SIZE * THUMB_SIZE * 4 * sizeof(uint16_t));
|
|
uint16_t *out = reinterpret_cast<uint16_t*>(outptr.get());
|
|
|
|
auto loop = [&](uint16_t *out, auto *in, auto scale)
|
|
{
|
|
for(int i=0; i<THUMB_SIZE; i++)
|
|
{
|
|
for(int 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;
|
|
if(m_channels == 1)
|
|
{
|
|
out[idx] = out[idx + 1] = out[idx + 2] = in[idx2] * scale;
|
|
}
|
|
else
|
|
{
|
|
out[idx] = in[idx2] * scale;;
|
|
out[idx + 1] = in[idx2 + 1] * scale;;
|
|
out[idx + 2] = in[idx2 + 2] * scale;;
|
|
}
|
|
out[idx + 3] = UINT16_MAX;
|
|
}
|
|
}
|
|
};
|
|
|
|
switch(m_type)
|
|
{
|
|
case UINT8:
|
|
loop(out, reinterpret_cast<uint8_t*>(m_pixels.get()), 256);
|
|
break;
|
|
case UINT16:
|
|
loop(out, reinterpret_cast<uint16_t*>(m_pixels.get()), 1);
|
|
break;
|
|
case UINT32:
|
|
loop(out, reinterpret_cast<uint32_t*>(m_pixels.get()), UINT16_MAX/(float)UINT32_MAX);
|
|
break;
|
|
case FLOAT32:
|
|
loop(out, reinterpret_cast<float*>(m_pixels.get()), 65535.0);
|
|
break;
|
|
default:
|
|
qWarning() << "FLOAT64 should not happend";
|
|
return;
|
|
}
|
|
|
|
m_pixels = std::move(outptr);
|
|
m_width = THUMB_SIZE;
|
|
m_height = THUMB_SIZE;
|
|
m_ch = 4;
|
|
m_channels = 3;
|
|
m_type = UINT16;
|
|
}
|
|
|
|
void RawImage::convertToGLFormat()
|
|
{
|
|
size_t s = size() * m_ch;
|
|
if(m_type == UINT32)
|
|
{
|
|
m_original = std::move(m_pixels);
|
|
allocate(m_width, m_height, m_channels, FLOAT32);
|
|
m_origType = UINT32;
|
|
float *dst = reinterpret_cast<float*>(m_pixels.get());
|
|
uint32_t *src = reinterpret_cast<uint32_t*>(m_original.get());
|
|
|
|
for(size_t i = 0; i < s; i++)
|
|
dst[i] = src[i] / (float)UINT32_MAX;
|
|
}
|
|
else if(m_type == FLOAT64)
|
|
{
|
|
m_original = std::move(m_pixels);
|
|
allocate(m_width, m_height, m_channels, FLOAT32);
|
|
m_origType = FLOAT64;
|
|
float *dst = reinterpret_cast<float*>(m_pixels.get());
|
|
double *src = reinterpret_cast<double*>(m_original.get());
|
|
|
|
for(size_t i = 0; i < s; i++)
|
|
dst[i] = src[i];
|
|
}
|
|
}
|
|
|
|
float RawImage::thumbAspect() const
|
|
{
|
|
return m_thumbAspect;
|
|
}
|
|
|
|
bool RawImage::pixel(int x, int y, double &r, double &g, double &b) const
|
|
{
|
|
if(x < 0 || y < 0 || x >= (int)width() || y >= (int)height())return false;
|
|
|
|
switch(m_origType)
|
|
{
|
|
case UINT8:
|
|
{
|
|
const uint8_t *v = static_cast<const uint8_t*>(origData(y, x));
|
|
if(m_channels == 1)
|
|
{
|
|
r = g = b = *v;
|
|
}
|
|
else
|
|
{
|
|
r = v[0];
|
|
g = v[1];
|
|
b = v[2];
|
|
}
|
|
break;
|
|
}
|
|
case UINT16:
|
|
{
|
|
const uint16_t *v = static_cast<const uint16_t*>(origData(y, x));
|
|
if(m_channels == 1)
|
|
{
|
|
r = g = b = *v;
|
|
}
|
|
else
|
|
{
|
|
r = v[0];
|
|
g = v[1];
|
|
b = v[2];
|
|
}
|
|
break;
|
|
}
|
|
case UINT32:
|
|
{
|
|
const uint32_t *v = static_cast<const uint32_t*>(origData(y, x));
|
|
if(m_channels == 1)
|
|
{
|
|
r = g = b = *v;
|
|
}
|
|
else
|
|
{
|
|
r = v[0];
|
|
g = v[1];
|
|
b = v[2];
|
|
}
|
|
break;
|
|
}
|
|
case FLOAT32:
|
|
{
|
|
const float *v = static_cast<const float*>(origData(y, x));
|
|
if(m_channels == 1)
|
|
{
|
|
r = g = b = *v;
|
|
}
|
|
else
|
|
{
|
|
r = v[0];
|
|
g = v[1];
|
|
b = v[2];
|
|
}
|
|
break;
|
|
}
|
|
case FLOAT64:
|
|
{
|
|
const double *v = static_cast<const double*>(origData(y, x));
|
|
if(m_channels == 1)
|
|
{
|
|
r = g = b = *v;
|
|
}
|
|
else
|
|
{
|
|
r = v[0];
|
|
g = v[1];
|
|
b = v[2];
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void RawImage::scaleToUnit()
|
|
{
|
|
/*if(CV_MAT_DEPTH(m_img.type()) == CV_32F)
|
|
{
|
|
double min, max;
|
|
cv::minMaxIdx(m_img, &min, &max);
|
|
if(min < 0 || max > 1)
|
|
{
|
|
float scale = 1.0 / (max - min);
|
|
float zero = min * scale;
|
|
m_img = m_img * scale - zero;
|
|
}
|
|
}*/
|
|
}
|
|
|
|
void RawImage::downscaleTo(uint32_t size)
|
|
{
|
|
/*if(size < width() || size < height())
|
|
{
|
|
double s = (double)size / std::max(width(), height());
|
|
cv::Size dsize(std::floor(width() * s), std::floor(height() * s));
|
|
cv::resize(m_img, m_img, dsize, 0, 0, cv::INTER_AREA);
|
|
}*/
|
|
}
|
|
|
|
std::shared_ptr<RawImage> RawImage::fromPlanar(const RawImage &img)
|
|
{
|
|
return RawImage::fromPlanar(img.data(), img.width(), img.height(), img.channels(), img.type());
|
|
}
|
|
|
|
std::shared_ptr<RawImage> RawImage::fromPlanar(const void *pixels, uint32_t w, uint32_t h, uint32_t ch, RawImage::DataType type)
|
|
{
|
|
std::shared_ptr<RawImage> image = std::make_shared<RawImage>(w, h, ch, type);
|
|
size_t size = w * h;
|
|
size_t ch2 = ch == 1 ? 1 : 4;
|
|
auto convert = [&](auto *in, auto *out, auto alpha)
|
|
{
|
|
for(size_t i=0; i<size; i++)
|
|
for(size_t o=0; o<ch; o++)
|
|
out[i*ch2 + o] = in[o*size + i];
|
|
|
|
if(ch != ch2)
|
|
for(size_t i=0; i<size; i++)
|
|
out[i*ch2 + 3] = alpha;
|
|
};
|
|
|
|
switch(type)
|
|
{
|
|
case UINT8:
|
|
#ifdef __SSE2__
|
|
if(ch==3)
|
|
fromPlanarSSE<uint8_t, 3>(pixels, image->data(), size);
|
|
else
|
|
fromPlanarSSE<uint8_t, 4>(pixels, image->data(), size);
|
|
#else
|
|
convert(static_cast<const uint8_t*>(pixels), static_cast<uint8_t*>(image->data()), UINT8_MAX);
|
|
#endif
|
|
break;
|
|
case UINT16:
|
|
#ifdef __SSE2__
|
|
if(ch==3)
|
|
fromPlanarSSE<uint16_t, 3>(pixels, static_cast<uint16_t*>(image->data()), size);
|
|
else
|
|
fromPlanarSSE<uint16_t, 4>(pixels, static_cast<uint16_t*>(image->data()), size);
|
|
#else
|
|
convert(static_cast<const uint16_t*>(pixels), static_cast<uint16_t*>(image->data()), UINT16_MAX);
|
|
#endif
|
|
break;
|
|
case UINT32:
|
|
#ifdef __SSE2__
|
|
if(ch==3)
|
|
fromPlanarSSE<uint32_t, 3>(pixels, image->data(), size);
|
|
else
|
|
fromPlanarSSE<uint32_t, 4>(pixels, image->data(), size);
|
|
#else
|
|
convert(static_cast<const uint32_t*>(pixels), static_cast<uint32_t*>(image->data()), UINT32_MAX);
|
|
#endif
|
|
break;
|
|
case FLOAT32:
|
|
#ifdef __SSE2__
|
|
if(ch==3)
|
|
fromPlanarSSE<float, 3>(pixels, image->data(), size);
|
|
else
|
|
fromPlanarSSE<float, 4>(pixels, image->data(), size);
|
|
#else
|
|
convert(static_cast<const float*>(pixels), static_cast<float*>(image->data()), 1);
|
|
#endif
|
|
break;
|
|
case FLOAT64:
|
|
convert(static_cast<const double*>(pixels), static_cast<double*>(image->data()), 1);
|
|
break;
|
|
}
|
|
return image;
|
|
}
|
|
|
|
std::vector<RawImage> RawImage::split() const
|
|
{
|
|
std::vector<RawImage> planes;
|
|
planes.resize(m_channels);
|
|
for(size_t i=0; i<m_channels; i++)
|
|
planes[i].allocate(m_width, m_height, 1, m_type);
|
|
|
|
size_t s = size();
|
|
auto extract = [&](auto *in, auto *out, size_t off)
|
|
{
|
|
for(size_t i=0; i < s; i+=m_ch)
|
|
out[i] = in[i*m_ch + off];
|
|
};
|
|
|
|
for(uint32_t i=0; i<m_ch; i++)
|
|
{
|
|
switch(m_type)
|
|
{
|
|
case UINT8:
|
|
extract(static_cast<const uint8_t*>(data()), static_cast<uint8_t*>(planes[i].data()), i);
|
|
break;
|
|
case UINT16:
|
|
extract(static_cast<const uint16_t*>(data()), static_cast<uint16_t*>(planes[i].data()), i);
|
|
break;
|
|
case UINT32:
|
|
case FLOAT32:
|
|
extract(static_cast<const uint32_t*>(data()), static_cast<uint32_t*>(planes[i].data()), i);
|
|
break;
|
|
case FLOAT64:
|
|
extract(static_cast<const double*>(data()), static_cast<double*>(planes[i].data()), i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return planes;
|
|
}
|