Merge trunk fixes to 2.0 branch. Get things ready for 2.0.2 release.
This commit is contained in:
parent
46334cb96a
commit
07df6e7539
|
@ -3,6 +3,7 @@ NVIDIA Texture Tools version 2.0.2
|
||||||
* Fix indexMirror error reported by Chris Lambert.
|
* Fix indexMirror error reported by Chris Lambert.
|
||||||
* Fix vc8 post build command, reported by Richard Sim.
|
* Fix vc8 post build command, reported by Richard Sim.
|
||||||
* Fix RGBA modes with less than 32 bpp by Viktor Linder.
|
* Fix RGBA modes with less than 32 bpp by Viktor Linder.
|
||||||
|
* Fix alpha decompression by amorilia. See issue 40.
|
||||||
|
|
||||||
NVIDIA Texture Tools version 2.0.1
|
NVIDIA Texture Tools version 2.0.1
|
||||||
* Fix memory leaks.
|
* Fix memory leaks.
|
||||||
|
|
|
@ -307,15 +307,6 @@ void ColorBlock::boundsRangeAlpha(Color32 * start, Color32 * end) const
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void ColorBlock::bestFitRange(Color32 * start, Color32 * end) const
|
|
||||||
{
|
|
||||||
nvDebugCheck(start != NULL);
|
|
||||||
nvDebugCheck(end != NULL);
|
|
||||||
|
|
||||||
Vector3 axis = bestFitLine().direction();
|
|
||||||
computeRange(axis, start, end);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sort colors by abosolute value in their 16 bit representation.
|
/// Sort colors by abosolute value in their 16 bit representation.
|
||||||
void ColorBlock::sortColorsByAbsoluteValue()
|
void ColorBlock::sortColorsByAbsoluteValue()
|
||||||
{
|
{
|
||||||
|
@ -393,19 +384,6 @@ void ColorBlock::sortColors(const Vector3 & axis)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
/// Get least squares line that best approxiamtes the points of the color block.
|
|
||||||
Line3 ColorBlock::bestFitLine() const
|
|
||||||
{
|
|
||||||
Array<Vector3> pointArray(16);
|
|
||||||
|
|
||||||
for(int i = 0; i < 16; i++) {
|
|
||||||
pointArray.append(Vector3(m_color[i].r, m_color[i].g, m_color[i].b));
|
|
||||||
}
|
|
||||||
|
|
||||||
return Fit::bestLine(pointArray);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/// Get the volume of the color block.
|
/// Get the volume of the color block.
|
||||||
float ColorBlock::volume() const
|
float ColorBlock::volume() const
|
||||||
{
|
{
|
||||||
|
|
|
@ -4,7 +4,6 @@
|
||||||
#define NV_IMAGE_COLORBLOCK_H
|
#define NV_IMAGE_COLORBLOCK_H
|
||||||
|
|
||||||
#include <nvmath/Color.h>
|
#include <nvmath/Color.h>
|
||||||
#include <nvmath/Fitting.h> // Line3
|
|
||||||
|
|
||||||
namespace nv
|
namespace nv
|
||||||
{
|
{
|
||||||
|
@ -33,16 +32,13 @@ namespace nv
|
||||||
void luminanceRange(Color32 * start, Color32 * end) const;
|
void luminanceRange(Color32 * start, Color32 * end) const;
|
||||||
void boundsRange(Color32 * start, Color32 * end) const;
|
void boundsRange(Color32 * start, Color32 * end) const;
|
||||||
void boundsRangeAlpha(Color32 * start, Color32 * end) const;
|
void boundsRangeAlpha(Color32 * start, Color32 * end) const;
|
||||||
void bestFitRange(Color32 * start, Color32 * end) const;
|
|
||||||
|
|
||||||
void sortColorsByAbsoluteValue();
|
void sortColorsByAbsoluteValue();
|
||||||
|
|
||||||
void computeRange(const Vector3 & axis, Color32 * start, Color32 * end) const;
|
void computeRange(const Vector3 & axis, Color32 * start, Color32 * end) const;
|
||||||
void sortColors(const Vector3 & axis);
|
void sortColors(const Vector3 & axis);
|
||||||
|
|
||||||
Line3 bestFitLine() const;
|
|
||||||
float volume() const;
|
float volume() const;
|
||||||
Line3 diameterLine() const;
|
|
||||||
|
|
||||||
// Accessors
|
// Accessors
|
||||||
const Color32 * colors() const;
|
const Color32 * colors() const;
|
||||||
|
|
|
@ -296,7 +296,7 @@ static bool downsample(const FloatImage * src, const BitMap * srcMask, const Flo
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
// This is the filter used in the Lumigraph paper. The Unreal engine uses something similar.
|
// This is the filter used in the Lumigraph paper.
|
||||||
void nv::fillPullPush(FloatImage * img, const BitMap * bmap)
|
void nv::fillPullPush(FloatImage * img, const BitMap * bmap)
|
||||||
{
|
{
|
||||||
nvCheck(img != NULL);
|
nvCheck(img != NULL);
|
||||||
|
@ -644,8 +644,8 @@ struct LocalPixels
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
// This is a cubic extrapolation filter from Charles Bloom (DoPixelSeamFix).
|
// This is a quadratic extrapolation filter from Charles Bloom (DoPixelSeamFix). Used with his permission.
|
||||||
void nv::fillCubicExtrapolate(int passCount, FloatImage * img, BitMap * bmap, int coverageIndex /*= -1*/)
|
void nv::fillQuadraticExtrapolate(int passCount, FloatImage * img, BitMap * bmap, int coverageIndex /*= -1*/)
|
||||||
{
|
{
|
||||||
nvCheck(passCount > 0);
|
nvCheck(passCount > 0);
|
||||||
nvCheck(img != NULL);
|
nvCheck(img != NULL);
|
||||||
|
|
|
@ -89,7 +89,7 @@ namespace nv
|
||||||
NVIMAGE_API void fillPullPush(FloatImage * img, const BitMap * bmap);
|
NVIMAGE_API void fillPullPush(FloatImage * img, const BitMap * bmap);
|
||||||
|
|
||||||
NVIMAGE_API void fillExtrapolate(int passCount, FloatImage * img, BitMap * bmap);
|
NVIMAGE_API void fillExtrapolate(int passCount, FloatImage * img, BitMap * bmap);
|
||||||
NVIMAGE_API void fillCubicExtrapolate(int passCount, FloatImage * img, BitMap * bmap, int coverageIndex = -1);
|
NVIMAGE_API void fillQuadraticExtrapolate(int passCount, FloatImage * img, BitMap * bmap, int coverageIndex = -1);
|
||||||
|
|
||||||
} // nv namespace
|
} // nv namespace
|
||||||
|
|
||||||
|
|
|
@ -7,8 +7,6 @@ SET(MATH_SRCS
|
||||||
Quaternion.h
|
Quaternion.h
|
||||||
Box.h
|
Box.h
|
||||||
Color.h
|
Color.h
|
||||||
Eigen.h Eigen.cpp
|
|
||||||
Fitting.h Fitting.cpp
|
|
||||||
Montecarlo.h Montecarlo.cpp
|
Montecarlo.h Montecarlo.cpp
|
||||||
Random.h Random.cpp
|
Random.h Random.cpp
|
||||||
SphericalHarmonic.h SphericalHarmonic.cpp
|
SphericalHarmonic.h SphericalHarmonic.cpp
|
||||||
|
|
|
@ -1,533 +0,0 @@
|
||||||
// This code is in the public domain -- castanyo@yahoo.es
|
|
||||||
|
|
||||||
#include "Eigen.h"
|
|
||||||
|
|
||||||
using namespace nv;
|
|
||||||
|
|
||||||
static const float EPS = 0.00001f;
|
|
||||||
static const int MAX_ITER = 100;
|
|
||||||
|
|
||||||
static void semi_definite_symmetric_eigen(const float *mat, int n, float *eigen_vec, float *eigen_val);
|
|
||||||
|
|
||||||
|
|
||||||
// Use power method to find the first eigenvector.
|
|
||||||
// http://www.miislita.com/information-retrieval-tutorial/matrix-tutorial-3-eigenvalues-eigenvectors.html
|
|
||||||
Vector3 nv::firstEigenVector(float matrix[6])
|
|
||||||
{
|
|
||||||
// Number of iterations. @@ Use a variable number of iterations.
|
|
||||||
const int NUM = 8;
|
|
||||||
|
|
||||||
Vector3 v(1, 1, 1);
|
|
||||||
for(int i = 0; i < NUM; i++) {
|
|
||||||
float x = v.x() * matrix[0] + v.y() * matrix[1] + v.z() * matrix[2];
|
|
||||||
float y = v.x() * matrix[1] + v.y() * matrix[3] + v.z() * matrix[4];
|
|
||||||
float z = v.x() * matrix[2] + v.y() * matrix[4] + v.z() * matrix[5];
|
|
||||||
|
|
||||||
float norm = max(max(x, y), z);
|
|
||||||
float iv = 1.0f / norm;
|
|
||||||
if (norm == 0.0f) {
|
|
||||||
return Vector3(zero);
|
|
||||||
}
|
|
||||||
|
|
||||||
v.set(x*iv, y*iv, z*iv);
|
|
||||||
}
|
|
||||||
|
|
||||||
return v;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/// Solve eigen system.
|
|
||||||
void Eigen::solve() {
|
|
||||||
semi_definite_symmetric_eigen(matrix, N, eigen_vec, eigen_val);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Solve eigen system.
|
|
||||||
void Eigen3::solve() {
|
|
||||||
// @@ Use lengyel code that seems to be more optimized.
|
|
||||||
#if 1
|
|
||||||
float v[3*3];
|
|
||||||
semi_definite_symmetric_eigen(matrix, 3, v, eigen_val);
|
|
||||||
|
|
||||||
eigen_vec[0].set(v[0], v[1], v[2]);
|
|
||||||
eigen_vec[1].set(v[3], v[4], v[5]);
|
|
||||||
eigen_vec[2].set(v[6], v[7], v[8]);
|
|
||||||
#else
|
|
||||||
const int maxSweeps = 32;
|
|
||||||
const float epsilon = 1.0e-10f;
|
|
||||||
|
|
||||||
float m11 = matrix[0]; // m(0,0);
|
|
||||||
float m12 = matrix[1]; // m(0,1);
|
|
||||||
float m13 = matrix[2]; // m(0,2);
|
|
||||||
float m22 = matrix[3]; // m(1,1);
|
|
||||||
float m23 = matrix[4]; // m(1,2);
|
|
||||||
float m33 = matrix[5]; // m(2,2);
|
|
||||||
|
|
||||||
//r.SetIdentity();
|
|
||||||
eigen_vec[0].set(1, 0, 0);
|
|
||||||
eigen_vec[1].set(0, 1, 0);
|
|
||||||
eigen_vec[2].set(0, 0, 1);
|
|
||||||
|
|
||||||
for (int a = 0; a < maxSweeps; a++)
|
|
||||||
{
|
|
||||||
// Exit if off-diagonal entries small enough
|
|
||||||
if ((fabs(m12) < epsilon) && (fabs(m13) < epsilon) && (fabs(m23) < epsilon))
|
|
||||||
{
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Annihilate (1,2) entry
|
|
||||||
if (m12 != 0.0f)
|
|
||||||
{
|
|
||||||
float u = (m22 - m11) * 0.5f / m12;
|
|
||||||
float u2 = u * u;
|
|
||||||
float u2p1 = u2 + 1.0f;
|
|
||||||
float t = (u2p1 != u2) ? ((u < 0.0f) ? -1.0f : 1.0f) * (sqrt(u2p1) - fabs(u)) : 0.5f / u;
|
|
||||||
float c = 1.0f / sqrt(t * t + 1.0f);
|
|
||||||
float s = c * t;
|
|
||||||
|
|
||||||
m11 -= t * m12;
|
|
||||||
m22 += t * m12;
|
|
||||||
m12 = 0.0f;
|
|
||||||
|
|
||||||
float temp = c * m13 - s * m23;
|
|
||||||
m23 = s * m13 + c * m23;
|
|
||||||
m13 = temp;
|
|
||||||
|
|
||||||
for (int i = 0; i < 3; i++)
|
|
||||||
{
|
|
||||||
float temp = c * eigen_vec[i].x - s * eigen_vec[i].y;
|
|
||||||
eigen_vec[i].y = s * eigen_vec[i].x + c * eigen_vec[i].y;
|
|
||||||
eigen_vec[i].x = temp;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Annihilate (1,3) entry
|
|
||||||
if (m13 != 0.0f)
|
|
||||||
{
|
|
||||||
float u = (m33 - m11) * 0.5f / m13;
|
|
||||||
float u2 = u * u;
|
|
||||||
float u2p1 = u2 + 1.0f;
|
|
||||||
float t = (u2p1 != u2) ? ((u < 0.0f) ? -1.0f : 1.0f) * (sqrt(u2p1) - fabs(u)) : 0.5f / u;
|
|
||||||
float c = 1.0f / sqrt(t * t + 1.0f);
|
|
||||||
float s = c * t;
|
|
||||||
|
|
||||||
m11 -= t * m13;
|
|
||||||
m33 += t * m13;
|
|
||||||
m13 = 0.0f;
|
|
||||||
|
|
||||||
float temp = c * m12 - s * m23;
|
|
||||||
m23 = s * m12 + c * m23;
|
|
||||||
m12 = temp;
|
|
||||||
|
|
||||||
for (int i = 0; i < 3; i++)
|
|
||||||
{
|
|
||||||
float temp = c * eigen_vec[i].x - s * eigen_vec[i].z;
|
|
||||||
eigen_vec[i].z = s * eigen_vec[i].x + c * eigen_vec[i].z;
|
|
||||||
eigen_vec[i].x = temp;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Annihilate (2,3) entry
|
|
||||||
if (m23 != 0.0f)
|
|
||||||
{
|
|
||||||
float u = (m33 - m22) * 0.5f / m23;
|
|
||||||
float u2 = u * u;
|
|
||||||
float u2p1 = u2 + 1.0f;
|
|
||||||
float t = (u2p1 != u2) ? ((u < 0.0f) ? -1.0f : 1.0f) * (sqrt(u2p1) - fabs(u)) : 0.5f / u;
|
|
||||||
float c = 1.0f / sqrt(t * t + 1.0f);
|
|
||||||
float s = c * t;
|
|
||||||
|
|
||||||
m22 -= t * m23;
|
|
||||||
m33 += t * m23;
|
|
||||||
m23 = 0.0f;
|
|
||||||
|
|
||||||
float temp = c * m12 - s * m13;
|
|
||||||
m13 = s * m12 + c * m13;
|
|
||||||
m12 = temp;
|
|
||||||
|
|
||||||
for (int i = 0; i < 3; i++)
|
|
||||||
{
|
|
||||||
float temp = c * eigen_vec[i].y - s * eigen_vec[i].z;
|
|
||||||
eigen_vec[i].z = s * eigen_vec[i].y + c * eigen_vec[i].z;
|
|
||||||
eigen_vec[i].y = temp;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
eigen_val[0] = m11;
|
|
||||||
eigen_val[1] = m22;
|
|
||||||
eigen_val[2] = m33;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*---------------------------------------------------------------------------
|
|
||||||
Functions
|
|
||||||
---------------------------------------------------------------------------*/
|
|
||||||
|
|
||||||
|
|
||||||
/** @@ I don't remember where did I get this function.
|
|
||||||
* computes the eigen values and eigen vectors
|
|
||||||
* of a semi definite symmetric matrix
|
|
||||||
*
|
|
||||||
* - matrix is stored in column symmetric storage, i.e.
|
|
||||||
* matrix = { m11, m12, m22, m13, m23, m33, m14, m24, m34, m44 ... }
|
|
||||||
* size = n(n+1)/2
|
|
||||||
*
|
|
||||||
* - eigen_vectors (return) = { v1, v2, v3, ..., vn } where vk = vk0, vk1, ..., vkn
|
|
||||||
* size = n^2, must be allocated by caller
|
|
||||||
*
|
|
||||||
* - eigen_values (return) are in decreasing order
|
|
||||||
* size = n, must be allocated by caller
|
|
||||||
*/
|
|
||||||
|
|
||||||
void semi_definite_symmetric_eigen(
|
|
||||||
const float *mat, int n, float *eigen_vec, float *eigen_val
|
|
||||||
) {
|
|
||||||
float *a,*v;
|
|
||||||
float a_norm,a_normEPS,thr,thr_nn;
|
|
||||||
int nb_iter = 0;
|
|
||||||
int jj;
|
|
||||||
int i,j,k,ij,ik,l,m,lm,mq,lq,ll,mm,imv,im,iq,ilv,il,nn;
|
|
||||||
int *index;
|
|
||||||
float a_ij,a_lm,a_ll,a_mm,a_im,a_il;
|
|
||||||
float a_lm_2;
|
|
||||||
float v_ilv,v_imv;
|
|
||||||
float x;
|
|
||||||
float sinx,sinx_2,cosx,cosx_2,sincos;
|
|
||||||
float delta;
|
|
||||||
|
|
||||||
// Number of entries in mat
|
|
||||||
|
|
||||||
nn = (n*(n+1))/2;
|
|
||||||
|
|
||||||
// Step 1: Copy mat to a
|
|
||||||
|
|
||||||
a = new float[nn];
|
|
||||||
|
|
||||||
for( ij=0; ij<nn; ij++ ) {
|
|
||||||
a[ij] = mat[ij];
|
|
||||||
}
|
|
||||||
|
|
||||||
// Ugly Fortran-porting trick: indices for a are between 1 and n
|
|
||||||
a--;
|
|
||||||
|
|
||||||
// Step 2 : Init diagonalization matrix as the unit matrix
|
|
||||||
v = new float[n*n];
|
|
||||||
|
|
||||||
ij = 0;
|
|
||||||
for( i=0; i<n; i++ ) {
|
|
||||||
for( j=0; j<n; j++ ) {
|
|
||||||
if( i==j ) {
|
|
||||||
v[ij++] = 1.0;
|
|
||||||
} else {
|
|
||||||
v[ij++] = 0.0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Ugly Fortran-porting trick: indices for v are between 1 and n
|
|
||||||
v--;
|
|
||||||
|
|
||||||
// Step 3 : compute the weight of the non diagonal terms
|
|
||||||
ij = 1 ;
|
|
||||||
a_norm = 0.0;
|
|
||||||
for( i=1; i<=n; i++ ) {
|
|
||||||
for( j=1; j<=i; j++ ) {
|
|
||||||
if( i!=j ) {
|
|
||||||
a_ij = a[ij];
|
|
||||||
a_norm += a_ij*a_ij;
|
|
||||||
}
|
|
||||||
ij++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if( a_norm != 0.0 ) {
|
|
||||||
|
|
||||||
a_normEPS = a_norm*EPS;
|
|
||||||
thr = a_norm ;
|
|
||||||
|
|
||||||
// Step 4 : rotations
|
|
||||||
while( thr > a_normEPS && nb_iter < MAX_ITER ) {
|
|
||||||
|
|
||||||
nb_iter++;
|
|
||||||
thr_nn = thr / nn;
|
|
||||||
|
|
||||||
for( l=1 ; l< n; l++ ) {
|
|
||||||
for( m=l+1; m<=n; m++ ) {
|
|
||||||
|
|
||||||
// compute sinx and cosx
|
|
||||||
|
|
||||||
lq = (l*l-l)/2;
|
|
||||||
mq = (m*m-m)/2;
|
|
||||||
|
|
||||||
lm = l+mq;
|
|
||||||
a_lm = a[lm];
|
|
||||||
a_lm_2 = a_lm*a_lm;
|
|
||||||
|
|
||||||
if( a_lm_2 < thr_nn ) {
|
|
||||||
continue ;
|
|
||||||
}
|
|
||||||
|
|
||||||
ll = l+lq;
|
|
||||||
mm = m+mq;
|
|
||||||
a_ll = a[ll];
|
|
||||||
a_mm = a[mm];
|
|
||||||
|
|
||||||
delta = a_ll - a_mm;
|
|
||||||
|
|
||||||
if( delta == 0.0f ) {
|
|
||||||
x = - PI/4 ;
|
|
||||||
} else {
|
|
||||||
x = - atanf( (a_lm+a_lm) / delta ) / 2.0f ;
|
|
||||||
}
|
|
||||||
|
|
||||||
sinx = sinf(x);
|
|
||||||
cosx = cosf(x);
|
|
||||||
sinx_2 = sinx*sinx;
|
|
||||||
cosx_2 = cosx*cosx;
|
|
||||||
sincos = sinx*cosx;
|
|
||||||
|
|
||||||
// rotate L and M columns
|
|
||||||
|
|
||||||
ilv = n*(l-1);
|
|
||||||
imv = n*(m-1);
|
|
||||||
|
|
||||||
for( i=1; i<=n;i++ ) {
|
|
||||||
if( (i!=l) && (i!=m) ) {
|
|
||||||
iq = (i*i-i)/2;
|
|
||||||
|
|
||||||
if( i<m ) {
|
|
||||||
im = i + mq;
|
|
||||||
} else {
|
|
||||||
im = m + iq;
|
|
||||||
}
|
|
||||||
a_im = a[im];
|
|
||||||
|
|
||||||
if( i<l ) {
|
|
||||||
il = i + lq;
|
|
||||||
} else {
|
|
||||||
il = l + iq;
|
|
||||||
}
|
|
||||||
a_il = a[il];
|
|
||||||
|
|
||||||
a[il] = a_il*cosx - a_im*sinx;
|
|
||||||
a[im] = a_il*sinx + a_im*cosx;
|
|
||||||
}
|
|
||||||
|
|
||||||
ilv++;
|
|
||||||
imv++;
|
|
||||||
|
|
||||||
v_ilv = v[ilv];
|
|
||||||
v_imv = v[imv];
|
|
||||||
|
|
||||||
v[ilv] = cosx*v_ilv - sinx*v_imv;
|
|
||||||
v[imv] = sinx*v_ilv + cosx*v_imv;
|
|
||||||
}
|
|
||||||
|
|
||||||
x = a_lm*sincos; x+=x;
|
|
||||||
|
|
||||||
a[ll] = a_ll*cosx_2 + a_mm*sinx_2 - x;
|
|
||||||
a[mm] = a_ll*sinx_2 + a_mm*cosx_2 + x;
|
|
||||||
a[lm] = 0.0;
|
|
||||||
|
|
||||||
thr = fabs( thr - a_lm_2 );
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Step 5: index conversion and copy eigen values
|
|
||||||
|
|
||||||
// back from Fortran to C++
|
|
||||||
a++;
|
|
||||||
|
|
||||||
for( i=0; i<n; i++ ) {
|
|
||||||
k = i + (i*(i+1))/2;
|
|
||||||
eigen_val[i] = a[k];
|
|
||||||
}
|
|
||||||
|
|
||||||
delete[] a;
|
|
||||||
|
|
||||||
// Step 6: sort the eigen values and eigen vectors
|
|
||||||
|
|
||||||
index = new int[n];
|
|
||||||
for( i=0; i<n; i++ ) {
|
|
||||||
index[i] = i;
|
|
||||||
}
|
|
||||||
|
|
||||||
for( i=0; i<(n-1); i++ ) {
|
|
||||||
x = eigen_val[i];
|
|
||||||
k = i;
|
|
||||||
|
|
||||||
for( j=i+1; j<n; j++ ) {
|
|
||||||
if( x < eigen_val[j] ) {
|
|
||||||
k = j;
|
|
||||||
x = eigen_val[j];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
eigen_val[k] = eigen_val[i];
|
|
||||||
eigen_val[i] = x;
|
|
||||||
|
|
||||||
jj = index[k];
|
|
||||||
index[k] = index[i];
|
|
||||||
index[i] = jj;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Step 7: save the eigen vectors
|
|
||||||
|
|
||||||
v++; // back from Fortran to to C++
|
|
||||||
|
|
||||||
ij = 0;
|
|
||||||
for( k=0; k<n; k++ ) {
|
|
||||||
ik = index[k]*n;
|
|
||||||
for( i=0; i<n; i++ ) {
|
|
||||||
eigen_vec[ij++] = v[ik++];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
delete[] v ;
|
|
||||||
delete[] index;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
//_________________________________________________________
|
|
||||||
|
|
||||||
|
|
||||||
// Eric Lengyel code:
|
|
||||||
// http://www.terathon.com/code/linear.html
|
|
||||||
#if 0
|
|
||||||
|
|
||||||
const float epsilon = 1.0e-10F;
|
|
||||||
const int maxSweeps = 32;
|
|
||||||
|
|
||||||
|
|
||||||
struct Matrix3D
|
|
||||||
{
|
|
||||||
float n[3][3];
|
|
||||||
|
|
||||||
float& operator()(int i, int j)
|
|
||||||
{
|
|
||||||
return (n[j][i]);
|
|
||||||
}
|
|
||||||
|
|
||||||
const float& operator()(int i, int j) const
|
|
||||||
{
|
|
||||||
return (n[j][i]);
|
|
||||||
}
|
|
||||||
|
|
||||||
void SetIdentity(void)
|
|
||||||
{
|
|
||||||
n[0][0] = n[1][1] = n[2][2] = 1.0F;
|
|
||||||
n[0][1] = n[0][2] = n[1][0] = n[1][2] = n[2][0] = n[2][1] = 0.0F;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
void CalculateEigensystem(const Matrix3D& m, float *lambda, Matrix3D& r)
|
|
||||||
{
|
|
||||||
float m11 = m(0,0);
|
|
||||||
float m12 = m(0,1);
|
|
||||||
float m13 = m(0,2);
|
|
||||||
float m22 = m(1,1);
|
|
||||||
float m23 = m(1,2);
|
|
||||||
float m33 = m(2,2);
|
|
||||||
|
|
||||||
r.SetIdentity();
|
|
||||||
for (int a = 0; a < maxSweeps; a++)
|
|
||||||
{
|
|
||||||
// Exit if off-diagonal entries small enough
|
|
||||||
if ((Fabs(m12) < epsilon) && (Fabs(m13) < epsilon) &&
|
|
||||||
(Fabs(m23) < epsilon)) break;
|
|
||||||
|
|
||||||
// Annihilate (1,2) entry
|
|
||||||
if (m12 != 0.0F)
|
|
||||||
{
|
|
||||||
float u = (m22 - m11) * 0.5F / m12;
|
|
||||||
float u2 = u * u;
|
|
||||||
float u2p1 = u2 + 1.0F;
|
|
||||||
float t = (u2p1 != u2) ?
|
|
||||||
((u < 0.0F) ? -1.0F : 1.0F) * (sqrt(u2p1) - fabs(u)) : 0.5F / u;
|
|
||||||
float c = 1.0F / sqrt(t * t + 1.0F);
|
|
||||||
float s = c * t;
|
|
||||||
|
|
||||||
m11 -= t * m12;
|
|
||||||
m22 += t * m12;
|
|
||||||
m12 = 0.0F;
|
|
||||||
|
|
||||||
float temp = c * m13 - s * m23;
|
|
||||||
m23 = s * m13 + c * m23;
|
|
||||||
m13 = temp;
|
|
||||||
|
|
||||||
for (int i = 0; i < 3; i++)
|
|
||||||
{
|
|
||||||
float temp = c * r(i,0) - s * r(i,1);
|
|
||||||
r(i,1) = s * r(i,0) + c * r(i,1);
|
|
||||||
r(i,0) = temp;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Annihilate (1,3) entry
|
|
||||||
if (m13 != 0.0F)
|
|
||||||
{
|
|
||||||
float u = (m33 - m11) * 0.5F / m13;
|
|
||||||
float u2 = u * u;
|
|
||||||
float u2p1 = u2 + 1.0F;
|
|
||||||
float t = (u2p1 != u2) ?
|
|
||||||
((u < 0.0F) ? -1.0F : 1.0F) * (sqrt(u2p1) - fabs(u)) : 0.5F / u;
|
|
||||||
float c = 1.0F / sqrt(t * t + 1.0F);
|
|
||||||
float s = c * t;
|
|
||||||
|
|
||||||
m11 -= t * m13;
|
|
||||||
m33 += t * m13;
|
|
||||||
m13 = 0.0F;
|
|
||||||
|
|
||||||
float temp = c * m12 - s * m23;
|
|
||||||
m23 = s * m12 + c * m23;
|
|
||||||
m12 = temp;
|
|
||||||
|
|
||||||
for (int i = 0; i < 3; i++)
|
|
||||||
{
|
|
||||||
float temp = c * r(i,0) - s * r(i,2);
|
|
||||||
r(i,2) = s * r(i,0) + c * r(i,2);
|
|
||||||
r(i,0) = temp;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Annihilate (2,3) entry
|
|
||||||
if (m23 != 0.0F)
|
|
||||||
{
|
|
||||||
float u = (m33 - m22) * 0.5F / m23;
|
|
||||||
float u2 = u * u;
|
|
||||||
float u2p1 = u2 + 1.0F;
|
|
||||||
float t = (u2p1 != u2) ?
|
|
||||||
((u < 0.0F) ? -1.0F : 1.0F) * (sqrt(u2p1) - fabs(u)) : 0.5F / u;
|
|
||||||
float c = 1.0F / sqrt(t * t + 1.0F);
|
|
||||||
float s = c * t;
|
|
||||||
|
|
||||||
m22 -= t * m23;
|
|
||||||
m33 += t * m23;
|
|
||||||
m23 = 0.0F;
|
|
||||||
|
|
||||||
float temp = c * m12 - s * m13;
|
|
||||||
m13 = s * m12 + c * m13;
|
|
||||||
m12 = temp;
|
|
||||||
|
|
||||||
for (int i = 0; i < 3; i++)
|
|
||||||
{
|
|
||||||
float temp = c * r(i,1) - s * r(i,2);
|
|
||||||
r(i,2) = s * r(i,1) + c * r(i,2);
|
|
||||||
r(i,1) = temp;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
lambda[0] = m11;
|
|
||||||
lambda[1] = m22;
|
|
||||||
lambda[2] = m33;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
|
@ -1,140 +0,0 @@
|
||||||
// This code is in the public domain -- castanyo@yahoo.es
|
|
||||||
|
|
||||||
#ifndef NV_MATH_EIGEN_H
|
|
||||||
#define NV_MATH_EIGEN_H
|
|
||||||
|
|
||||||
#include <nvcore/Containers.h> // swap
|
|
||||||
#include <nvmath/nvmath.h>
|
|
||||||
#include <nvmath/Vector.h>
|
|
||||||
|
|
||||||
namespace nv
|
|
||||||
{
|
|
||||||
|
|
||||||
// Compute first eigen vector using the power method.
|
|
||||||
Vector3 firstEigenVector(float matrix[6]);
|
|
||||||
|
|
||||||
/// Generic eigen-solver.
|
|
||||||
class Eigen
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
|
|
||||||
/// Ctor.
|
|
||||||
Eigen(uint n) : N(n)
|
|
||||||
{
|
|
||||||
uint size = n * (n + 1) / 2;
|
|
||||||
matrix = new float[size];
|
|
||||||
eigen_vec = new float[N*N];
|
|
||||||
eigen_val = new float[N];
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Dtor.
|
|
||||||
~Eigen()
|
|
||||||
{
|
|
||||||
delete [] matrix;
|
|
||||||
delete [] eigen_vec;
|
|
||||||
delete [] eigen_val;
|
|
||||||
}
|
|
||||||
|
|
||||||
NVMATH_API void solve();
|
|
||||||
|
|
||||||
/// Matrix accesor.
|
|
||||||
float & operator()(uint x, uint y)
|
|
||||||
{
|
|
||||||
if( x > y ) {
|
|
||||||
swap(x, y);
|
|
||||||
}
|
|
||||||
return matrix[y * (y + 1) / 2 + x];
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Matrix const accessor.
|
|
||||||
float operator()(uint x, uint y) const
|
|
||||||
{
|
|
||||||
if( x > y ) {
|
|
||||||
swap(x, y);
|
|
||||||
}
|
|
||||||
return matrix[y * (y + 1) / 2 + x];
|
|
||||||
}
|
|
||||||
|
|
||||||
Vector3 eigenVector3(uint i) const
|
|
||||||
{
|
|
||||||
nvCheck(3 == N);
|
|
||||||
nvCheck(i < N);
|
|
||||||
return Vector3(eigen_vec[i*N+0], eigen_vec[i*N+1], eigen_vec[i*N+2]);
|
|
||||||
}
|
|
||||||
|
|
||||||
Vector4 eigenVector4(uint i) const
|
|
||||||
{
|
|
||||||
nvCheck(4 == N);
|
|
||||||
nvCheck(i < N);
|
|
||||||
return Vector4(eigen_vec[i*N+0], eigen_vec[i*N+1], eigen_vec[i*N+2], eigen_vec[i*N+3]);
|
|
||||||
}
|
|
||||||
|
|
||||||
float eigenValue(uint i) const
|
|
||||||
{
|
|
||||||
nvCheck(i < N);
|
|
||||||
return eigen_val[i];
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
const uint N;
|
|
||||||
float * matrix;
|
|
||||||
float * eigen_vec;
|
|
||||||
float * eigen_val;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
/// 3x3 eigen-solver.
|
|
||||||
/// Based on Eric Lengyel's code:
|
|
||||||
/// http://www.terathon.com/code/linear.html
|
|
||||||
class Eigen3
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** Ctor. */
|
|
||||||
Eigen3() {}
|
|
||||||
|
|
||||||
NVMATH_API void solve();
|
|
||||||
|
|
||||||
/// Matrix accesor.
|
|
||||||
float & operator()(uint x, uint y)
|
|
||||||
{
|
|
||||||
nvDebugCheck( x < 3 && y < 3 );
|
|
||||||
if( x > y ) {
|
|
||||||
swap(x, y);
|
|
||||||
}
|
|
||||||
return matrix[y * (y + 1) / 2 + x];
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Matrix const accessor.
|
|
||||||
float operator()(uint x, uint y) const
|
|
||||||
{
|
|
||||||
nvDebugCheck( x < 3 && y < 3 );
|
|
||||||
if( x > y ) {
|
|
||||||
swap(x, y);
|
|
||||||
}
|
|
||||||
return matrix[y * (y + 1) / 2 + x];
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Get ith eigen vector.
|
|
||||||
Vector3 eigenVector(uint i) const
|
|
||||||
{
|
|
||||||
nvCheck(i < 3);
|
|
||||||
return eigen_vec[i];
|
|
||||||
}
|
|
||||||
|
|
||||||
/** Get ith eigen value. */
|
|
||||||
float eigenValue(uint i) const
|
|
||||||
{
|
|
||||||
nvCheck(i < 3);
|
|
||||||
return eigen_val[i];
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
float matrix[3+2+1];
|
|
||||||
Vector3 eigen_vec[3];
|
|
||||||
float eigen_val[3];
|
|
||||||
};
|
|
||||||
|
|
||||||
} // nv namespace
|
|
||||||
|
|
||||||
#endif // NV_MATH_EIGEN_H
|
|
|
@ -1,134 +0,0 @@
|
||||||
// License: Wild Magic License Version 3
|
|
||||||
// http://geometrictools.com/License/WildMagic3License.pdf
|
|
||||||
|
|
||||||
#include "Fitting.h"
|
|
||||||
#include "Eigen.h"
|
|
||||||
|
|
||||||
using namespace nv;
|
|
||||||
|
|
||||||
|
|
||||||
/** Fit a 3d line to the given set of points.
|
|
||||||
*
|
|
||||||
* Based on code from:
|
|
||||||
* http://geometrictools.com/
|
|
||||||
*/
|
|
||||||
Line3 Fit::bestLine(const Array<Vector3> & pointArray)
|
|
||||||
{
|
|
||||||
nvDebugCheck(pointArray.count() > 0);
|
|
||||||
|
|
||||||
Line3 line;
|
|
||||||
|
|
||||||
const uint pointCount = pointArray.count();
|
|
||||||
const float inv_num = 1.0f / pointCount;
|
|
||||||
|
|
||||||
// compute the mean of the points
|
|
||||||
Vector3 center(zero);
|
|
||||||
for(uint i = 0; i < pointCount; i++) {
|
|
||||||
center += pointArray[i];
|
|
||||||
}
|
|
||||||
line.setOrigin(center * inv_num);
|
|
||||||
|
|
||||||
// compute the covariance matrix of the points
|
|
||||||
float covariance[6] = {0, 0, 0, 0, 0, 0};
|
|
||||||
for(uint i = 0; i < pointCount; i++) {
|
|
||||||
Vector3 diff = pointArray[i] - line.origin();
|
|
||||||
covariance[0] += diff.x() * diff.x();
|
|
||||||
covariance[1] += diff.x() * diff.y();
|
|
||||||
covariance[2] += diff.x() * diff.z();
|
|
||||||
covariance[3] += diff.y() * diff.y();
|
|
||||||
covariance[4] += diff.y() * diff.z();
|
|
||||||
covariance[5] += diff.z() * diff.z();
|
|
||||||
}
|
|
||||||
|
|
||||||
line.setDirection(normalizeSafe(firstEigenVector(covariance), Vector3(zero), 0.0f));
|
|
||||||
|
|
||||||
// @@ This variant is from David Eberly... I'm not sure how that works.
|
|
||||||
/*sum_xx *= inv_num;
|
|
||||||
sum_xy *= inv_num;
|
|
||||||
sum_xz *= inv_num;
|
|
||||||
sum_yy *= inv_num;
|
|
||||||
sum_yz *= inv_num;
|
|
||||||
sum_zz *= inv_num;
|
|
||||||
|
|
||||||
// set up the eigensolver
|
|
||||||
Eigen3 ES;
|
|
||||||
ES(0,0) = sum_yy + sum_zz;
|
|
||||||
ES(0,1) = -sum_xy;
|
|
||||||
ES(0,2) = -sum_xz;
|
|
||||||
ES(1,1) = sum_xx + sum_zz;
|
|
||||||
ES(1,2) = -sum_yz;
|
|
||||||
ES(2,2) = sum_xx + sum_yy;
|
|
||||||
|
|
||||||
// compute eigenstuff, smallest eigenvalue is in last position
|
|
||||||
ES.solve();
|
|
||||||
|
|
||||||
line.setDirection(ES.eigenVector(2));
|
|
||||||
|
|
||||||
nvCheck( isNormalized(line.direction()) );
|
|
||||||
*/
|
|
||||||
return line;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/** Fit a 3d plane to the given set of points.
|
|
||||||
*
|
|
||||||
* Based on code from:
|
|
||||||
* http://geometrictools.com/
|
|
||||||
*/
|
|
||||||
Vector4 Fit::bestPlane(const Array<Vector3> & pointArray)
|
|
||||||
{
|
|
||||||
Vector3 center(zero);
|
|
||||||
|
|
||||||
const uint pointCount = pointArray.count();
|
|
||||||
const float inv_num = 1.0f / pointCount;
|
|
||||||
|
|
||||||
// compute the mean of the points
|
|
||||||
for(uint i = 0; i < pointCount; i++) {
|
|
||||||
center += pointArray[i];
|
|
||||||
}
|
|
||||||
center *= inv_num;
|
|
||||||
|
|
||||||
// compute the covariance matrix of the points
|
|
||||||
float sum_xx = 0.0f;
|
|
||||||
float sum_xy = 0.0f;
|
|
||||||
float sum_xz = 0.0f;
|
|
||||||
float sum_yy = 0.0f;
|
|
||||||
float sum_yz = 0.0f;
|
|
||||||
float sum_zz = 0.0f;
|
|
||||||
|
|
||||||
for(uint i = 0; i < pointCount; i++) {
|
|
||||||
Vector3 diff = pointArray[i] - center;
|
|
||||||
sum_xx += diff.x() * diff.x();
|
|
||||||
sum_xy += diff.x() * diff.y();
|
|
||||||
sum_xz += diff.x() * diff.z();
|
|
||||||
sum_yy += diff.y() * diff.y();
|
|
||||||
sum_yz += diff.y() * diff.z();
|
|
||||||
sum_zz += diff.z() * diff.z();
|
|
||||||
}
|
|
||||||
|
|
||||||
sum_xx *= inv_num;
|
|
||||||
sum_xy *= inv_num;
|
|
||||||
sum_xz *= inv_num;
|
|
||||||
sum_yy *= inv_num;
|
|
||||||
sum_yz *= inv_num;
|
|
||||||
sum_zz *= inv_num;
|
|
||||||
|
|
||||||
// set up the eigensolver
|
|
||||||
Eigen3 ES;
|
|
||||||
ES(0,0) = sum_yy + sum_zz;
|
|
||||||
ES(0,1) = -sum_xy;
|
|
||||||
ES(0,2) = -sum_xz;
|
|
||||||
ES(1,1) = sum_xx + sum_zz;
|
|
||||||
ES(1,2) = -sum_yz;
|
|
||||||
ES(2,2) = sum_xx + sum_yy;
|
|
||||||
|
|
||||||
// compute eigenstuff, greatest eigenvalue is in first position
|
|
||||||
ES.solve();
|
|
||||||
|
|
||||||
Vector3 normal = ES.eigenVector(0);
|
|
||||||
nvCheck(isNormalized(normal));
|
|
||||||
|
|
||||||
float offset = dot(normal, center);
|
|
||||||
|
|
||||||
return Vector4(normal, offset);
|
|
||||||
}
|
|
|
@ -1,78 +0,0 @@
|
||||||
// This code is in the public domain -- castanyo@yahoo.es
|
|
||||||
|
|
||||||
#ifndef NV_MATH_FITTING_H
|
|
||||||
#define NV_MATH_FITTING_H
|
|
||||||
|
|
||||||
#include <nvmath/Vector.h>
|
|
||||||
|
|
||||||
namespace nv
|
|
||||||
{
|
|
||||||
|
|
||||||
/// 3D Line.
|
|
||||||
struct Line3
|
|
||||||
{
|
|
||||||
/// Ctor.
|
|
||||||
Line3() : m_origin(zero), m_direction(zero)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Copy ctor.
|
|
||||||
Line3(const Line3 & l) : m_origin(l.m_origin), m_direction(l.m_direction)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Ctor.
|
|
||||||
Line3(Vector3::Arg o, Vector3::Arg d) : m_origin(o), m_direction(d)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Normalize the line.
|
|
||||||
void normalize()
|
|
||||||
{
|
|
||||||
m_direction = nv::normalize(m_direction);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Project a point onto the line.
|
|
||||||
Vector3 projectPoint(Vector3::Arg point) const
|
|
||||||
{
|
|
||||||
nvDebugCheck(isNormalized(m_direction));
|
|
||||||
|
|
||||||
Vector3 v = point - m_origin;
|
|
||||||
return m_origin + m_direction * dot(m_direction, v);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Compute distance to line.
|
|
||||||
float distanceToPoint(Vector3::Arg point) const
|
|
||||||
{
|
|
||||||
nvDebugCheck(isNormalized(m_direction));
|
|
||||||
|
|
||||||
Vector3 v = point - m_origin;
|
|
||||||
Vector3 l = v - m_direction * dot(m_direction, v);
|
|
||||||
|
|
||||||
return length(l);
|
|
||||||
}
|
|
||||||
|
|
||||||
const Vector3 & origin() const { return m_origin; }
|
|
||||||
void setOrigin(Vector3::Arg value) { m_origin = value; }
|
|
||||||
|
|
||||||
const Vector3 & direction() const { return m_direction; }
|
|
||||||
void setDirection(Vector3::Arg value) { m_direction = value; }
|
|
||||||
|
|
||||||
|
|
||||||
private:
|
|
||||||
Vector3 m_origin;
|
|
||||||
Vector3 m_direction;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
namespace Fit
|
|
||||||
{
|
|
||||||
|
|
||||||
NVMATH_API Line3 bestLine(const Array<Vector3> & pointArray);
|
|
||||||
NVMATH_API Vector4 bestPlane(const Array<Vector3> & pointArray);
|
|
||||||
|
|
||||||
} // Fit namespace
|
|
||||||
|
|
||||||
} // nv namespace
|
|
||||||
|
|
||||||
#endif // _PI_MATHLIB_FITTING_H_
|
|
|
@ -97,7 +97,6 @@ void nv::fastCompressDXT1a(const Image * image, const OutputOptions::Private & o
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
rgba.init(image, x, y);
|
rgba.init(image, x, y);
|
||||||
|
|
||||||
QuickCompress::compressDXT1a(rgba, &block);
|
QuickCompress::compressDXT1a(rgba, &block);
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
|
@ -119,7 +118,7 @@ void nv::fastCompressDXT3(const Image * image, const nvtt::OutputOptions::Privat
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
rgba.init(image, x, y);
|
rgba.init(image, x, y);
|
||||||
compressBlock_BoundsRange(rgba, &block);
|
QuickCompress::compressDXT3(rgba, &block);
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
||||||
|
@ -140,7 +139,8 @@ void nv::fastCompressDXT5(const Image * image, const nvtt::OutputOptions::Privat
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
rgba.init(image, x, y);
|
rgba.init(image, x, y);
|
||||||
compressBlock_BoundsRange(rgba, &block);
|
//QuickCompress::compressDXT5(rgba, &block); // @@ Use fast version!!
|
||||||
|
nv::compressBlock_BoundsRange(rgba, &block);
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
||||||
|
@ -165,7 +165,8 @@ void nv::fastCompressDXT5n(const Image * image, const nvtt::OutputOptions::Priva
|
||||||
// copy X coordinate to alpha channel and Y coordinate to green channel.
|
// copy X coordinate to alpha channel and Y coordinate to green channel.
|
||||||
rgba.swizzleDXT5n();
|
rgba.swizzleDXT5n();
|
||||||
|
|
||||||
compressBlock_BoundsRange(rgba, &block);
|
//QuickCompress::compressDXT5(rgba, &block); // @@ Use fast version!!
|
||||||
|
nv::compressBlock_BoundsRange(rgba, &block);
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
||||||
|
@ -286,7 +287,7 @@ void nv::compressDXT3(const Image * image, const OutputOptions::Private & output
|
||||||
rgba.init(image, x, y);
|
rgba.init(image, x, y);
|
||||||
|
|
||||||
// Compress explicit alpha.
|
// Compress explicit alpha.
|
||||||
compressBlock(rgba, &block.alpha);
|
QuickCompress::compressDXT3A(rgba, &block.alpha);
|
||||||
|
|
||||||
// Compress color.
|
// Compress color.
|
||||||
squish::ColourSet colours((uint8 *)rgba.colors(), squish::kWeightColourByAlpha);
|
squish::ColourSet colours((uint8 *)rgba.colors(), squish::kWeightColourByAlpha);
|
||||||
|
@ -317,14 +318,13 @@ void nv::compressDXT5(const Image * image, const OutputOptions::Private & output
|
||||||
rgba.init(image, x, y);
|
rgba.init(image, x, y);
|
||||||
|
|
||||||
// Compress alpha.
|
// Compress alpha.
|
||||||
uint error;
|
|
||||||
if (compressionOptions.quality == Quality_Highest)
|
if (compressionOptions.quality == Quality_Highest)
|
||||||
{
|
{
|
||||||
error = compressBlock_BruteForce(rgba, &block.alpha);
|
compressBlock_BruteForce(rgba, &block.alpha);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
error = compressBlock_Iterative(rgba, &block.alpha);
|
QuickCompress::compressDXT5A(rgba, &block.alpha);
|
||||||
}
|
}
|
||||||
|
|
||||||
// Compress color.
|
// Compress color.
|
||||||
|
@ -359,10 +359,13 @@ void nv::compressDXT5n(const Image * image, const OutputOptions::Private & outpu
|
||||||
rgba.swizzleDXT5n();
|
rgba.swizzleDXT5n();
|
||||||
|
|
||||||
// Compress X.
|
// Compress X.
|
||||||
uint error = compressBlock_Iterative(rgba, &block.alpha);
|
|
||||||
if (compressionOptions.quality == Quality_Highest)
|
if (compressionOptions.quality == Quality_Highest)
|
||||||
{
|
{
|
||||||
error = compressBlock_BruteForce(rgba, &block.alpha);
|
compressBlock_BruteForce(rgba, &block.alpha);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
QuickCompress::compressDXT5A(rgba, &block.alpha);
|
||||||
}
|
}
|
||||||
|
|
||||||
// Compress Y.
|
// Compress Y.
|
||||||
|
@ -384,23 +387,19 @@ void nv::compressBC4(const Image * image, const nvtt::OutputOptions::Private & o
|
||||||
ColorBlock rgba;
|
ColorBlock rgba;
|
||||||
AlphaBlockDXT5 block;
|
AlphaBlockDXT5 block;
|
||||||
|
|
||||||
uint totalError = 0;
|
|
||||||
|
|
||||||
for (uint y = 0; y < h; y += 4) {
|
for (uint y = 0; y < h; y += 4) {
|
||||||
for (uint x = 0; x < w; x += 4) {
|
for (uint x = 0; x < w; x += 4) {
|
||||||
|
|
||||||
rgba.init(image, x, y);
|
rgba.init(image, x, y);
|
||||||
|
|
||||||
//error = compressBlock_BoundsRange(rgba, &block);
|
|
||||||
uint error = compressBlock_Iterative(rgba, &block);
|
|
||||||
|
|
||||||
if (compressionOptions.quality == Quality_Highest)
|
if (compressionOptions.quality == Quality_Highest)
|
||||||
{
|
{
|
||||||
// Try brute force algorithm.
|
compressBlock_BruteForce(rgba, &block);
|
||||||
error = compressBlock_BruteForce(rgba, &block);
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
QuickCompress::compressDXT5A(rgba, &block);
|
||||||
}
|
}
|
||||||
|
|
||||||
totalError += error;
|
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
outputOptions.outputHandler->writeData(&block, sizeof(block));
|
||||||
|
@ -429,18 +428,15 @@ void nv::compressBC5(const Image * image, const nvtt::OutputOptions::Private & o
|
||||||
ycolor.init(image, x, y);
|
ycolor.init(image, x, y);
|
||||||
ycolor.splatY();
|
ycolor.splatY();
|
||||||
|
|
||||||
// @@ Compute normal error, instead of separate xy errors.
|
|
||||||
uint xerror, yerror;
|
|
||||||
|
|
||||||
if (compressionOptions.quality == Quality_Highest)
|
if (compressionOptions.quality == Quality_Highest)
|
||||||
{
|
{
|
||||||
xerror = compressBlock_BruteForce(xcolor, &block.x);
|
compressBlock_BruteForce(xcolor, &block.x);
|
||||||
yerror = compressBlock_BruteForce(ycolor, &block.y);
|
compressBlock_BruteForce(ycolor, &block.y);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
xerror = compressBlock_Iterative(xcolor, &block.x);
|
QuickCompress::compressDXT5A(xcolor, &block.x);
|
||||||
yerror = compressBlock_Iterative(ycolor, &block.y);
|
QuickCompress::compressDXT5A(ycolor, &block.y);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (outputOptions.outputHandler != NULL) {
|
if (outputOptions.outputHandler != NULL) {
|
||||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -38,40 +38,37 @@ namespace nv
|
||||||
// Color compression:
|
// Color compression:
|
||||||
|
|
||||||
// Compressor that uses the extremes of the luminance axis.
|
// Compressor that uses the extremes of the luminance axis.
|
||||||
void compressBlock_DiameterAxis(const ColorBlock & rgba, BlockDXT1 * block);
|
// void compressBlock_DiameterAxis(const ColorBlock & rgba, BlockDXT1 * block);
|
||||||
|
|
||||||
// Compressor that uses the extremes of the luminance axis.
|
// Compressor that uses the extremes of the luminance axis.
|
||||||
void compressBlock_LuminanceAxis(const ColorBlock & rgba, BlockDXT1 * block);
|
// void compressBlock_LuminanceAxis(const ColorBlock & rgba, BlockDXT1 * block);
|
||||||
|
|
||||||
// Compressor that uses bounding box.
|
// Compressor that uses bounding box.
|
||||||
void compressBlock_BoundsRange(const ColorBlock & rgba, BlockDXT1 * block);
|
void compressBlock_BoundsRange(const ColorBlock & rgba, BlockDXT1 * block);
|
||||||
|
|
||||||
// Compressor that uses bounding box and takes alpha into account.
|
// Compressor that uses bounding box and takes alpha into account.
|
||||||
void compressBlock_BoundsRangeAlpha(const ColorBlock & rgba, BlockDXT1 * block);
|
// void compressBlock_BoundsRangeAlpha(const ColorBlock & rgba, BlockDXT1 * block);
|
||||||
|
|
||||||
// Compressor that uses the best fit axis.
|
|
||||||
void compressBlock_BestFitAxis(const ColorBlock & rgba, BlockDXT1 * block);
|
|
||||||
|
|
||||||
|
|
||||||
// Simple, but slow compressor that tests all color pairs.
|
// Simple, but slow compressor that tests all color pairs.
|
||||||
void compressBlock_TestAllPairs(const ColorBlock & rgba, BlockDXT1 * block);
|
// void compressBlock_TestAllPairs(const ColorBlock & rgba, BlockDXT1 * block);
|
||||||
|
|
||||||
// Brute force 6d search along the best fit axis.
|
// Brute force 6d search along the best fit axis.
|
||||||
void compressBlock_AnalyzeBestFitAxis(const ColorBlock & rgba, BlockDXT1 * block);
|
// void compressBlock_AnalyzeBestFitAxis(const ColorBlock & rgba, BlockDXT1 * block);
|
||||||
|
|
||||||
// Spatial greedy search.
|
// Spatial greedy search.
|
||||||
void refineSolution_1dSearch(const ColorBlock & rgba, BlockDXT1 * block);
|
// void refineSolution_1dSearch(const ColorBlock & rgba, BlockDXT1 * block);
|
||||||
void refineSolution_3dSearch(const ColorBlock & rgba, BlockDXT1 * block);
|
// void refineSolution_3dSearch(const ColorBlock & rgba, BlockDXT1 * block);
|
||||||
void refineSolution_6dSearch(const ColorBlock & rgba, BlockDXT1 * block);
|
// void refineSolution_6dSearch(const ColorBlock & rgba, BlockDXT1 * block);
|
||||||
|
|
||||||
// Brute force compressor for DXT5n
|
// Brute force compressor for DXT5n
|
||||||
void compressGreenBlock_BruteForce(const ColorBlock & rgba, BlockDXT1 * block);
|
// void compressGreenBlock_BruteForce(const ColorBlock & rgba, BlockDXT1 * block);
|
||||||
|
|
||||||
// Minimize error of the endpoints.
|
// Minimize error of the endpoints.
|
||||||
void optimizeEndPoints(const ColorBlock & rgba, BlockDXT1 * block);
|
// void optimizeEndPoints(const ColorBlock & rgba, BlockDXT1 * block);
|
||||||
|
|
||||||
uint blockError(const ColorBlock & rgba, const BlockDXT1 & block);
|
// uint blockError(const ColorBlock & rgba, const BlockDXT1 & block);
|
||||||
uint blockError(const ColorBlock & rgba, const AlphaBlockDXT5 & block);
|
// uint blockError(const ColorBlock & rgba, const AlphaBlockDXT5 & block);
|
||||||
|
|
||||||
// Alpha compression:
|
// Alpha compression:
|
||||||
void compressBlock(const ColorBlock & rgba, AlphaBlockDXT3 * block);
|
void compressBlock(const ColorBlock & rgba, AlphaBlockDXT3 * block);
|
||||||
|
@ -80,7 +77,7 @@ namespace nv
|
||||||
|
|
||||||
uint compressBlock_BoundsRange(const ColorBlock & rgba, AlphaBlockDXT5 * block);
|
uint compressBlock_BoundsRange(const ColorBlock & rgba, AlphaBlockDXT5 * block);
|
||||||
uint compressBlock_BruteForce(const ColorBlock & rgba, AlphaBlockDXT5 * block);
|
uint compressBlock_BruteForce(const ColorBlock & rgba, AlphaBlockDXT5 * block);
|
||||||
uint compressBlock_Iterative(const ColorBlock & rgba, AlphaBlockDXT5 * block);
|
// uint compressBlock_Iterative(const ColorBlock & rgba, AlphaBlockDXT5 * block);
|
||||||
|
|
||||||
} // nv namespace
|
} // nv namespace
|
||||||
|
|
||||||
|
|
|
@ -288,62 +288,219 @@ static void optimizeEndPoints4(Vector3 block[16], BlockDXT1 * dxtBlock)
|
||||||
dxtBlock->indices = computeIndices3(block, a, b);
|
dxtBlock->indices = computeIndices3(block, a, b);
|
||||||
}*/
|
}*/
|
||||||
|
|
||||||
|
namespace
|
||||||
static void optimizeAlpha8(const ColorBlock & rgba, AlphaBlockDXT5 * block)
|
|
||||||
{
|
{
|
||||||
float alpha2_sum = 0;
|
static int computeGreenError(const ColorBlock & rgba, const BlockDXT1 * block)
|
||||||
float beta2_sum = 0;
|
|
||||||
float alphabeta_sum = 0;
|
|
||||||
float alphax_sum = 0;
|
|
||||||
float betax_sum = 0;
|
|
||||||
|
|
||||||
for (int i = 0; i < 16; i++)
|
|
||||||
{
|
{
|
||||||
uint idx = block->index(i);
|
nvDebugCheck(block != NULL);
|
||||||
float alpha;
|
|
||||||
if (idx < 2) alpha = 1.0f - idx;
|
|
||||||
else alpha = (8.0f - idx) / 7.0f;
|
|
||||||
|
|
||||||
float beta = 1 - alpha;
|
int palette[4];
|
||||||
|
palette[0] = (block->col0.g << 2) | (block->col0.g >> 4);
|
||||||
|
palette[1] = (block->col1.g << 2) | (block->col1.g >> 4);
|
||||||
|
palette[2] = (2 * palette[0] + palette[1]) / 3;
|
||||||
|
palette[3] = (2 * palette[1] + palette[0]) / 3;
|
||||||
|
|
||||||
alpha2_sum += alpha * alpha;
|
int totalError = 0;
|
||||||
beta2_sum += beta * beta;
|
|
||||||
alphabeta_sum += alpha * beta;
|
for (int i = 0; i < 16; i++)
|
||||||
alphax_sum += alpha * rgba.color(i).a;
|
{
|
||||||
betax_sum += beta * rgba.color(i).a;
|
const int green = rgba.color(i).g;
|
||||||
|
|
||||||
|
int error = abs(green - palette[0]);
|
||||||
|
error = min(error, abs(green - palette[1]));
|
||||||
|
error = min(error, abs(green - palette[2]));
|
||||||
|
error = min(error, abs(green - palette[3]));
|
||||||
|
|
||||||
|
totalError += error;
|
||||||
|
}
|
||||||
|
|
||||||
|
return totalError;
|
||||||
}
|
}
|
||||||
|
|
||||||
const float factor = 1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
|
static uint computeGreenIndices(const ColorBlock & rgba, const Color32 palette[4])
|
||||||
|
|
||||||
float a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
|
|
||||||
float b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
|
|
||||||
|
|
||||||
uint alpha0 = uint(min(max(a, 0.0f), 255.0f));
|
|
||||||
uint alpha1 = uint(min(max(b, 0.0f), 255.0f));
|
|
||||||
|
|
||||||
if (alpha0 < alpha1)
|
|
||||||
{
|
{
|
||||||
swap(alpha0, alpha1);
|
const int color0 = palette[0].g;
|
||||||
|
const int color1 = palette[1].g;
|
||||||
|
const int color2 = palette[2].g;
|
||||||
|
const int color3 = palette[3].g;
|
||||||
|
|
||||||
|
uint indices = 0;
|
||||||
|
for (int i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
const int color = rgba.color(i).g;
|
||||||
|
|
||||||
|
uint d0 = abs(color0 - color);
|
||||||
|
uint d1 = abs(color1 - color);
|
||||||
|
uint d2 = abs(color2 - color);
|
||||||
|
uint d3 = abs(color3 - color);
|
||||||
|
|
||||||
|
uint b0 = d0 > d3;
|
||||||
|
uint b1 = d1 > d2;
|
||||||
|
uint b2 = d0 > d2;
|
||||||
|
uint b3 = d1 > d3;
|
||||||
|
uint b4 = d2 > d3;
|
||||||
|
|
||||||
|
uint x0 = b1 & b2;
|
||||||
|
uint x1 = b0 & b3;
|
||||||
|
uint x2 = b0 & b4;
|
||||||
|
|
||||||
|
indices |= (x2 | ((x0 | x1) << 1)) << (2 * i);
|
||||||
|
}
|
||||||
|
|
||||||
|
return indices;
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
namespace
|
||||||
|
{
|
||||||
|
|
||||||
|
static uint computeAlphaIndices(const ColorBlock & rgba, AlphaBlockDXT5 * block)
|
||||||
|
{
|
||||||
|
uint8 alphas[8];
|
||||||
|
block->evaluatePalette(alphas);
|
||||||
|
|
||||||
|
uint totalError = 0;
|
||||||
|
|
||||||
|
for (uint i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
uint8 alpha = rgba.color(i).a;
|
||||||
|
|
||||||
|
uint besterror = 256*256;
|
||||||
|
uint best = 8;
|
||||||
|
for(uint p = 0; p < 8; p++)
|
||||||
|
{
|
||||||
|
int d = alphas[p] - alpha;
|
||||||
|
uint error = d * d;
|
||||||
|
|
||||||
|
if (error < besterror)
|
||||||
|
{
|
||||||
|
besterror = error;
|
||||||
|
best = p;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
nvDebugCheck(best < 8);
|
||||||
|
|
||||||
|
totalError += besterror;
|
||||||
|
block->setIndex(i, best);
|
||||||
|
}
|
||||||
|
|
||||||
|
return totalError;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void optimizeAlpha8(const ColorBlock & rgba, AlphaBlockDXT5 * block)
|
||||||
|
{
|
||||||
|
float alpha2_sum = 0;
|
||||||
|
float beta2_sum = 0;
|
||||||
|
float alphabeta_sum = 0;
|
||||||
|
float alphax_sum = 0;
|
||||||
|
float betax_sum = 0;
|
||||||
|
|
||||||
// Flip indices:
|
|
||||||
for (int i = 0; i < 16; i++)
|
for (int i = 0; i < 16; i++)
|
||||||
{
|
{
|
||||||
uint idx = block->index(i);
|
uint idx = block->index(i);
|
||||||
if (idx < 2) block->setIndex(i, 1 - idx);
|
float alpha;
|
||||||
else block->setIndex(i, 9 - idx);
|
if (idx < 2) alpha = 1.0f - idx;
|
||||||
|
else alpha = (8.0f - idx) / 7.0f;
|
||||||
|
|
||||||
|
float beta = 1 - alpha;
|
||||||
|
|
||||||
|
alpha2_sum += alpha * alpha;
|
||||||
|
beta2_sum += beta * beta;
|
||||||
|
alphabeta_sum += alpha * beta;
|
||||||
|
alphax_sum += alpha * rgba.color(i).a;
|
||||||
|
betax_sum += beta * rgba.color(i).a;
|
||||||
}
|
}
|
||||||
}
|
|
||||||
else if (alpha0 == alpha1)
|
const float factor = 1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
|
||||||
{
|
|
||||||
for (int i = 0; i < 16; i++)
|
float a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
|
||||||
|
float b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
|
||||||
|
|
||||||
|
uint alpha0 = uint(min(max(a, 0.0f), 255.0f));
|
||||||
|
uint alpha1 = uint(min(max(b, 0.0f), 255.0f));
|
||||||
|
|
||||||
|
if (alpha0 < alpha1)
|
||||||
{
|
{
|
||||||
block->setIndex(i, 0);
|
swap(alpha0, alpha1);
|
||||||
|
|
||||||
|
// Flip indices:
|
||||||
|
for (int i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
uint idx = block->index(i);
|
||||||
|
if (idx < 2) block->setIndex(i, 1 - idx);
|
||||||
|
else block->setIndex(i, 9 - idx);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
else if (alpha0 == alpha1)
|
||||||
|
{
|
||||||
|
for (int i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
block->setIndex(i, 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
block->alpha0 = alpha0;
|
||||||
|
block->alpha1 = alpha1;
|
||||||
}
|
}
|
||||||
|
|
||||||
block->alpha0 = alpha0;
|
/*
|
||||||
block->alpha1 = alpha1;
|
static void optimizeAlpha6(const ColorBlock & rgba, AlphaBlockDXT5 * block)
|
||||||
}
|
{
|
||||||
|
float alpha2_sum = 0;
|
||||||
|
float beta2_sum = 0;
|
||||||
|
float alphabeta_sum = 0;
|
||||||
|
float alphax_sum = 0;
|
||||||
|
float betax_sum = 0;
|
||||||
|
|
||||||
|
for (int i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
uint8 x = rgba.color(i).a;
|
||||||
|
if (x == 0 || x == 255) continue;
|
||||||
|
|
||||||
|
uint bits = block->index(i);
|
||||||
|
if (bits == 6 || bits == 7) continue;
|
||||||
|
|
||||||
|
float alpha;
|
||||||
|
if (bits == 0) alpha = 1.0f;
|
||||||
|
else if (bits == 1) alpha = 0.0f;
|
||||||
|
else alpha = (6.0f - block->index(i)) / 5.0f;
|
||||||
|
|
||||||
|
float beta = 1 - alpha;
|
||||||
|
|
||||||
|
alpha2_sum += alpha * alpha;
|
||||||
|
beta2_sum += beta * beta;
|
||||||
|
alphabeta_sum += alpha * beta;
|
||||||
|
alphax_sum += alpha * x;
|
||||||
|
betax_sum += beta * x;
|
||||||
|
}
|
||||||
|
|
||||||
|
const float factor = 1.0f / (alpha2_sum * beta2_sum - alphabeta_sum * alphabeta_sum);
|
||||||
|
|
||||||
|
float a = (alphax_sum * beta2_sum - betax_sum * alphabeta_sum) * factor;
|
||||||
|
float b = (betax_sum * alpha2_sum - alphax_sum * alphabeta_sum) * factor;
|
||||||
|
|
||||||
|
uint alpha0 = uint(min(max(a, 0.0f), 255.0f));
|
||||||
|
uint alpha1 = uint(min(max(b, 0.0f), 255.0f));
|
||||||
|
|
||||||
|
if (alpha0 > alpha1)
|
||||||
|
{
|
||||||
|
swap(alpha0, alpha1);
|
||||||
|
}
|
||||||
|
|
||||||
|
block->alpha0 = alpha0;
|
||||||
|
block->alpha1 = alpha1;
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
|
||||||
|
static bool sameIndices(const AlphaBlockDXT5 & block0, const AlphaBlockDXT5 & block1)
|
||||||
|
{
|
||||||
|
const uint64 mask = ~uint64(0xFFFF);
|
||||||
|
return (block0.u | mask) == (block1.u | mask);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
@ -436,66 +593,6 @@ void QuickCompress::compressDXT1a(const ColorBlock & rgba, BlockDXT1 * dxtBlock)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
static int computeGreenError(const ColorBlock & rgba, const BlockDXT1 * block)
|
|
||||||
{
|
|
||||||
nvDebugCheck(block != NULL);
|
|
||||||
|
|
||||||
int palette[4];
|
|
||||||
palette[0] = (block->col0.g << 2) | (block->col0.g >> 4);
|
|
||||||
palette[1] = (block->col1.g << 2) | (block->col1.g >> 4);
|
|
||||||
palette[2] = (2 * palette[0] + palette[1]) / 3;
|
|
||||||
palette[3] = (2 * palette[1] + palette[0]) / 3;
|
|
||||||
|
|
||||||
int totalError = 0;
|
|
||||||
|
|
||||||
for (int i = 0; i < 16; i++)
|
|
||||||
{
|
|
||||||
const int green = rgba.color(i).g;
|
|
||||||
|
|
||||||
int error = abs(green - palette[0]);
|
|
||||||
error = min(error, abs(green - palette[1]));
|
|
||||||
error = min(error, abs(green - palette[2]));
|
|
||||||
error = min(error, abs(green - palette[3]));
|
|
||||||
|
|
||||||
totalError += error;
|
|
||||||
}
|
|
||||||
|
|
||||||
return totalError;
|
|
||||||
}
|
|
||||||
|
|
||||||
static uint computeGreenIndices(const ColorBlock & rgba, const Color32 palette[4])
|
|
||||||
{
|
|
||||||
const int color0 = palette[0].g;
|
|
||||||
const int color1 = palette[1].g;
|
|
||||||
const int color2 = palette[2].g;
|
|
||||||
const int color3 = palette[3].g;
|
|
||||||
|
|
||||||
uint indices = 0;
|
|
||||||
for (int i = 0; i < 16; i++)
|
|
||||||
{
|
|
||||||
const int color = rgba.color(i).g;
|
|
||||||
|
|
||||||
uint d0 = abs(color0 - color);
|
|
||||||
uint d1 = abs(color1 - color);
|
|
||||||
uint d2 = abs(color2 - color);
|
|
||||||
uint d3 = abs(color3 - color);
|
|
||||||
|
|
||||||
uint b0 = d0 > d3;
|
|
||||||
uint b1 = d1 > d2;
|
|
||||||
uint b2 = d0 > d2;
|
|
||||||
uint b3 = d1 > d3;
|
|
||||||
uint b4 = d2 > d3;
|
|
||||||
|
|
||||||
uint x0 = b1 & b2;
|
|
||||||
uint x1 = b0 & b3;
|
|
||||||
uint x2 = b0 & b4;
|
|
||||||
|
|
||||||
indices |= (x2 | ((x0 | x1) << 1)) << (2 * i);
|
|
||||||
}
|
|
||||||
|
|
||||||
return indices;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Brute force green channel compressor
|
// Brute force green channel compressor
|
||||||
void QuickCompress::compressDXT1G(const ColorBlock & rgba, BlockDXT1 * block)
|
void QuickCompress::compressDXT1G(const ColorBlock & rgba, BlockDXT1 * block)
|
||||||
{
|
{
|
||||||
|
@ -558,6 +655,7 @@ void QuickCompress::compressDXT1G(const ColorBlock & rgba, BlockDXT1 * block)
|
||||||
|
|
||||||
void QuickCompress::compressDXT3A(const ColorBlock & rgba, AlphaBlockDXT3 * dxtBlock)
|
void QuickCompress::compressDXT3A(const ColorBlock & rgba, AlphaBlockDXT3 * dxtBlock)
|
||||||
{
|
{
|
||||||
|
// @@ Round instead of truncate. When rounding take into account bit expansion.
|
||||||
dxtBlock->alpha0 = rgba.color(0).a >> 4;
|
dxtBlock->alpha0 = rgba.color(0).a >> 4;
|
||||||
dxtBlock->alpha1 = rgba.color(1).a >> 4;
|
dxtBlock->alpha1 = rgba.color(1).a >> 4;
|
||||||
dxtBlock->alpha2 = rgba.color(2).a >> 4;
|
dxtBlock->alpha2 = rgba.color(2).a >> 4;
|
||||||
|
@ -582,9 +680,49 @@ void QuickCompress::compressDXT3(const ColorBlock & rgba, BlockDXT3 * dxtBlock)
|
||||||
compressDXT3A(rgba, &dxtBlock->alpha);
|
compressDXT3A(rgba, &dxtBlock->alpha);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
void QuickCompress::compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtBlock)
|
void QuickCompress::compressDXT5A(const ColorBlock & rgba, AlphaBlockDXT5 * dxtBlock)
|
||||||
{
|
{
|
||||||
// @@ TODO
|
uint8 alpha0 = 0;
|
||||||
|
uint8 alpha1 = 255;
|
||||||
|
|
||||||
|
// Get min/max alpha.
|
||||||
|
for (uint i = 0; i < 16; i++)
|
||||||
|
{
|
||||||
|
uint8 alpha = rgba.color(i).a;
|
||||||
|
alpha0 = max(alpha0, alpha);
|
||||||
|
alpha1 = min(alpha1, alpha);
|
||||||
|
}
|
||||||
|
|
||||||
|
AlphaBlockDXT5 block;
|
||||||
|
block.alpha0 = alpha0 - (alpha0 - alpha1) / 34;
|
||||||
|
block.alpha1 = alpha1 + (alpha0 - alpha1) / 34;
|
||||||
|
uint besterror = computeAlphaIndices(rgba, &block);
|
||||||
|
|
||||||
|
AlphaBlockDXT5 bestblock = block;
|
||||||
|
|
||||||
|
while(true)
|
||||||
|
{
|
||||||
|
optimizeAlpha8(rgba, &block);
|
||||||
|
uint error = computeAlphaIndices(rgba, &block);
|
||||||
|
|
||||||
|
if (error >= besterror)
|
||||||
|
{
|
||||||
|
// No improvement, stop.
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if (sameIndices(block, bestblock))
|
||||||
|
{
|
||||||
|
bestblock = block;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
besterror = error;
|
||||||
|
bestblock = block;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Copy best block to result;
|
||||||
|
*dxtBlock = bestblock;
|
||||||
}
|
}
|
||||||
|
|
||||||
void QuickCompress::compressDXT5(const ColorBlock & rgba, BlockDXT5 * dxtBlock)
|
void QuickCompress::compressDXT5(const ColorBlock & rgba, BlockDXT5 * dxtBlock)
|
||||||
|
|
|
@ -24,13 +24,12 @@
|
||||||
#include <nvcore/Debug.h>
|
#include <nvcore/Debug.h>
|
||||||
#include <nvcore/Containers.h>
|
#include <nvcore/Containers.h>
|
||||||
#include <nvmath/Color.h>
|
#include <nvmath/Color.h>
|
||||||
#include <nvmath/Fitting.h>
|
|
||||||
#include <nvimage/Image.h>
|
#include <nvimage/Image.h>
|
||||||
#include <nvimage/ColorBlock.h>
|
#include <nvimage/ColorBlock.h>
|
||||||
#include <nvimage/BlockDXT.h>
|
#include <nvimage/BlockDXT.h>
|
||||||
#include <nvtt/CompressionOptions.h>
|
#include <nvtt/CompressionOptions.h>
|
||||||
#include <nvtt/OutputOptions.h>
|
#include <nvtt/OutputOptions.h>
|
||||||
#include <nvtt/FastCompressDXT.h>
|
#include <nvtt/QuickCompressDXT.h>
|
||||||
|
|
||||||
#include "CudaCompressDXT.h"
|
#include "CudaCompressDXT.h"
|
||||||
#include "CudaUtils.h"
|
#include "CudaUtils.h"
|
||||||
|
@ -228,7 +227,7 @@ void CudaCompressor::compressDXT3(const Image * image, const OutputOptions::Priv
|
||||||
for (uint i = 0; i < count; i++)
|
for (uint i = 0; i < count; i++)
|
||||||
{
|
{
|
||||||
ColorBlock rgba(blockLinearImage + (bn + i) * 16);
|
ColorBlock rgba(blockLinearImage + (bn + i) * 16);
|
||||||
compressBlock(rgba, alphaBlocks + i);
|
QuickCompress::compressDXT5A(rgba, alphaBlocks + i);
|
||||||
}
|
}
|
||||||
|
|
||||||
// Check for errors.
|
// Check for errors.
|
||||||
|
@ -312,7 +311,7 @@ void CudaCompressor::compressDXT5(const Image * image, const OutputOptions::Priv
|
||||||
for (uint i = 0; i < count; i++)
|
for (uint i = 0; i < count; i++)
|
||||||
{
|
{
|
||||||
ColorBlock rgba(blockLinearImage + (bn + i) * 16);
|
ColorBlock rgba(blockLinearImage + (bn + i) * 16);
|
||||||
compressBlock_Iterative(rgba, alphaBlocks + i);
|
QuickCompress::compressDXT5A(rgba, alphaBlocks + i);
|
||||||
}
|
}
|
||||||
|
|
||||||
// Check for errors.
|
// Check for errors.
|
||||||
|
|
Loading…
Reference in New Issue
Block a user