You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
248 lines
13 KiB
248 lines
13 KiB
#ifndef IMG_CS_BASE_H_ |
|
#define IMG_CS_BASE_H_ |
|
|
|
// warning: temporary name/location, will change in near future |
|
|
|
#include "img/img.h" |
|
|
|
namespace img { |
|
|
|
// RGB: GAMMA -> LINEAR |
|
template<int Channels, typename ScalarType1, bool Safe1,typename ScalarType2, bool Safe2> |
|
inline void convert_gamma_precompensated_rgb_to_linear_rgb(const img::Image<Channels,ScalarType1,Safe1> &gamma_precompensated_rgb_image, img::Image<Channels,ScalarType2,Safe2> &linear_rgb_image) |
|
{ |
|
assert(gamma_precompensated_rgb_image.isValid()); |
|
assert(!gamma_precompensated_rgb_image.attributes.hasColorspace(SRGB)); |
|
assert(gamma_precompensated_rgb_image.attributes.hasRange(0.0,1.0)); |
|
ScalarType2 old_gamma; |
|
gamma_precompensated_rgb_image.attributes.getGamma(old_gamma); |
|
assert((old_gamma>0.0)&&(old_gamma<1.0)); |
|
if(Safe1 || Safe2){ |
|
if(!gamma_precompensated_rgb_image.isValid()) throw ImageException("Invalid rgb image"); |
|
if(gamma_precompensated_rgb_image.attributes.hasColorspace(SRGB)) throw ImageException("Invalid colorspace attribute"); |
|
if(!gamma_precompensated_rgb_image.attributes.hasRange(0,1)) throw ImageException("Invalid range attribute"); |
|
if(!((old_gamma>0.0)&&(old_gamma<1.0))) throw ImageException("Invalid gamma attribute"); |
|
} |
|
linear_rgb_image.setZero(gamma_precompensated_rgb_image.width(),gamma_precompensated_rgb_image.height()); |
|
linear_rgb_image.attributes=gamma_precompensated_rgb_image.attributes; |
|
|
|
for(int channel=0; channel<Channels; ++channel) |
|
for(int x_coord=0; x_coord<gamma_precompensated_rgb_image.width(); ++x_coord) |
|
for(int y_coord=0; y_coord<gamma_precompensated_rgb_image.height(); ++y_coord){ |
|
linear_rgb_image.setValue(x_coord,y_coord,channel, pow(ScalarType2(gamma_precompensated_rgb_image.getValue(x_coord,y_coord,channel)),ScalarType2(1.0)/old_gamma)); |
|
} |
|
linear_rgb_image.attributes.setGamma(ScalarType2(1.0)); |
|
} |
|
|
|
// RGB: LINEAR -> GAMMA |
|
// when converting from linear to gamma precompensated the gamma parameter mus be in range (0.0,1.0) |
|
template<int Channels, typename ScalarType1, bool Safe1,typename ScalarType2, bool Safe2> |
|
inline void convert_linear_rgb_to_gamma_precompensated_rgb(const img::Image<Channels,ScalarType1,Safe1> &linear_rgb_image, img::Image<Channels,ScalarType2,Safe2> &gamma_precompensated_rgb_image, ScalarType2 gamma=ScalarType2(1.0/2.2)) |
|
{ |
|
assert(linear_rgb_image.isValid()); |
|
assert(!linear_rgb_image.attributes.hasColorspace(SRGB)); |
|
assert(linear_rgb_image.attributes.hasRange(0.0,1.0)); |
|
assert(linear_rgb_image.attributes.hasGamma(1.0)); |
|
assert((gamma>0.0)&&(gamma<1.0)); |
|
if(Safe1 || Safe2){ |
|
if(!linear_rgb_image.isValid()) throw img::ImageException("Invalid rgb image"); |
|
if(linear_rgb_image.attributes.hasColorspace(SRGB)) throw ImageException("Invalid colorspace attribute"); |
|
if(!linear_rgb_image.attributes.hasRange(0.0,1.0)) throw ImageException("Invalid range attribute"); |
|
if(!linear_rgb_image.attributes.hasGamma(1.0)) throw ImageException("Invalid gamma attribute"); |
|
if(!((gamma>0.0)&&(gamma<1.0))) throw ImageException("Invalid gamma parameter"); |
|
} |
|
gamma_precompensated_rgb_image.setZero(linear_rgb_image.width(),linear_rgb_image.height()); |
|
gamma_precompensated_rgb_image.attributes=linear_rgb_image.attributes; |
|
|
|
for(int channel=0; channel<Channels; ++channel) |
|
for(int x_coord=0; x_coord<linear_rgb_image.width(); ++x_coord) |
|
for(int y_coord=0; y_coord<linear_rgb_image.height(); ++y_coord){ |
|
gamma_precompensated_rgb_image.setValue(x_coord,y_coord,channel, pow(ScalarType2(linear_rgb_image.getValue(x_coord,y_coord,channel)),gamma)); |
|
} |
|
gamma_precompensated_rgb_image.attributes.setGamma(gamma); |
|
} |
|
|
|
// SRGB: GAMMA -> LINEAR |
|
template<int Channels, typename ScalarType1, bool Safe1,typename ScalarType2, bool Safe2> |
|
inline void convert_gamma_precompensated_srgb_to_linear_srgb(const img::Image<Channels,ScalarType1,Safe1> &gamma_precompensated_srgb_image, img::Image<Channels,ScalarType2,Safe2> &linear_srgb_image) |
|
{ |
|
assert(gamma_precompensated_srgb_image.isValid()); |
|
assert(gamma_precompensated_srgb_image.attributes.hasColorspace(SRGB)); |
|
assert(gamma_precompensated_srgb_image.attributes.hasRange(0.0,1.0)); |
|
assert(!gamma_precompensated_srgb_image.attributes.hasGamma(1.0)); |
|
if(Safe1 || Safe2){ |
|
if(!gamma_precompensated_srgb_image.isValid()) throw ImageException("Invalid rgb image"); |
|
if(!gamma_precompensated_srgb_image.attributes.hasColorspace(SRGB)) throw ImageException("Invalid colorspace attribute"); |
|
if(!gamma_precompensated_srgb_image.attributes.hasRange(0,1)) throw ImageException("Invalid range attribute"); |
|
if(gamma_precompensated_srgb_image.attributes.hasGamma(1.0)) throw ImageException("Invalid gamma attribute"); |
|
} |
|
linear_srgb_image.setZero(gamma_precompensated_srgb_image.width(),gamma_precompensated_srgb_image.height()); |
|
linear_srgb_image.attributes=gamma_precompensated_srgb_image.attributes; |
|
|
|
for(int channel=0; channel<Channels; ++channel) |
|
for(int x_coord=0; x_coord<gamma_precompensated_srgb_image.width(); ++x_coord) |
|
for(int y_coord=0; y_coord<gamma_precompensated_srgb_image.height(); ++y_coord){ |
|
ScalarType2 value = ScalarType2(gamma_precompensated_srgb_image.getValue(x_coord,y_coord,channel)); |
|
if(value<=ScalarType2(0.04045)) |
|
value = value / ScalarType2(12.92); |
|
else |
|
value = pow( (value+ScalarType2(0.055)) / ScalarType2(1.055), ScalarType2(2.4) ); |
|
linear_srgb_image.setValue(x_coord, y_coord, channel, value); |
|
} |
|
linear_srgb_image.attributes.setGamma(ScalarType2(1.0)); |
|
} |
|
|
|
// SRGB: LINEAR -> GAMMA |
|
template<int Channels, typename ScalarType1, bool Safe1,typename ScalarType2, bool Safe2> |
|
inline void convert_linear_srgb_to_gamma_precompensated_srgb(const img::Image<Channels,ScalarType1,Safe1> &linear_srgb_image, img::Image<Channels,ScalarType2,Safe2> &gamma_precompensated_srgb_image) |
|
{ |
|
assert(linear_srgb_image.isValid()); |
|
assert(linear_srgb_image.attributes.hasColorspace(SRGB)); |
|
assert(linear_srgb_image.attributes.hasRange(0.0,1.0)); |
|
assert(linear_srgb_image.attributes.hasGamma(1.0)); |
|
if(Safe1 || Safe2){ |
|
if(!linear_srgb_image.isValid()) throw img::ImageException("Invalid rgb image"); |
|
if(!linear_srgb_image.attributes.hasColorspace(SRGB)) throw ImageException("Invalid colorspace attribute"); |
|
if(!linear_srgb_image.attributes.hasRange(0.0,1.0)) throw ImageException("Invalid range attribute"); |
|
if(!linear_srgb_image.attributes.hasGamma(1.0)) throw ImageException("Invalid gamma attribute"); |
|
} |
|
gamma_precompensated_srgb_image.setZero(linear_srgb_image.width(),linear_srgb_image.height()); |
|
gamma_precompensated_srgb_image.attributes=linear_srgb_image.attributes; |
|
|
|
for(int channel=0; channel<Channels; ++channel) |
|
for(int x_coord=0; x_coord<linear_srgb_image.width(); ++x_coord) |
|
for(int y_coord=0; y_coord<linear_srgb_image.height(); ++y_coord){ |
|
ScalarType2 value = ScalarType2(linear_srgb_image.getValue(x_coord,y_coord,channel)); |
|
if(value<=ScalarType2(0.0031308)) |
|
value = value * ScalarType2(12.92); |
|
else |
|
value = (ScalarType2(1.055) * pow(value, ScalarType2(1.0/2.4))) - ScalarType2(0.055); |
|
gamma_precompensated_srgb_image.setValue(x_coord, y_coord, channel, value); |
|
} |
|
gamma_precompensated_srgb_image.attributes.setGamma(ScalarType2(2.2)); // approssimation |
|
} |
|
|
|
// SRGB -> XYZ |
|
template<typename ScalarType1, bool Safe1,typename ScalarType2, bool Safe2> |
|
inline void convert_srgb_to_xyz(const img::Image<3,ScalarType1,Safe1> &rgb_image, img::Image<3,ScalarType2,Safe2> &xyz_image) |
|
{ |
|
assert( rgb_image.isValid()); |
|
assert( rgb_image.attributes.hasRange(0.0,1.0)); |
|
assert( rgb_image.attributes.hasGamma(1.0)); |
|
assert( rgb_image.attributes.hasColorspace(img::RGB) ); |
|
if(Safe1 || Safe2){ |
|
if(!rgb_image.isValid()) throw img::ImageException("Invalid rgb image"); |
|
if(!rgb_image.attributes.hasRange(0.0,1.0)) throw img::ImageException("Invalid range attribute"); |
|
if(!rgb_image.attributes.hasGamma(1.0)) throw img::ImageException("Invalid gamma attribute"); |
|
if(!rgb_image.attributes.hasColorspace(img::RGB)) throw img::ImageException("Invalid colorspace attribute"); |
|
} |
|
xyz_image.setZero(rgb_image.width(),rgb_image.height()); |
|
xyz_image.attributes=rgb_image.attributes; |
|
|
|
for(int x_coord=0; x_coord<rgb_image.width(); ++x_coord) |
|
for(int y_coord=0; y_coord<rgb_image.height(); ++y_coord){ |
|
const ScalarType2 R = static_cast<ScalarType2>(rgb_image.getValue(x_coord,y_coord,0)); |
|
const ScalarType2 G = static_cast<ScalarType2>(rgb_image.getValue(x_coord,y_coord,1)); |
|
const ScalarType2 B = static_cast<ScalarType2>(rgb_image.getValue(x_coord,y_coord,2)); |
|
|
|
xyz_image.setValue(x_coord,y_coord,0, ( 0.412453f*R + 0.357580f*G + 0.180423f*B ) ); |
|
xyz_image.setValue(x_coord,y_coord,1, ( 0.212671f*R + 0.715160f*G + 0.072169f*B ) ); |
|
xyz_image.setValue(x_coord,y_coord,2, ( 0.019334f*R + 0.119193f*G + 0.950227f*B ) ); |
|
} |
|
xyz_image.setColorspace(img::CIE_XYZ); |
|
} |
|
|
|
// XYZ -> SRGB |
|
template<typename ScalarType1, bool Safe1,typename ScalarType2, bool Safe2> |
|
inline void convert_xyz_to_rgb(const img::Image<3,ScalarType1,Safe1> &xyz_image, img::Image<3,ScalarType2,Safe2> &rgb_image) |
|
{ |
|
assert( xyz_image.isValid()); |
|
assert( xyz_image.attributes.hasRange(0.0,1.0)); |
|
assert( xyz_image.attributes.hasGamma(1.0)); |
|
assert( xyz_image.attributes.hasColorspace(img::CIE_XYZ) ); |
|
|
|
if(Safe1 || Safe2){ |
|
if(!xyz_image.isValid()) throw img::ImageException("Invalid xyz image"); |
|
if(!xyz_image.attributes.hasRange(0.0,1.0)) throw img::ImageException("Invalid range attribute"); |
|
if(!xyz_image.attributes.hasGamma(1.0)) throw img::ImageException("Invalid gamma attribute"); |
|
if(!rgb_image.attributes.hasColorspace(img::CIE_XYZ)) throw img::ImageException("Invalid colorspace attribute"); |
|
} |
|
rgb_image.setZero(xyz_image.width(),xyz_image.height()); |
|
rgb_image.attributes=xyz_image.attributes; |
|
|
|
for(int x=0; x<xyz_image.width(); ++x) |
|
for(int y=0; y<xyz_image.height(); ++y){ |
|
const ScalarType2 X = static_cast<ScalarType2>(xyz_image.getValue(x,y,0)); |
|
const ScalarType2 Y = static_cast<ScalarType2>(xyz_image.getValue(x,y,1)); |
|
const ScalarType2 Z = static_cast<ScalarType2>(xyz_image.getValue(x,y,2)); |
|
|
|
const ScalarType2 R = 3.240479f*X + -1.537150f*Y + -0.498535f*Z; |
|
const ScalarType2 G = -0.969256f*X + 1.875992f*Y + 0.041556f*Z; |
|
const ScalarType2 B = 0.055648f*X + -0.204043f*Y + 1.057311f*Z; |
|
|
|
rgb_image.setValue(x,y,0, ( R<0.0f?0.0f:(R>1.0f?1.0f:R) ) ); |
|
rgb_image.setValue(x,y,1, ( G<0.0f?0.0f:(G>1.0f?1.0f:G) ) ); |
|
rgb_image.setValue(x,y,2, ( B<0.0f?0.0f:(B>1.0f?1.0f:B) ) ); |
|
} |
|
rgb_image.setColorspace(img::RGB); |
|
} |
|
|
|
///ora nn ho tempo: |
|
//// AltriRGB -> XYZ |
|
//// XYZ -> AltriRGB |
|
//// XYZ -> LAB |
|
//// LAB -> XYZ |
|
//template<typename ScalarType1, bool Safe1,typename ScalarType2, bool Safe2> |
|
//inline void convert_xyz_to_lab(const img::Image<3,ScalarType1,Safe1> &xyz_image, img::Image<3,ScalarType2,Safe2> &lab_image) |
|
//{ |
|
// assert(xyz_image.isValid()); |
|
// if(Safe1 || Safe2){ |
|
// if(!xyz_image.isValid()) throw img::ImageException("Invalid xyz image"); |
|
// } |
|
// lab_image.setZero(xyz_image.width(),xyz_image.height()); |
|
// |
|
// const ScalarType2 one_third=0.33333333333333333333333333333333333333333333333333333333333333f; |
|
// const ScalarType2 Xn = 0.9513f; |
|
// const ScalarType2 Yn = 1.000f; |
|
// const ScalarType2 Zn = 1.0886f; |
|
// |
|
// for(int x=0; x<xyz_image.width(); ++x) |
|
// for(int y=0; y<xyz_image.height(); ++y){ |
|
// const ScalarType2 X_third = pow(static_cast<ScalarType2>(xyz_image.getValue(x,y,0))/Xn,one_third); |
|
// const ScalarType2 Y = static_cast<ScalarType2>(xyz_image.getValue(x,y,1))/Yn; |
|
// const ScalarType2 Y_third = pow(Y,one_third); |
|
// const ScalarType2 Z_third = pow(static_cast<ScalarType2>(xyz_image.getValue(x,y,2))/Zn,one_third); |
|
// |
|
// lab_image.setValue(x,y,0, (Y > 0.008856f)?((116.0f*(Y_third)) - 16.0f):(903.3f*Y) ); |
|
// lab_image.setValue(x,y,1, 500.0f * ((X_third) - (Y_third)) ); |
|
// lab_image.setValue(x,y,2, 200.0f * ((Y_third) - (Z_third)) ); |
|
// } |
|
//} |
|
// |
|
//template<typename ScalarType1, bool Safe1,typename ScalarType2, bool Safe2> |
|
//inline void convert_lab_to_xyz(const img::Image<3,ScalarType1,Safe1> &lab_image, img::Image<3,ScalarType2,Safe2> &xyz_image) |
|
//{ |
|
// assert(0); // sistemare attributi |
|
// assert(lab_image.isValid()); |
|
// if(Safe1 || Safe2){ |
|
// if(!lab_image.isValid()) throw img::ImageException("Invalid lab image"); |
|
// } |
|
// xyz_image.setZero(lab_image.width(),lab_image.height()); |
|
// |
|
// const ScalarType2 Xn = 0.9513f; |
|
// const ScalarType2 Yn = 1.000f; |
|
// const ScalarType2 Zn = 1.0886f; |
|
// |
|
// for(int x=0; x<lab_image.width(); ++x) |
|
// for(int y=0; y<lab_image.height(); ++y){ |
|
// const ScalarType2 P = (static_cast<ScalarType2>(lab_image.getValue(x,y,0))+16.0f)/116.0f; |
|
// |
|
// xyz_image.setValue(x,y,0, Xn * pow(P + (lab_image.getValue(x,y,1)/500.0f), 3.0f) ); |
|
// xyz_image.setValue(x,y,1, Yn * pow(P, 3.0f) ); |
|
// xyz_image.setValue(x,y,2, Zn * pow(P - (lab_image.getValue(x,y,2)/200.0f), 3.0f) ); |
|
// } |
|
//} |
|
|
|
} // end namespace img |
|
|
|
#endif /*IMG_CS_BASE_H_*/
|
|
|