ShuriZma
/
xenia
mirror of https://github.com/xenia-project/xenia.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
xenia/third_party/crunch/crnlib/crn_image_utils.cpp

1368 lines
46 KiB
C++
Raw Normal View History

Adding Crunch at r319.
2014-01-21 07:02:34 +00:00
// File: crn_image_utils.cpp
// See Copyright Notice and license at the end of inc/crnlib.h
#include "crn_core.h"
#include "crn_image_utils.h"
#include "crn_console.h"
#include "crn_resampler.h"
#include "crn_threaded_resampler.h"
#include "crn_strutils.h"
#include "crn_file_utils.h"
#include "crn_threading.h"
#include "crn_miniz.h"
#include "crn_jpge.h"
#include "crn_cfile_stream.h"
#include "crn_mipmapped_texture.h"
#include "crn_buffer_stream.h"
#define STBI_HEADER_FILE_ONLY
#include "crn_stb_image.cpp"
#include "crn_jpgd.h"
#include "crn_pixel_format.h"
namespace crnlib
{
const float cInfinitePSNR = 999999.0f;
const uint CRNLIB_LARGEST_SUPPORTED_IMAGE_DIMENSION = 16384;
namespace image_utils
{
bool read_from_stream_stb(data_stream_serializer &serializer, image_u8& img)
{
uint8_vec buf;
if (!serializer.read_entire_file(buf))
return false;
int x = 0, y = 0, n = 0;
unsigned char* pData = stbi_load_from_memory(buf.get_ptr(), buf.size_in_bytes(), &x, &y, &n, 4);
if (!pData)
return false;
if ((x > (int)CRNLIB_LARGEST_SUPPORTED_IMAGE_DIMENSION) || (y > (int)CRNLIB_LARGEST_SUPPORTED_IMAGE_DIMENSION))
{
stbi_image_free(pData);
return false;
}
const bool has_alpha = ((n == 2) || (n == 4));
img.resize(x, y);
bool grayscale = true;
for (int py = 0; py < y; py++)
{
const color_quad_u8* pSrc = reinterpret_cast<const color_quad_u8*>(pData) + (py * x);
color_quad_u8* pDst = img.get_scanline(py);
color_quad_u8* pDst_end = pDst + x;
while (pDst != pDst_end)
{
color_quad_u8 c(*pSrc++);
if (!has_alpha)
c.a = 255;
if (!c.is_grayscale())
grayscale = false;
*pDst++ = c;
}
}
stbi_image_free(pData);
img.reset_comp_flags();
img.set_grayscale(grayscale);
img.set_component_valid(3, has_alpha);
return true;
}
bool read_from_stream_jpgd(data_stream_serializer &serializer, image_u8& img)
{
uint8_vec buf;
if (!serializer.read_entire_file(buf))
return false;
int width = 0, height = 0, actual_comps = 0;
unsigned char *pSrc_img = jpgd::decompress_jpeg_image_from_memory(buf.get_ptr(), buf.size_in_bytes(), &width, &height, &actual_comps, 4);
if (!pSrc_img)
return false;
if (math::maximum(width, height) > (int)CRNLIB_LARGEST_SUPPORTED_IMAGE_DIMENSION)
{
crnlib_free(pSrc_img);
return false;
}
if (!img.grant_ownership(reinterpret_cast<color_quad_u8*>(pSrc_img), width, height))
{
crnlib_free(pSrc_img);
return false;
}
img.reset_comp_flags();
img.set_grayscale(actual_comps == 1);
img.set_component_valid(3, false);
return true;
}
bool read_from_stream(image_u8& dest, data_stream_serializer& serializer, uint read_flags)
{
if (read_flags > cReadFlagsAllFlags)
{
CRNLIB_ASSERT(0);
return false;
}
if (!serializer.get_stream())
{
CRNLIB_ASSERT(0);
return false;
}
dynamic_string ext(serializer.get_name());
file_utils::get_extension(ext);
if ((ext == "jpg") || (ext == "jpeg"))
{
// Use my jpeg decoder by default because it supports progressive jpeg's.
if ((read_flags & cReadFlagForceSTB) == 0)
{
return image_utils::read_from_stream_jpgd(serializer, dest);
}
}
return image_utils::read_from_stream_stb(serializer, dest);
}
bool read_from_file(image_u8& dest, const char* pFilename, uint read_flags)
{
if (read_flags > cReadFlagsAllFlags)
{
CRNLIB_ASSERT(0);
return false;
}
cfile_stream file_stream;
if (!file_stream.open(pFilename))
return false;
data_stream_serializer serializer(file_stream);
return read_from_stream(dest, serializer, read_flags);
}
bool write_to_file(const char* pFilename, const image_u8& img, uint write_flags, int grayscale_comp_index)
{
if ((grayscale_comp_index < -1) || (grayscale_comp_index > 3))
{
CRNLIB_ASSERT(0);
return false;
}
if (!img.get_width())
{
CRNLIB_ASSERT(0);
return false;
}
dynamic_string ext(pFilename);
bool is_jpeg = false;
if (file_utils::get_extension(ext))
{
is_jpeg = ((ext == "jpg") || (ext == "jpeg"));
if ((ext != "png") && (ext != "bmp") && (ext != "tga") && (!is_jpeg))
{
console::error("crnlib::image_utils::write_to_file: Can only write .BMP, .TGA, .PNG, or .JPG files!\n");
return false;
}
}
crnlib::vector<uint8> temp;
uint num_src_chans = 0;
const void *pSrc_img = NULL;
if (is_jpeg)
{
write_flags |= cWriteFlagIgnoreAlpha;
}
if ((img.get_comp_flags() & pixel_format_helpers::cCompFlagGrayscale) || (write_flags & image_utils::cWriteFlagGrayscale))
{
CRNLIB_ASSERT(grayscale_comp_index < 4);
if (grayscale_comp_index > 3) grayscale_comp_index = 3;
temp.resize(img.get_total_pixels());
for (uint y = 0; y < img.get_height(); y++)
{
const color_quad_u8* pSrc = img.get_scanline(y);
const color_quad_u8* pSrc_end = pSrc + img.get_width();
uint8* pDst = &temp[y * img.get_width()];
if (img.get_comp_flags() & pixel_format_helpers::cCompFlagGrayscale)
{
while (pSrc != pSrc_end)
*pDst++ = (*pSrc++)[1];
}
else if (grayscale_comp_index < 0)
{
while (pSrc != pSrc_end)
*pDst++ = static_cast<uint8>((*pSrc++).get_luma());
}
else
{
while (pSrc != pSrc_end)
*pDst++ = (*pSrc++)[grayscale_comp_index];
}
}
pSrc_img = &temp[0];
num_src_chans = 1;
}
else if ((!img.is_component_valid(3)) || (write_flags & cWriteFlagIgnoreAlpha))
{
temp.resize(img.get_total_pixels() * 3);
for (uint y = 0; y < img.get_height(); y++)
{
const color_quad_u8* pSrc = img.get_scanline(y);
const color_quad_u8* pSrc_end = pSrc + img.get_width();
uint8* pDst = &temp[y * img.get_width() * 3];
while (pSrc != pSrc_end)
{
const color_quad_u8 c(*pSrc++);
pDst[0] = c.r;
pDst[1] = c.g;
pDst[2] = c.b;
pDst += 3;
}
}
num_src_chans = 3;
pSrc_img = &temp[0];
}
else
{
num_src_chans = 4;
pSrc_img = img.get_ptr();
}
bool success = false;
if (ext == "png")
{
size_t png_image_size = 0;
void *pPNG_image_data = tdefl_write_image_to_png_file_in_memory(pSrc_img, img.get_width(), img.get_height(), num_src_chans, &png_image_size);
if (!pPNG_image_data)
return false;
success = file_utils::write_buf_to_file(pFilename, pPNG_image_data, png_image_size);
mz_free(pPNG_image_data);
}
else if (is_jpeg)
{
jpge::params params;
if (write_flags & cWriteFlagJPEGQualityLevelMask)
params.m_quality = math::clamp<uint>((write_flags & cWriteFlagJPEGQualityLevelMask) >> cWriteFlagJPEGQualityLevelShift, 1U, 100U);
params.m_two_pass_flag = (write_flags & cWriteFlagJPEGTwoPass) != 0;
params.m_no_chroma_discrim_flag = (write_flags & cWriteFlagJPEGNoChromaDiscrim) != 0;
if (write_flags & cWriteFlagJPEGH1V1)
params.m_subsampling = jpge::H1V1;
else if (write_flags & cWriteFlagJPEGH2V1)
params.m_subsampling = jpge::H2V1;
else if (write_flags & cWriteFlagJPEGH2V2)
params.m_subsampling = jpge::H2V2;
success = jpge::compress_image_to_jpeg_file(pFilename, img.get_width(), img.get_height(), num_src_chans, (const jpge::uint8*)pSrc_img, params);
}
else
{
success = ((ext == "bmp" ? stbi_write_bmp : stbi_write_tga)(pFilename, img.get_width(), img.get_height(), num_src_chans, pSrc_img) == CRNLIB_TRUE);
}
return success;
}
bool has_alpha(const image_u8& img)
{
for (uint y = 0; y < img.get_height(); y++)
for (uint x = 0; x < img.get_width(); x++)
if (img(x, y).a < 255)
return true;
return false;
}
void renorm_normal_map(image_u8& img)
{
for (uint y = 0; y < img.get_height(); y++)
{
for (uint x = 0; x < img.get_width(); x++)
{
color_quad_u8& c = img(x, y);
if ((c.r == 128) && (c.g == 128) && (c.b == 128))
continue;
vec3F v(c.r, c.g, c.b);
v *= 1.0f/255.0f;
v *= 2.0f;
v -= vec3F(1.0f);
v.clamp(-1.0f, 1.0f);
float length = v.length();
if (length < .077f)
c.set(128, 128, 128, c.a);
else if (fabs(length - 1.0f) > .077f)
{
if (length)
v /= length;
for (uint i = 0; i < 3; i++)
c[i] = static_cast<uint8>(math::clamp<float>(floor((v[i] + 1.0f) * .5f * 255.0f + .5f), 0.0f, 255.0f));
if ((c.r == 128) && (c.g == 128))
{
if (c.b < 128)
c.b = 0;
else
c.b = 255;
}
}
}
}
}
bool is_normal_map(const image_u8& img, const char* pFilename)
{
float score = 0.0f;
uint num_invalid_pixels = 0;
// TODO: Derive better score from pixel mean, eigenvecs/vals
//crnlib::vector<vec3F> pixels;
for (uint y = 0; y < img.get_height(); y++)
{
for (uint x = 0; x < img.get_width(); x++)
{
const color_quad_u8& c = img(x, y);
if (c.b < 123)
{
num_invalid_pixels++;
continue;
}
else if ((c.r != 128) || (c.g != 128) || (c.b != 128))
{
vec3F v(c.r, c.g, c.b);
v -= vec3F(128.0f);
v /= vec3F(127.0f);
//pixels.push_back(v);
v.clamp(-1.0f, 1.0f);
float norm = v.norm();
if ((norm < 0.83f) || (norm > 1.29f))
num_invalid_pixels++;
}
}
}
score -= math::clamp(float(num_invalid_pixels) / (img.get_width() * img.get_height()) - .026f, 0.0f, 1.0f) * 5.0f;
if (pFilename)
{
dynamic_string str(pFilename);
str.tolower();
if (str.contains("normal") || str.contains("local") || str.contains("nmap"))
score += 1.0f;
if (str.contains("diffuse") || str.contains("spec") || str.contains("gloss"))
score -= 1.0f;
}
return score >= 0.0f;
}
bool resample_single_thread(const image_u8& src, image_u8& dst, const resample_params& params)
{
const uint src_width = src.get_width();
const uint src_height = src.get_height();
if (math::maximum(src_width, src_height) > CRNLIB_RESAMPLER_MAX_DIMENSION)
{
printf("Image is too large!\n");
return EXIT_FAILURE;
}
const int cMaxComponents = 4;
if (((int)params.m_num_comps < 1) || ((int)params.m_num_comps > (int)cMaxComponents))
return false;
const uint dst_width = params.m_dst_width;
const uint dst_height = params.m_dst_height;
if ((math::minimum(dst_width, dst_height) < 1) || (math::maximum(dst_width, dst_height) > CRNLIB_RESAMPLER_MAX_DIMENSION))
{
printf("Image is too large!\n");
return EXIT_FAILURE;
}
if ((src_width == dst_width) && (src_height == dst_height))
{
dst = src;
return true;
}
dst.clear();
dst.resize(params.m_dst_width, params.m_dst_height);
// Partial gamma correction looks better on mips. Set to 1.0 to disable gamma correction.
const float source_gamma = params.m_source_gamma;//1.75f;
float srgb_to_linear[256];
if (params.m_srgb)
{
for (int i = 0; i < 256; ++i)
srgb_to_linear[i] = (float)pow(i * 1.0f/255.0f, source_gamma);
}
const int linear_to_srgb_table_size = 8192;
unsigned char linear_to_srgb[linear_to_srgb_table_size];
const float inv_linear_to_srgb_table_size = 1.0f / linear_to_srgb_table_size;
const float inv_source_gamma = 1.0f / source_gamma;
if (params.m_srgb)
{
for (int i = 0; i < linear_to_srgb_table_size; ++i)
{
int k = (int)(255.0f * pow(i * inv_linear_to_srgb_table_size, inv_source_gamma) + .5f);
if (k < 0) k = 0; else if (k > 255) k = 255;
linear_to_srgb[i] = (unsigned char)k;
}
}
Resampler* resamplers[cMaxComponents];
crnlib::vector<float> samples[cMaxComponents];
resamplers[0] = crnlib_new<Resampler>(src_width, src_height, dst_width, dst_height,
params.m_wrapping ? Resampler::BOUNDARY_WRAP : Resampler::BOUNDARY_CLAMP, 0.0f, 1.0f,
params.m_pFilter, (Resampler::Contrib_List*)NULL, (Resampler::Contrib_List*)NULL, params.m_filter_scale, params.m_filter_scale);
samples[0].resize(src_width);
for (uint i = 1; i < params.m_num_comps; i++)
{
resamplers[i] = crnlib_new<Resampler>(src_width, src_height, dst_width, dst_height,
params.m_wrapping ? Resampler::BOUNDARY_WRAP : Resampler::BOUNDARY_CLAMP, 0.0f, 1.0f,
params.m_pFilter, resamplers[0]->get_clist_x(), resamplers[0]->get_clist_y(), params.m_filter_scale, params.m_filter_scale);
samples[i].resize(src_width);
}
uint dst_y = 0;
for (uint src_y = 0; src_y < src_height; src_y++)
{
const color_quad_u8* pSrc = src.get_scanline(src_y);
for (uint x = 0; x < src_width; x++)
{
for (uint c = 0; c < params.m_num_comps; c++)
{
const uint comp_index = params.m_first_comp + c;
const uint8 v = (*pSrc)[comp_index];
if (!params.m_srgb || (comp_index == 3))
samples[c][x] = v * (1.0f/255.0f);
else
samples[c][x] = srgb_to_linear[v];
}
pSrc++;
}
for (uint c = 0; c < params.m_num_comps; c++)
{
if (!resamplers[c]->put_line(&samples[c][0]))
{
for (uint i = 0; i < params.m_num_comps; i++)
crnlib_delete(resamplers[i]);
return false;
}
}
for ( ; ; )
{
uint c;
for (c = 0; c < params.m_num_comps; c++)
{
const uint comp_index = params.m_first_comp + c;
const float* pOutput_samples = resamplers[c]->get_line();
if (!pOutput_samples)
break;
const bool linear = !params.m_srgb || (comp_index == 3);
CRNLIB_ASSERT(dst_y < dst_height);
color_quad_u8* pDst = dst.get_scanline(dst_y);
for (uint x = 0; x < dst_width; x++)
{
if (linear)
{
int c = (int)(255.0f * pOutput_samples[x] + .5f);
if (c < 0) c = 0; else if (c > 255) c = 255;
(*pDst)[comp_index] = (unsigned char)c;
}
else
{
int j = (int)(linear_to_srgb_table_size * pOutput_samples[x] + .5f);
if (j < 0) j = 0; else if (j >= linear_to_srgb_table_size) j = linear_to_srgb_table_size - 1;
(*pDst)[comp_index] = linear_to_srgb[j];
}
pDst++;
}
}
if (c < params.m_num_comps)
break;
dst_y++;
}
}
for (uint i = 0; i < params.m_num_comps; i++)
crnlib_delete(resamplers[i]);
return true;
}
bool resample_multithreaded(const image_u8& src, image_u8& dst, const resample_params& params)
{
const uint src_width = src.get_width();
const uint src_height = src.get_height();
if (math::maximum(src_width, src_height) > CRNLIB_RESAMPLER_MAX_DIMENSION)
{
printf("Image is too large!\n");
return EXIT_FAILURE;
}
const int cMaxComponents = 4;
if (((int)params.m_num_comps < 1) || ((int)params.m_num_comps > (int)cMaxComponents))
return false;
const uint dst_width = params.m_dst_width;
const uint dst_height = params.m_dst_height;
if ((math::minimum(dst_width, dst_height) < 1) || (math::maximum(dst_width, dst_height) > CRNLIB_RESAMPLER_MAX_DIMENSION))
{
printf("Image is too large!\n");
return EXIT_FAILURE;
}
if ((src_width == dst_width) && (src_height == dst_height))
{
dst = src;
return true;
}
dst.clear();
// Partial gamma correction looks better on mips. Set to 1.0 to disable gamma correction.
const float source_gamma = params.m_source_gamma;//1.75f;
float srgb_to_linear[256];
if (params.m_srgb)
{
for (int i = 0; i < 256; ++i)
srgb_to_linear[i] = (float)pow(i * 1.0f/255.0f, source_gamma);
}
const int linear_to_srgb_table_size = 8192;
unsigned char linear_to_srgb[linear_to_srgb_table_size];
const float inv_linear_to_srgb_table_size = 1.0f / linear_to_srgb_table_size;
const float inv_source_gamma = 1.0f / source_gamma;
if (params.m_srgb)
{
for (int i = 0; i < linear_to_srgb_table_size; ++i)
{
int k = (int)(255.0f * pow(i * inv_linear_to_srgb_table_size, inv_source_gamma) + .5f);
if (k < 0) k = 0; else if (k > 255) k = 255;
linear_to_srgb[i] = (unsigned char)k;
}
}
task_pool tp;
tp.init(g_number_of_processors - 1);
threaded_resampler resampler(tp);
threaded_resampler::params p;
p.m_src_width = src_width;
p.m_src_height = src_height;
p.m_dst_width = dst_width;
p.m_dst_height = dst_height;
p.m_sample_low = 0.0f;
p.m_sample_high = 1.0f;
p.m_boundary_op = params.m_wrapping ? Resampler::BOUNDARY_WRAP : Resampler::BOUNDARY_CLAMP;
p.m_Pfilter_name = params.m_pFilter;
p.m_filter_x_scale = params.m_filter_scale;
p.m_filter_y_scale = params.m_filter_scale;
uint resampler_comps = 4;
if (params.m_num_comps == 1)
{
p.m_fmt = threaded_resampler::cPF_Y_F32;
resampler_comps = 1;
}
else if (params.m_num_comps <= 3)
p.m_fmt = threaded_resampler::cPF_RGBX_F32;
else
p.m_fmt = threaded_resampler::cPF_RGBA_F32;
crnlib::vector<float> src_samples;
crnlib::vector<float> dst_samples;
if (!src_samples.try_resize(src_width * src_height * resampler_comps))
return false;
if (!dst_samples.try_resize(dst_width * dst_height * resampler_comps))
return false;
p.m_pSrc_pixels = src_samples.get_ptr();
p.m_src_pitch = src_width * resampler_comps * sizeof(float);
p.m_pDst_pixels = dst_samples.get_ptr();
p.m_dst_pitch = dst_width * resampler_comps * sizeof(float);
for (uint src_y = 0; src_y < src_height; src_y++)
{
const color_quad_u8* pSrc = src.get_scanline(src_y);
float* pDst = src_samples.get_ptr() + src_width * resampler_comps * src_y;
for (uint x = 0; x < src_width; x++)
{
for (uint c = 0; c < params.m_num_comps; c++)
{
const uint comp_index = params.m_first_comp + c;
const uint8 v = (*pSrc)[comp_index];
if (!params.m_srgb || (comp_index == 3))
pDst[c] = v * (1.0f/255.0f);
else
pDst[c] = srgb_to_linear[v];
}
pSrc++;
pDst += resampler_comps;
}
}
if (!resampler.resample(p))
return false;
src_samples.clear();
if (!dst.resize(params.m_dst_width, params.m_dst_height))
return false;
for (uint dst_y = 0; dst_y < dst_height; dst_y++)
{
const float* pSrc = dst_samples.get_ptr() + dst_width * resampler_comps * dst_y;
color_quad_u8* pDst = dst.get_scanline(dst_y);
for (uint x = 0; x < dst_width; x++)
{
color_quad_u8 dst(0, 0, 0, 255);
for (uint c = 0; c < params.m_num_comps; c++)
{
const uint comp_index = params.m_first_comp + c;
const float v = pSrc[c];
if ((!params.m_srgb) || (comp_index == 3))
{
int c = static_cast<int>(255.0f * v + .5f);
if (c < 0) c = 0; else if (c > 255) c = 255;
dst[comp_index] = (unsigned char)c;
}
else
{
int j = static_cast<int>(linear_to_srgb_table_size * v + .5f);
if (j < 0) j = 0; else if (j >= linear_to_srgb_table_size) j = linear_to_srgb_table_size - 1;
dst[comp_index] = linear_to_srgb[j];
}
}
*pDst++ = dst;
pSrc += resampler_comps;
}
}
return true;
}
bool resample(const image_u8& src, image_u8& dst, const resample_params& params)
{
if ((params.m_multithreaded) && (g_number_of_processors > 1))
return resample_multithreaded(src, dst, params);
else
return resample_single_thread(src, dst, params);
}
bool compute_delta(image_u8& dest, image_u8& a, image_u8& b, uint scale)
{
if ( (a.get_width() != b.get_width()) || (a.get_height() != b.get_height()) )
return false;
dest.resize(a.get_width(), b.get_height());
for (uint y = 0; y < a.get_height(); y++)
{
for (uint x = 0; x < a.get_width(); x++)
{
const color_quad_u8& ca = a(x, y);
const color_quad_u8& cb = b(x, y);
color_quad_u8 cd;
for (uint c = 0; c < 4; c++)
{
int d = (ca[c] - cb[c]) * scale + 128;
d = math::clamp(d, 0, 255);
cd[c] = static_cast<uint8>(d);
}
dest(x, y) = cd;
}
}
return true;
}
// FIXME: Totally hack-ass computation.
// Perhaps port http://www.lomont.org/Software/Misc/SSIM/SSIM.html?
double compute_block_ssim(uint t, const uint8* pX, const uint8* pY)
{
double ave_x = 0.0f;
double ave_y = 0.0f;
for (uint i = 0; i < t; i++)
{
ave_x += pX[i];
ave_y += pY[i];
}
ave_x /= t;
ave_y /= t;
double var_x = 0.0f;
double var_y = 0.0f;
for (uint i = 0; i < t; i++)
{
var_x += math::square(pX[i] - ave_x);
var_y += math::square(pY[i] - ave_y);
}
var_x = sqrt(var_x / (t - 1));
var_y = sqrt(var_y / (t - 1));
double covar_xy = 0.0f;
for (uint i = 0; i < t; i++)
covar_xy += (pX[i] - ave_x) * (pY[i] - ave_y);
covar_xy /= (t - 1);
const double c1 = 6.5025; //(255*.01)^2
const double c2 = 58.5225; //(255*.03)^2
double n = (2.0f * ave_x * ave_y + c1) * (2.0f * covar_xy + c2);
double d = (ave_x * ave_x + ave_y * ave_y + c1) * (var_x * var_x + var_y * var_y + c2);
return n / d;
}
double compute_ssim(const image_u8& a, const image_u8& b, int channel_index)
{
const uint N = 6;
uint8 sx[N*N], sy[N*N];
double total_ssim = 0.0f;
uint total_blocks = 0;
//image_u8 yimg((a.get_width() + N - 1) / N, (a.get_height() + N - 1) / N);
for (uint y = 0; y < a.get_height(); y += N)
{
for (uint x = 0; x < a.get_width(); x += N)
{
for (uint iy = 0; iy < N; iy++)
{
for (uint ix = 0; ix < N; ix++)
{
if (channel_index < 0)
sx[ix+iy*N] = (uint8)a.get_clamped(x+ix, y+iy).get_luma();
else
sx[ix+iy*N] = (uint8)a.get_clamped(x+ix, y+iy)[channel_index];
if (channel_index < 0)
sy[ix+iy*N] = (uint8)b.get_clamped(x+ix, y+iy).get_luma();
else
sy[ix+iy*N] = (uint8)b.get_clamped(x+ix, y+iy)[channel_index];
}
}
double ssim = compute_block_ssim(N*N, sx, sy);
total_ssim += ssim;
total_blocks++;
//uint ssim_c = (uint)math::clamp<double>(ssim * 127.0f + 128.0f, 0, 255);
//yimg(x / N, y / N).set(ssim_c, ssim_c, ssim_c, 255);
}
}
if (!total_blocks)
return 0.0f;
//save_to_file_stb_or_miniz("ssim.tga", yimg, cWriteFlagGrayscale);
return total_ssim / total_blocks;
}
void print_ssim(const image_u8& src_img, const image_u8& dst_img)
{
src_img;
dst_img;
//double y_ssim = compute_ssim(src_img, dst_img, -1);
//console::printf("Luma MSSIM: %f, Scaled: %f", y_ssim, (y_ssim - .8f) / .2f);
//double r_ssim = compute_ssim(src_img, dst_img, 0);
//console::printf(" R MSSIM: %f", r_ssim);
//double g_ssim = compute_ssim(src_img, dst_img, 1);
//console::printf(" G MSSIM: %f", g_ssim);
//double b_ssim = compute_ssim(src_img, dst_img, 2);
//console::printf(" B MSSIM: %f", b_ssim);
}
void error_metrics::print(const char* pName) const
{
if (mPeakSNR >= cInfinitePSNR)
console::printf("%s Error: Max: %3u, Mean: %3.3f, MSE: %3.3f, RMSE: %3.3f, PSNR: Infinite", pName, mMax, mMean, mMeanSquared, mRootMeanSquared);
else
console::printf("%s Error: Max: %3u, Mean: %3.3f, MSE: %3.3f, RMSE: %3.3f, PSNR: %3.3f", pName, mMax, mMean, mMeanSquared, mRootMeanSquared, mPeakSNR);
}
bool error_metrics::compute(const image_u8& a, const image_u8& b, uint first_channel, uint num_channels, bool average_component_error)
{
//if ( (!a.get_width()) || (!b.get_height()) || (a.get_width() != b.get_width()) || (a.get_height() != b.get_height()) )
// return false;
const uint width = math::minimum(a.get_width(), b.get_width());
const uint height = math::minimum(a.get_height(), b.get_height());
CRNLIB_ASSERT((first_channel < 4U) && (first_channel + num_channels <= 4U));
// Histogram approach due to Charles Bloom.
double hist[256];
utils::zero_object(hist);
for (uint y = 0; y < height; y++)
{
for (uint x = 0; x < width; x++)
{
const color_quad_u8& ca = a(x, y);
const color_quad_u8& cb = b(x, y);
if (!num_channels)
hist[labs(ca.get_luma() - cb.get_luma())]++;
else
{
for (uint c = 0; c < num_channels; c++)
hist[labs(ca[first_channel + c] - cb[first_channel + c])]++;
}
}
}
mMax = 0;
double sum = 0.0f, sum2 = 0.0f;
for (uint i = 0; i < 256; i++)
{
if (!hist[i])
continue;
mMax = math::maximum(mMax, i);
double x = i * hist[i];
sum += x;
sum2 += i * x;
}
// See http://bmrc.berkeley.edu/courseware/cs294/fall97/assignment/psnr.html
double total_values = width * height;
if (average_component_error)
total_values *= math::clamp<uint>(num_channels, 1, 4);
mMean = math::clamp<double>(sum / total_values, 0.0f, 255.0f);
mMeanSquared = math::clamp<double>(sum2 / total_values, 0.0f, 255.0f*255.0f);
mRootMeanSquared = sqrt(mMeanSquared);
if (!mRootMeanSquared)
mPeakSNR = cInfinitePSNR;
else
mPeakSNR = math::clamp<double>(log10(255.0f / mRootMeanSquared) * 20.0f, 0.0f, 500.0f);
return true;
}
void print_image_metrics(const image_u8& src_img, const image_u8& dst_img)
{
if ( (!src_img.get_width()) || (!dst_img.get_height()) || (src_img.get_width() != dst_img.get_width()) || (src_img.get_height() != dst_img.get_height()) )
console::printf("print_image_metrics: Image resolutions don't match exactly (%ux%u) vs. (%ux%u)", src_img.get_width(), src_img.get_height(), dst_img.get_width(), dst_img.get_height());
image_utils::error_metrics error_metrics;
if (src_img.has_rgb() || dst_img.has_rgb())
{
error_metrics.compute(src_img, dst_img, 0, 3, false);
error_metrics.print("RGB Total ");
error_metrics.compute(src_img, dst_img, 0, 3, true);
error_metrics.print("RGB Average");
error_metrics.compute(src_img, dst_img, 0, 0);
error_metrics.print("Luma ");
error_metrics.compute(src_img, dst_img, 0, 1);
error_metrics.print("Red ");
error_metrics.compute(src_img, dst_img, 1, 1);
error_metrics.print("Green ");
error_metrics.compute(src_img, dst_img, 2, 1);
error_metrics.print("Blue ");
}
if (src_img.has_alpha() || dst_img.has_alpha())
{
error_metrics.compute(src_img, dst_img, 3, 1);
error_metrics.print("Alpha ");
}
}
static uint8 regen_z(uint x, uint y)
{
float vx = math::clamp((x - 128.0f) * 1.0f/127.0f, -1.0f, 1.0f);
float vy = math::clamp((y - 128.0f) * 1.0f/127.0f, -1.0f, 1.0f);
float vz = sqrt(math::clamp(1.0f - vx * vx - vy * vy, 0.0f, 1.0f));
vz = vz * 127.0f + 128.0f;
if (vz < 128.0f)
vz -= .5f;
else
vz += .5f;
int ib = math::float_to_int(vz);
return static_cast<uint8>(math::clamp(ib, 0, 255));
}
void convert_image(image_u8& img, image_utils::conversion_type conv_type)
{
switch (conv_type)
{
case image_utils::cConversion_To_CCxY:
{
img.set_comp_flags(static_cast<pixel_format_helpers::component_flags>(pixel_format_helpers::cCompFlagRValid | pixel_format_helpers::cCompFlagGValid | pixel_format_helpers::cCompFlagAValid | pixel_format_helpers::cCompFlagLumaChroma));
break;
}
case image_utils::cConversion_From_CCxY:
{
img.set_comp_flags(static_cast<pixel_format_helpers::component_flags>(pixel_format_helpers::cCompFlagRValid | pixel_format_helpers::cCompFlagGValid | pixel_format_helpers::cCompFlagBValid));
break;
}
case image_utils::cConversion_To_xGxR:
{
img.set_comp_flags(static_cast<pixel_format_helpers::component_flags>(pixel_format_helpers::cCompFlagGValid | pixel_format_helpers::cCompFlagAValid | pixel_format_helpers::cCompFlagNormalMap));
break;
}
case image_utils::cConversion_From_xGxR:
{
img.set_comp_flags(static_cast<pixel_format_helpers::component_flags>(pixel_format_helpers::cCompFlagRValid | pixel_format_helpers::cCompFlagGValid | pixel_format_helpers::cCompFlagBValid | pixel_format_helpers::cCompFlagNormalMap));
break;
}
case image_utils::cConversion_To_xGBR:
{
img.set_comp_flags(static_cast<pixel_format_helpers::component_flags>(pixel_format_helpers::cCompFlagGValid | pixel_format_helpers::cCompFlagBValid | pixel_format_helpers::cCompFlagAValid | pixel_format_helpers::cCompFlagNormalMap));
break;
}
case image_utils::cConversion_To_AGBR:
{
img.set_comp_flags(static_cast<pixel_format_helpers::component_flags>(pixel_format_helpers::cCompFlagRValid | pixel_format_helpers::cCompFlagGValid | pixel_format_helpers::cCompFlagBValid | pixel_format_helpers::cCompFlagAValid | pixel_format_helpers::cCompFlagNormalMap));
break;
}
case image_utils::cConversion_From_xGBR:
{
img.set_comp_flags(static_cast<pixel_format_helpers::component_flags>(pixel_format_helpers::cCompFlagRValid | pixel_format_helpers::cCompFlagGValid | pixel_format_helpers::cCompFlagBValid | pixel_format_helpers::cCompFlagNormalMap));
break;
}
case image_utils::cConversion_From_AGBR:
{
img.set_comp_flags(static_cast<pixel_format_helpers::component_flags>(pixel_format_helpers::cCompFlagRValid | pixel_format_helpers::cCompFlagGValid | pixel_format_helpers::cCompFlagBValid | pixel_format_helpers::cCompFlagAValid | pixel_format_helpers::cCompFlagNormalMap));
break;
}
case image_utils::cConversion_XY_to_XYZ:
{
img.set_comp_flags(static_cast<pixel_format_helpers::component_flags>(pixel_format_helpers::cCompFlagRValid | pixel_format_helpers::cCompFlagGValid | pixel_format_helpers::cCompFlagBValid | pixel_format_helpers::cCompFlagNormalMap));
break;
}
case cConversion_Y_To_A:
{
img.set_comp_flags(static_cast<pixel_format_helpers::component_flags>(img.get_comp_flags() | pixel_format_helpers::cCompFlagAValid));
break;
}
case cConversion_A_To_RGBA:
{
img.set_comp_flags(static_cast<pixel_format_helpers::component_flags>(pixel_format_helpers::cCompFlagRValid | pixel_format_helpers::cCompFlagGValid | pixel_format_helpers::cCompFlagBValid | pixel_format_helpers::cCompFlagAValid));
break;
}
case cConversion_Y_To_RGB:
{
img.set_comp_flags(static_cast<pixel_format_helpers::component_flags>(pixel_format_helpers::cCompFlagRValid | pixel_format_helpers::cCompFlagGValid | pixel_format_helpers::cCompFlagBValid | pixel_format_helpers::cCompFlagGrayscale | (img.has_alpha() ? pixel_format_helpers::cCompFlagAValid : 0)));
break;
}
case cConversion_To_Y:
{
img.set_comp_flags(static_cast<pixel_format_helpers::component_flags>(img.get_comp_flags() | pixel_format_helpers::cCompFlagGrayscale));
break;
}
default:
{
CRNLIB_ASSERT(false);
return;
}
}
for (uint y = 0; y < img.get_height(); y++)
{
for (uint x = 0; x < img.get_width(); x++)
{
color_quad_u8 src(img(x, y));
color_quad_u8 dst;
switch (conv_type)
{
case image_utils::cConversion_To_CCxY:
{
color::RGB_to_YCC(dst, src);
break;
}
case image_utils::cConversion_From_CCxY:
{
color::YCC_to_RGB(dst, src);
break;
}
case image_utils::cConversion_To_xGxR:
{
dst.r = 0;
dst.g = src.g;
dst.b = 0;
dst.a = src.r;
break;
}
case image_utils::cConversion_From_xGxR:
{
dst.r = src.a;
dst.g = src.g;
// This is kinda iffy, we're assuming the image is a normal map here.
dst.b = regen_z(src.a, src.g);
dst.a = 255;
break;
}
case image_utils::cConversion_To_xGBR:
{
dst.r = 0;
dst.g = src.g;
dst.b = src.b;
dst.a = src.r;
break;
}
case image_utils::cConversion_To_AGBR:
{
dst.r = src.a;
dst.g = src.g;
dst.b = src.b;
dst.a = src.r;
break;
}
case image_utils::cConversion_From_xGBR:
{
dst.r = src.a;
dst.g = src.g;
dst.b = src.b;
dst.a = 255;
break;
}
case image_utils::cConversion_From_AGBR:
{
dst.r = src.a;
dst.g = src.g;
dst.b = src.b;
dst.a = src.r;
break;
}
case image_utils::cConversion_XY_to_XYZ:
{
dst.r = src.r;
dst.g = src.g;
// This is kinda iffy, we're assuming the image is a normal map here.
dst.b = regen_z(src.r, src.g);
dst.a = 255;
break;
}
case image_utils::cConversion_Y_To_A:
{
dst.r = src.r;
dst.g = src.g;
dst.b = src.b;
dst.a = static_cast<uint8>(src.get_luma());
break;
}
case image_utils::cConversion_Y_To_RGB:
{
uint8 y = static_cast<uint8>(src.get_luma());
dst.r = y;
dst.g = y;
dst.b = y;
dst.a = src.a;
break;
}
case image_utils::cConversion_A_To_RGBA:
{
dst.r = src.a;
dst.g = src.a;
dst.b = src.a;
dst.a = src.a;
break;
}
case image_utils::cConversion_To_Y:
{
uint8 y = static_cast<uint8>(src.get_luma());
dst.r = y;
dst.g = y;
dst.b = y;
dst.a = src.a;
break;
}
default:
{
CRNLIB_ASSERT(false);
dst = src;
break;
}
}
img(x, y) = dst;
}
}
}
image_utils::conversion_type get_conversion_type(bool cooking, pixel_format fmt)
{
image_utils::conversion_type conv_type = image_utils::cConversion_Invalid;
if (cooking)
{
switch (fmt)
{
case PIXEL_FMT_DXT5_CCxY:
{
conv_type = image_utils::cConversion_To_CCxY;
break;
}
case PIXEL_FMT_DXT5_xGxR:
{
conv_type = image_utils::cConversion_To_xGxR;
break;
}
case PIXEL_FMT_DXT5_xGBR:
{
conv_type = image_utils::cConversion_To_xGBR;
break;
}
case PIXEL_FMT_DXT5_AGBR:
{
conv_type = image_utils::cConversion_To_AGBR;
break;
}
default: break;
}
}
else
{
switch (fmt)
{
case PIXEL_FMT_3DC:
case PIXEL_FMT_DXN:
{
conv_type = image_utils::cConversion_XY_to_XYZ;
break;
}
case PIXEL_FMT_DXT5_CCxY:
{
conv_type = image_utils::cConversion_From_CCxY;
break;
}
case PIXEL_FMT_DXT5_xGxR:
{
conv_type = image_utils::cConversion_From_xGxR;
break;
}
case PIXEL_FMT_DXT5_xGBR:
{
conv_type = image_utils::cConversion_From_xGBR;
break;
}
case PIXEL_FMT_DXT5_AGBR:
{
conv_type = image_utils::cConversion_From_AGBR;
break;
}
default: break;
}
}
return conv_type;
}
image_utils::conversion_type get_image_conversion_type_from_crn_format(crn_format fmt)
{
switch (fmt)
{
case cCRNFmtDXT5_CCxY: return image_utils::cConversion_To_CCxY;
case cCRNFmtDXT5_xGxR: return image_utils::cConversion_To_xGxR;
case cCRNFmtDXT5_xGBR: return image_utils::cConversion_To_xGBR;
case cCRNFmtDXT5_AGBR: return image_utils::cConversion_To_AGBR;
default: break;
}
return image_utils::cConversion_Invalid;
}
double compute_std_dev(uint n, const color_quad_u8* pPixels, uint first_channel, uint num_channels)
{
if (!n)
return 0.0f;
double sum = 0.0f;
double sum2 = 0.0f;
for (uint i = 0; i < n; i++)
{
const color_quad_u8& cp = pPixels[i];
if (!num_channels)
{
uint l = cp.get_luma();
sum += l;
sum2 += l*l;
}
else
{
for (uint c = 0; c < num_channels; c++)
{
uint l = cp[first_channel + c];
sum += l;
sum2 += l*l;
}
}
}
double w = math::maximum(1U, num_channels) * n;
sum /= w;
sum2 /= w;
double var = sum2 - sum * sum;
var = math::maximum<double>(var, 0.0f);
return sqrt(var);
}
uint8* read_image_from_memory(const uint8* pImage, int nSize, int* pWidth, int* pHeight, int* pActualComps, int req_comps, const char* pFilename)
{
*pWidth = 0;
*pHeight = 0;
*pActualComps = 0;
if ((req_comps < 1) || (req_comps > 4))
return false;
mipmapped_texture tex;
buffer_stream buf_stream(pImage, nSize);
buf_stream.set_name(pFilename);
data_stream_serializer serializer(buf_stream);
if (!tex.read_from_stream(serializer))
return NULL;
if (tex.is_packed())
{
if (!tex.unpack_from_dxt(true))
return NULL;
}
image_u8 img;
image_u8* pImg = tex.get_level_image(0, 0, img);
if (!pImg)
return NULL;
*pWidth = tex.get_width();
*pHeight = tex.get_height();
if (pImg->has_alpha())
*pActualComps = 4;
else if (pImg->is_grayscale())
*pActualComps = 1;
else
*pActualComps = 3;
uint8 *pDst = NULL;
if (req_comps == 4)
{
pDst = (uint8*)malloc(tex.get_total_pixels() * sizeof(uint32));
uint8 *pSrc = (uint8*)pImg->get_ptr();
memcpy(pDst, pSrc, tex.get_total_pixels() * sizeof(uint32));
}
else
{
image_u8 luma_img;
if (req_comps == 1)
{
luma_img = *pImg;
luma_img.convert_to_grayscale();
pImg = &luma_img;
}
pixel_packer packer(req_comps, 8);
uint32 n;
pDst = image_utils::pack_image(*pImg, packer, n);
}
return pDst;
}
} // namespace image_utils
} // namespace crnlib