drewcassidy/nvidia-texture-tools
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Use tabs.

Browse Source
This commit is contained in:
castano 2010-10-22 05:12:35 +00:00
parent 09e46ead48
commit 188d5043d8
1 changed files with 379 additions and 379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

758
src/nvtt/tests/testsuite.cpp
View File

@ -42,490 +42,490 @@ using namespace nv;
// Kodak image set // Kodak image set
static const char * s_kodakImageSet[] = { static const char * s_kodakImageSet[] = {
"kodim01.png", "kodim01.png",
"kodim02.png", "kodim02.png",
"kodim03.png", "kodim03.png",
"kodim04.png", "kodim04.png",
"kodim05.png", "kodim05.png",
"kodim06.png", "kodim06.png",
"kodim07.png", "kodim07.png",
"kodim08.png", "kodim08.png",
"kodim09.png", "kodim09.png",
"kodim10.png", "kodim10.png",
"kodim11.png", "kodim11.png",
"kodim12.png", "kodim12.png",
"kodim13.png", "kodim13.png",
"kodim14.png", "kodim14.png",
"kodim15.png", "kodim15.png",
"kodim16.png", "kodim16.png",
"kodim17.png", "kodim17.png",
"kodim18.png", "kodim18.png",
"kodim19.png", "kodim19.png",
"kodim20.png", "kodim20.png",
"kodim21.png", "kodim21.png",
"kodim22.png", "kodim22.png",
"kodim23.png", "kodim23.png",
"kodim24.png", "kodim24.png",
}; };
// Waterloo image set // Waterloo image set
static const char * s_waterlooImageSet[] = { static const char * s_waterlooImageSet[] = {
"clegg.png", "clegg.png",
"frymire.png", "frymire.png",
"lena.png", "lena.png",
"monarch.png", "monarch.png",
"peppers.png", "peppers.png",
"sail.png", "sail.png",
"serrano.png", "serrano.png",
"tulips.png", "tulips.png",
}; };
// Epic image set // Epic image set
static const char * s_epicImageSet[] = { static const char * s_epicImageSet[] = {
"Bradley1.png", "Bradley1.png",
"Gradient.png", "Gradient.png",
"MoreRocks.png", "MoreRocks.png",
"Wall.png", "Wall.png",
"Rainbow.png", "Rainbow.png",
"Text.png", "Text.png",
}; };
// Farbrausch // Farbrausch
static const char * s_farbrauschImageSet[] = { static const char * s_farbrauschImageSet[] = {
"t.2d.pn02.bmp", "t.2d.pn02.bmp",
"t.aircondition.01.bmp", "t.aircondition.01.bmp",
"t.bricks.02.bmp", "t.bricks.02.bmp",
"t.bricks.05.bmp", "t.bricks.05.bmp",
"t.concrete.cracked.01.bmp", "t.concrete.cracked.01.bmp",
"t.envi.colored02.bmp", "t.envi.colored02.bmp",
"t.envi.colored03.bmp", "t.envi.colored03.bmp",
"t.font.01.bmp", "t.font.01.bmp",
"t.sewers.01.bmp", "t.sewers.01.bmp",
"t.train.03.bmp", "t.train.03.bmp",
"t.yello.01.bmp", "t.yello.01.bmp",
}; };
// Lugaru // Lugaru
static const char * s_lugaruImageSet[] = { static const char * s_lugaruImageSet[] = {
"lugaru-blood.png", "lugaru-blood.png",
"lugaru-bush.png", "lugaru-bush.png",
"lugaru-cursor.png", "lugaru-cursor.png",
"lugaru-hawk.png", "lugaru-hawk.png",
}; };
// Quake3 // Quake3
static const char * s_quake3ImageSet[] = { static const char * s_quake3ImageSet[] = {
"q3-blocks15cgeomtrn.tga", "q3-blocks15cgeomtrn.tga",
"q3-blocks17bloody.tga", "q3-blocks17bloody.tga",
"q3-dark_tin2.tga", "q3-dark_tin2.tga",
"q3-fan_grate.tga", "q3-fan_grate.tga",
"q3-fan.tga", "q3-fan.tga",
"q3-metal2_2.tga", "q3-metal2_2.tga",
"q3-panel_glo.tga", "q3-panel_glo.tga",
"q3-proto_fence.tga", "q3-proto_fence.tga",
"q3-wires02.tga", "q3-wires02.tga",
}; };
struct ImageSet struct ImageSet
{ {
const char ** fileNames; const char ** fileNames;
int fileCount; int fileCount;
nvtt::Format format; nvtt::Format format;
}; };
static ImageSet s_imageSets[] = { static ImageSet s_imageSets[] = {
{s_kodakImageSet, sizeof(s_kodakImageSet)/sizeof(s_kodakImageSet[0]), nvtt::Format_DXT1}, {s_kodakImageSet, sizeof(s_kodakImageSet)/sizeof(s_kodakImageSet[0]), nvtt::Format_DXT1},
{s_waterlooImageSet, sizeof(s_waterlooImageSet)/sizeof(s_waterlooImageSet[0]), nvtt::Format_DXT1}, {s_waterlooImageSet, sizeof(s_waterlooImageSet)/sizeof(s_waterlooImageSet[0]), nvtt::Format_DXT1},
{s_epicImageSet, sizeof(s_epicImageSet)/sizeof(s_epicImageSet[0]), nvtt::Format_DXT1}, {s_epicImageSet, sizeof(s_epicImageSet)/sizeof(s_epicImageSet[0]), nvtt::Format_DXT1},
{s_farbrauschImageSet, sizeof(s_farbrauschImageSet)/sizeof(s_farbrauschImageSet[0]), nvtt::Format_DXT1}, {s_farbrauschImageSet, sizeof(s_farbrauschImageSet)/sizeof(s_farbrauschImageSet[0]), nvtt::Format_DXT1},
{s_lugaruImageSet, sizeof(s_lugaruImageSet)/sizeof(s_lugaruImageSet[0]), nvtt::Format_DXT5}, {s_lugaruImageSet, sizeof(s_lugaruImageSet)/sizeof(s_lugaruImageSet[0]), nvtt::Format_DXT5},
{s_quake3ImageSet, sizeof(s_quake3ImageSet)/sizeof(s_quake3ImageSet[0]), nvtt::Format_DXT5}, {s_quake3ImageSet, sizeof(s_quake3ImageSet)/sizeof(s_quake3ImageSet[0]), nvtt::Format_DXT5},
}; };
const int s_imageSetCount = sizeof(s_imageSets)/sizeof(s_imageSets[0]); const int s_imageSetCount = sizeof(s_imageSets)/sizeof(s_imageSets[0]);
enum Decoder enum Decoder
{ {
Decoder_Reference, Decoder_Reference,
Decoder_NVIDIA, Decoder_NVIDIA,
}; };
struct MyOutputHandler : public nvtt::OutputHandler struct MyOutputHandler : public nvtt::OutputHandler
{ {
MyOutputHandler() : m_data(NULL), m_ptr(NULL) {} MyOutputHandler() : m_data(NULL), m_ptr(NULL) {}
~MyOutputHandler() ~MyOutputHandler()
{ {
free(m_data); free(m_data);
} }
virtual void beginImage(int size, int width, int height, int depth, int face, int miplevel) virtual void beginImage(int size, int width, int height, int depth, int face, int miplevel)
{ {
m_size = size; m_size = size;
m_width = width; m_width = width;
m_height = height; m_height = height;
free(m_data); free(m_data);
m_data = (unsigned char *)malloc(size); m_data = (unsigned char *)malloc(size);
m_ptr = m_data; m_ptr = m_data;
} }
virtual bool writeData(const void * data, int size)
{
memcpy(m_ptr, data, size);
m_ptr += size;
return true;
}
Image * decompress(nvtt::Format format, Decoder decoder) virtual bool writeData(const void * data, int size)
{ {
int bw = (m_width + 3) / 4; memcpy(m_ptr, data, size);
int bh = (m_height + 3) / 4; m_ptr += size;
return true;
}
AutoPtr<Image> img( new Image() ); Image * decompress(nvtt::Format format, Decoder decoder)
img->allocate(m_width, m_height); {
int bw = (m_width + 3) / 4;
int bh = (m_height + 3) / 4;
if (format == nvtt::Format_BC1) AutoPtr<Image> img( new Image() );
{ img->allocate(m_width, m_height);
BlockDXT1 * block = (BlockDXT1 *)m_data;
for (int y = 0; y < bh; y++) if (format == nvtt::Format_BC1)
{ {
for (int x = 0; x < bw; x++) BlockDXT1 * block = (BlockDXT1 *)m_data;
{
ColorBlock colors;
if (decoder == Decoder_Reference) {
block->decodeBlock(&colors);
}
else if (decoder == Decoder_NVIDIA) {
block->decodeBlockNV5x(&colors);
}
for (int yy = 0; yy < 4; yy++) for (int y = 0; y < bh; y++)
{ {
for (int xx = 0; xx < 4; xx++) for (int x = 0; x < bw; x++)
{ {
Color32 c = colors.color(xx, yy); ColorBlock colors;
if (decoder == Decoder_Reference) {
block->decodeBlock(&colors);
}
else if (decoder == Decoder_NVIDIA) {
block->decodeBlockNV5x(&colors);
}
if (x * 4 + xx < m_width && y * 4 + yy < m_height) for (int yy = 0; yy < 4; yy++)
{ {
img->pixel(x * 4 + xx, y * 4 + yy) = c; for (int xx = 0; xx < 4; xx++)
} {
} Color32 c = colors.color(xx, yy);
}
block++; if (x * 4 + xx < m_width && y * 4 + yy < m_height)
} {
} img->pixel(x * 4 + xx, y * 4 + yy) = c;
} }
else if (format == nvtt::Format_BC3) }
{ }
BlockDXT5 * block = (BlockDXT5 *)m_data;
for (int y = 0; y < bh; y++) block++;
{ }
for (int x = 0; x < bw; x++) }
{ }
ColorBlock colors; else if (format == nvtt::Format_BC3)
if (decoder == Decoder_Reference) { {
block->decodeBlock(&colors); BlockDXT5 * block = (BlockDXT5 *)m_data;
}
else if (decoder == Decoder_NVIDIA) {
block->decodeBlockNV5x(&colors);
}
for (int yy = 0; yy < 4; yy++) for (int y = 0; y < bh; y++)
{ {
for (int xx = 0; xx < 4; xx++) for (int x = 0; x < bw; x++)
{ {
Color32 c = colors.color(xx, yy); ColorBlock colors;
if (decoder == Decoder_Reference) {
block->decodeBlock(&colors);
}
else if (decoder == Decoder_NVIDIA) {
block->decodeBlockNV5x(&colors);
}
if (x * 4 + xx < m_width && y * 4 + yy < m_height) for (int yy = 0; yy < 4; yy++)
{ {
img->pixel(x * 4 + xx, y * 4 + yy) = c; for (int xx = 0; xx < 4; xx++)
} {
} Color32 c = colors.color(xx, yy);
}
block++; if (x * 4 + xx < m_width && y * 4 + yy < m_height)
} {
} img->pixel(x * 4 + xx, y * 4 + yy) = c;
} }
}
}
block++;
}
}
}
return img.release(); return img.release();
} }
int m_size; int m_size;
int m_width; int m_width;
int m_height; int m_height;
unsigned char * m_data; unsigned char * m_data;
unsigned char * m_ptr; unsigned char * m_ptr;
}; };
float rmsError(const Image * a, const Image * b) float rmsError(const Image * a, const Image * b)
{ {
nvCheck(a != NULL); nvCheck(a != NULL);
nvCheck(b != NULL); nvCheck(b != NULL);
nvCheck(a->width() == b->width()); nvCheck(a->width() == b->width());
nvCheck(a->height() == b->height()); nvCheck(a->height() == b->height());
double mse = 0; double mse = 0;
const uint count = a->width() * a->height(); const uint count = a->width() * a->height();
for (uint i = 0; i < count; i++) for (uint i = 0; i < count; i++)
{ {
Color32 c0 = a->pixel(i); Color32 c0 = a->pixel(i);
Color32 c1 = b->pixel(i); Color32 c1 = b->pixel(i);
int r = c0.r - c1.r; int r = c0.r - c1.r;
int g = c0.g - c1.g; int g = c0.g - c1.g;
int b = c0.b - c1.b; int b = c0.b - c1.b;
int a = c0.a - c1.a; int a = c0.a - c1.a;
mse += double(r * r * c0.a) / 255; mse += double(r * r * c0.a) / 255;
mse += double(g * g * c0.a) / 255; mse += double(g * g * c0.a) / 255;
mse += double(b * b * c0.a) / 255; mse += double(b * b * c0.a) / 255;
} }
return float(sqrt(mse / count)); return float(sqrt(mse / count));
} }
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
const uint version = nvtt::version(); const uint version = nvtt::version();
const uint major = version / 100; const uint major = version / 100;
const uint minor = version % 100; const uint minor = version % 100;
printf("NVIDIA Texture Tools %u.%u - Copyright NVIDIA Corporation 2007 - 2008\n\n", major, minor);
int set = 0;
bool fast = false;
bool nocuda = false;
bool showHelp = false;
Decoder decoder = Decoder_Reference;
const char * basePath = "";
const char * outPath = "output";
const char * regressPath = NULL;
// Parse arguments.
for (int i = 1; i < argc; i++)
{
if (strcmp("-set", argv[i]) == 0)
{
if (i+1 < argc && argv[i+1][0] != '-') {
set = atoi(argv[i+1]);
i++;
}
}
else if (strcmp("-dec", argv[i]) == 0)
{
if (i+1 < argc && argv[i+1][0] != '-') {
decoder = (Decoder)atoi(argv[i+1]);
i++;
}
}
else if (strcmp("-fast", argv[i]) == 0)
{
fast = true;
}
else if (strcmp("-nocuda", argv[i]) == 0)
{
nocuda = true;
}
else if (strcmp("-help", argv[i]) == 0)
{
showHelp = true;
}
else if (strcmp("-path", argv[i]) == 0)
{
if (i+1 < argc && argv[i+1][0] != '-') {
basePath = argv[i+1];
i++;
}
}
else if (strcmp("-out", argv[i]) == 0)
{
if (i+1 < argc && argv[i+1][0] != '-') {
outPath = argv[i+1];
i++;
}
}
else if (strcmp("-regress", argv[i]) == 0)
{
if (i+1 < argc && argv[i+1][0] != '-') {
regressPath = argv[i+1];
i++;
}
}
}
if (showHelp) printf("NVIDIA Texture Tools %u.%u - Copyright NVIDIA Corporation 2007 - 2008\n\n", major, minor);
{
printf("usage: nvtestsuite [options]\n\n"); int set = 0;
bool fast = false;
printf("Input options:\n"); bool nocuda = false;
printf(" -path <path> \tInput image path.\n"); bool showHelp = false;
printf(" -regress <path>\tRegression directory.\n"); Decoder decoder = Decoder_Reference;
printf(" -set [0:2] \tImage set.\n"); const char * basePath = "";
printf(" 0: \tKodak.\n"); const char * outPath = "output";
printf(" 1: \tWaterloo.\n"); const char * regressPath = NULL;
printf(" 2: \tEpic.\n");
printf(" 3: \tFarbrausch.\n"); // Parse arguments.
for (int i = 1; i < argc; i++)
{
if (strcmp("-set", argv[i]) == 0)
{
if (i+1 < argc && argv[i+1][0] != '-') {
set = atoi(argv[i+1]);
i++;
}
}
else if (strcmp("-dec", argv[i]) == 0)
{
if (i+1 < argc && argv[i+1][0] != '-') {
decoder = (Decoder)atoi(argv[i+1]);
i++;
}
}
else if (strcmp("-fast", argv[i]) == 0)
{
fast = true;
}
else if (strcmp("-nocuda", argv[i]) == 0)
{
nocuda = true;
}
else if (strcmp("-help", argv[i]) == 0)
{
showHelp = true;
}
else if (strcmp("-path", argv[i]) == 0)
{
if (i+1 < argc && argv[i+1][0] != '-') {
basePath = argv[i+1];
i++;
}
}
else if (strcmp("-out", argv[i]) == 0)
{
if (i+1 < argc && argv[i+1][0] != '-') {
outPath = argv[i+1];
i++;
}
}
else if (strcmp("-regress", argv[i]) == 0)
{
if (i+1 < argc && argv[i+1][0] != '-') {
regressPath = argv[i+1];
i++;
}
}
}
if (showHelp)
{
printf("usage: nvtestsuite [options]\n\n");
printf("Input options:\n");
printf(" -path <path> \tInput image path.\n");
printf(" -regress <path>\tRegression directory.\n");
printf(" -set [0:2] \tImage set.\n");
printf(" 0: \tKodak.\n");
printf(" 1: \tWaterloo.\n");
printf(" 2: \tEpic.\n");
printf(" 3: \tFarbrausch.\n");
printf(" 4: \tLugaru.\n"); printf(" 4: \tLugaru.\n");
printf(" 5: \tQuake 3.\n"); printf(" 5: \tQuake 3.\n");
printf(" -dec x \tDecompressor.\n"); printf(" -dec x \tDecompressor.\n");
printf(" 0: \tReference.\n"); printf(" 0: \tReference.\n");
printf(" 1: \tNVIDIA.\n"); printf(" 1: \tNVIDIA.\n");
printf("Compression options:\n"); printf("Compression options:\n");
printf(" -fast \tFast compression.\n"); printf(" -fast \tFast compression.\n");
printf(" -nocuda \tDo not use cuda compressor.\n"); printf(" -nocuda \tDo not use cuda compressor.\n");
printf("Output options:\n");
printf(" -out <path> \tOutput directory.\n");
return 1; printf("Output options:\n");
} printf(" -out <path> \tOutput directory.\n");
nvtt::InputOptions inputOptions;
inputOptions.setMipmapGeneration(false);
inputOptions.setAlphaMode(nvtt::AlphaMode_Transparency);
nvtt::CompressionOptions compressionOptions; return 1;
compressionOptions.setFormat(nvtt::Format_BC1); }
if (fast)
{
compressionOptions.setQuality(nvtt::Quality_Fastest);
}
else
{
compressionOptions.setQuality(nvtt::Quality_Production);
}
//compressionOptions.setExternalCompressor("ati");
//compressionOptions.setExternalCompressor("squish");
//compressionOptions.setExternalCompressor("d3dx");
//compressionOptions.setExternalCompressor("stb");
compressionOptions.setFormat(s_imageSets[set].format); nvtt::InputOptions inputOptions;
inputOptions.setMipmapGeneration(false);
inputOptions.setAlphaMode(nvtt::AlphaMode_Transparency);
nvtt::CompressionOptions compressionOptions;
compressionOptions.setFormat(nvtt::Format_BC1);
if (fast)
{
compressionOptions.setQuality(nvtt::Quality_Fastest);
}
else
{
compressionOptions.setQuality(nvtt::Quality_Production);
}
//compressionOptions.setExternalCompressor("ati");
//compressionOptions.setExternalCompressor("squish");
//compressionOptions.setExternalCompressor("d3dx");
//compressionOptions.setExternalCompressor("stb");
compressionOptions.setFormat(s_imageSets[set].format);
nvtt::OutputOptions outputOptions; nvtt::OutputOptions outputOptions;
outputOptions.setOutputHeader(false); outputOptions.setOutputHeader(false);
MyOutputHandler outputHandler; MyOutputHandler outputHandler;
outputOptions.setOutputHandler(&outputHandler); outputOptions.setOutputHandler(&outputHandler);
nvtt::Context context; nvtt::Context context;
context.enableCudaAcceleration(!nocuda); context.enableCudaAcceleration(!nocuda);
FileSystem::changeDirectory(basePath); FileSystem::changeDirectory(basePath);
FileSystem::createDirectory(outPath); FileSystem::createDirectory(outPath);
Path csvFileName; Path csvFileName;
csvFileName.format("%s/result-%d.csv", outPath, set); csvFileName.format("%s/result-%d.csv", outPath, set);
StdOutputStream csvStream(csvFileName.str()); StdOutputStream csvStream(csvFileName.str());
TextWriter csvWriter(&csvStream); TextWriter csvWriter(&csvStream);
float totalTime = 0; float totalTime = 0;
float totalRMSE = 0; float totalRMSE = 0;
int failedTests = 0; int failedTests = 0;
float totalDiff = 0; float totalDiff = 0;
const char ** fileNames = s_imageSets[set].fileNames; const char ** fileNames = s_imageSets[set].fileNames;
int fileCount = s_imageSets[set].fileCount; int fileCount = s_imageSets[set].fileCount;
Timer timer; Timer timer;
for (int i = 0; i < fileCount; i++) for (int i = 0; i < fileCount; i++)
{ {
AutoPtr<Image> img( new Image() ); AutoPtr<Image> img( new Image() );
if (!img->load(fileNames[i]))
{
printf("Input image '%s' not found.\n", fileNames[i]);
return EXIT_FAILURE;
}
inputOptions.setTextureLayout(nvtt::TextureType_2D, img->width(), img->height()); if (!img->load(fileNames[i]))
inputOptions.setMipmapData(img->pixels(), img->width(), img->height()); {
printf("Input image '%s' not found.\n", fileNames[i]);
return EXIT_FAILURE;
}
printf("Compressing: \t'%s'\n", fileNames[i]); inputOptions.setTextureLayout(nvtt::TextureType_2D, img->width(), img->height());
inputOptions.setMipmapData(img->pixels(), img->width(), img->height());
timer.start(); printf("Compressing: \t'%s'\n", fileNames[i]);
context.process(inputOptions, compressionOptions, outputOptions); timer.start();
timer.stop(); context.process(inputOptions, compressionOptions, outputOptions);
printf(" Time: \t%.3f sec\n", float(timer.elapsed()) / 1000);
totalTime += float(timer.elapsed()) / 1000;
AutoPtr<Image> img_out( outputHandler.decompress(s_imageSets[set].format, decoder) ); timer.stop();
printf(" Time: \t%.3f sec\n", float(timer.elapsed()) / 1000);
totalTime += float(timer.elapsed()) / 1000;
Path outputFileName; AutoPtr<Image> img_out( outputHandler.decompress(s_imageSets[set].format, decoder) );
outputFileName.format("%s/%s", outPath, fileNames[i]);
outputFileName.stripExtension();
outputFileName.append(".png");
if (!ImageIO::save(outputFileName.str(), img_out.ptr()))
{
printf("Error saving file '%s'.\n", outputFileName.str());
}
float rmse = rmsError(img.ptr(), img_out.ptr()); Path outputFileName;
totalRMSE += rmse; outputFileName.format("%s/%s", outPath, fileNames[i]);
outputFileName.stripExtension();
outputFileName.append(".png");
if (!ImageIO::save(outputFileName.str(), img_out.ptr()))
{
printf("Error saving file '%s'.\n", outputFileName.str());
}
printf(" RMSE: \t%.4f\n", rmse); float rmse = rmsError(img.ptr(), img_out.ptr());
totalRMSE += rmse;
// Output csv file printf(" RMSE: \t%.4f\n", rmse);
csvWriter << "\"" << fileNames[i] << "\"," << rmse << "\n";
if (regressPath != NULL) // Output csv file
{ csvWriter << "\"" << fileNames[i] << "\"," << rmse << "\n";
Path regressFileName;
regressFileName.format("%s/%s", regressPath, fileNames[i]);
regressFileName.stripExtension();
regressFileName.append(".png");
AutoPtr<Image> img_reg( new Image() ); if (regressPath != NULL)
if (!img_reg->load(regressFileName.str())) {
{ Path regressFileName;
printf("Regression image '%s' not found.\n", regressFileName.str()); regressFileName.format("%s/%s", regressPath, fileNames[i]);
return EXIT_FAILURE; regressFileName.stripExtension();
} regressFileName.append(".png");
float rmse_reg = rmsError(img.ptr(), img_reg.ptr()); AutoPtr<Image> img_reg( new Image() );
if (!img_reg->load(regressFileName.str()))
{
printf("Regression image '%s' not found.\n", regressFileName.str());
return EXIT_FAILURE;
}
float diff = rmse_reg - rmse; float rmse_reg = rmsError(img.ptr(), img_reg.ptr());
totalDiff += diff;
const char * text = "PASSED"; float diff = rmse_reg - rmse;
if (equal(diff, 0)) text = "PASSED"; totalDiff += diff;
else if (diff < 0) {
text = "FAILED";
failedTests++;
}
printf(" Diff: \t%.4f (%s)\n", diff, text); const char * text = "PASSED";
} if (equal(diff, 0)) text = "PASSED";
else if (diff < 0) {
text = "FAILED";
failedTests++;
}
fflush(stdout); printf(" Diff: \t%.4f (%s)\n", diff, text);
} }
totalRMSE /= fileCount; fflush(stdout);
totalDiff /= fileCount; }
printf("Total Results:\n"); totalRMSE /= fileCount;
printf(" Total Time: \t%.3f sec\n", totalTime); totalDiff /= fileCount;
printf(" Average RMSE:\t%.4f\n", totalRMSE);
if (regressPath != NULL) printf("Total Results:\n");
{ printf(" Total Time: \t%.3f sec\n", totalTime);
printf("Regression Results:\n"); printf(" Average RMSE:\t%.4f\n", totalRMSE);
printf(" Diff: %.4f\n", totalDiff);
printf(" %d/%d tests failed.\n", failedTests, fileCount);
}
return EXIT_SUCCESS; if (regressPath != NULL)
{
printf("Regression Results:\n");
printf(" Diff: %.4f\n", totalDiff);
printf(" %d/%d tests failed.\n", failedTests, fileCount);
}
return EXIT_SUCCESS;
} }