stefan
/
NLMSvariants
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

removed free(localWeights), changed help function from -x to -g true for graphing

This commit is contained in:
gurkenhabicht 2018-05-24 14:15:36 +02:00
parent 9955d5871b
commit 70cb5e399b
2 changed files with 244 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/ansi_c_implementation/NLMSvariants.c
View File

@ -265,7 +265,7 @@ void localMean ( mldata_t *mlData, point_t points[] ) {
deviation /= xErrorLength; // Deviation
printf("mean:%lf, devitation:%lf\t\tlocal Mean\n", mean, deviation);
fprintf(fp4, "\nQuadratische Varianz(x_error): %f\nMittelwert:(x_error): %f\n\n", deviation, mean); // Write to logfile
free(localWeights);
// free(localWeights);
free(xErrorPtr);
free(xError);
@ -353,7 +353,7 @@ void directPredecessor( mldata_t *mlData, point_t points[]) {
printf("mean:%lf, devitation:%lf\t\tdirect Predecessor\n", mean, deviation);
fprintf(fp3, "\nQuadratische Varianz(x_error): %f\nMittelwert:(x_error): %f\n\n", deviation, mean);
fclose(fp3);
free(localWeights);
// free(localWeights);
free(xErrorPtr);
free(xError);
}
@ -438,7 +438,7 @@ void differentialPredecessor ( mldata_t *mlData, point_t points[] ) {
printf("mean:%lf, devitation:%lf\t\tdifferential Predecessor\n", mean, deviation);
fprintf(fp6, "\nQuadratische Varianz(x_error): %f\nMittelwert:(x_error): %f\n\n", deviation, mean);
fclose(fp6);
free(localWeights);
// free(localWeights);
free(xErrorPtr);
free(xError);
@ -884,7 +884,7 @@ void usage ( char **argv ) {
printf("\t-c <color>\t\tUse this color channel from inputfile.\n");
printf("\t-w <digit>\t\tCount of used weights (windowSize).\n");
printf("\t-l <digit>\t\tLearnrate, 0 < learnrate < 1.\n");
printf("\t-x true\t\t\tLogfiles only, no graph building.\n\t\t\t\tChoose for intense amount of input data.\n");
printf("\t-g true\t\t\tGraph building.\n\t\t\t\tChoose for n < 1200.\n");
printf("\t-s <digit>\t\tDigit for random seed generator.\n\t\t\t\tSame Digits produce same random values. Default is srand by time.\n");
printf("\n\n");
printf("%s compares prediction methods of least mean square filters.\nBy default it reads ppm file format and return logfiles as well\nas an svg graphs as an output of said least mean square methods.\n\nExample:\n\t%s -i myimage.ppm -w 3 -c green -s 5 -x true\n", &argv[0][0], &argv[0][0]);

255
src/cpp_implementation/NLMSvariants.cpp
View File

@ -23,45 +23,45 @@ double *xSamples; // Input values
mldata_t *mlData = NULL; // Machine learning
point_t *points = NULL; // Graphing
/* *graph building* */
/* *graph building* */
static imagePixel_t * rdPPM(char *fileName); // Read PPM file format
void mkPpmFile(char *fileName, imagePixel_t *image); // Writes PPM file
int ppmColorChannel(FILE* fp, imagePixel_t *image, // Writes colorChannel from PPM file to log file
char *colorChannel, mldata_t *mlData);
void colorSamples(FILE* fp, mldata_t *mlData); // Stores color channel values in xSamples
/* *file handling* */
char * mkFileName(char* buffer,
size_t max_len, int suffixId);
char *fileSuffix(int id);
char *fileHeader(int id); // Header inside the logfiles
//void myLogger ( FILE* fp, point_t points[] );
/* *file handling* */
char * mkFileName ( char* buffer,
size_t max_len, int suffixId );
char *fileSuffix ( int id );
char *fileHeader ( int id ); // Header inside the logfiles
//void myLogger ( FILE* fp, point_t points[] );
void bufferLogger(char *buffer, point_t points[]); // Writes points to graph template
void mkSvgGraph(point_t points[]); // Parses graph template and calls bufferLogger()
void weightsLogger(double *weights, int suffix); // Writes updated weights to a file
void mkSvgGraph ( point_t points[] ); // Parses graph template and calls bufferLogger()
void weightsLogger ( double *weights, int suffix ); // Writes updated weights to a file
/* *rand seed* */
double r2(void); // Random val between 0 and 1
double rndm(void);
/* *rand seed* */
double r2 ( void ); // Random val between 0 and 1
double rndm ( void );
/* *args parser* */
void usage(char **argv); // Help text called by args parser
void usage ( char **argv ); // Help text called by args parser
/* *math* */
/* *math* */
mldata_t * init_mldata_t(unsigned windowSize, unsigned samplesCount, double learnrate);
double sum_array(double x[], int length);
void localMean(mldata_t *mlData, point_t points[]); // First,
void directPredecessor(mldata_t *mlData, point_t points[]); // Second,
void differentialPredecessor(mldata_t *mlData, point_t points[]); // Third filter implementation
void localMean ( mldata_t *mlData,point_t points[] ); // First,
void directPredecessor ( mldata_t *mlData, point_t points[] ); // Second,
void differentialPredecessor ( mldata_t *mlData, point_t points[] ); // Third filter implementation
double *popNAN(double *xError); // Returns array without NAN values, if any exist
double windowXMean(int _arraylength, int xCount); // Returns mean value of given window
int main(int argc, char **argv) {
char *colorChannel = (char *)malloc(sizeof(char) * 32);
int main( int argc, char **argv ) {
char *colorChannel = (char *) malloc(sizeof(char)* 32);
char *inputfile = (char *)malloc(sizeof(char) * 32);
unsigned *seed = NULL;
unsigned k, include = 0;
@ -74,8 +74,8 @@ int main(int argc, char **argv) {
char *istrue = "true";
while ((argc > 1) && (argv[1][0] == '-')) { // Parses parameters from stdin
switch (argv[1][1]) {
while( (argc > 1) && (argv[1][0] == '-') ) { // Parses parameters from stdin
switch( argv[1][1] ) {
case 'i':
inputfile = &argv[1][3];
++argv;
@ -114,11 +114,10 @@ int main(int argc, char **argv) {
break;
case 'g':
sscanf(&argv[1][3], "%s", xBuffer);
if (strstr(xBuffer, istrue)) {
if ( strstr(xBuffer, istrue) ) {
include = 1;
}
else {
printf("Wrong Argruments: %s\n", argv[1]);
} else {
printf( "Wrong Argruments: %s\n", argv[1]);
usage(argv);
}
++argv;
@ -133,9 +132,9 @@ int main(int argc, char **argv) {
--argc;
}
init_mldata_t(windowSize, samplesCount, learnrate);
xSamples = (double *)malloc(sizeof(double) * mlData->samplesCount); // Resize input values
points = (point_t *)malloc(sizeof(point_t) * mlData->samplesCount); // Resize points
init_mldata_t ( windowSize, samplesCount, learnrate );
xSamples = (double *) malloc ( sizeof(double) * mlData->samplesCount ); // Resize input values
points = (point_t *) malloc ( sizeof(point_t) * mlData->samplesCount); // Resize points
imagePixel_t *image;
image = rdPPM(inputfile); // Set Pointer on input values
@ -148,12 +147,11 @@ int main(int argc, char **argv) {
FILE* fp6 = fopen(fileName, "r");
colorSamples(fp6, mlData);
if ((seed != NULL)) {
srand(*seed); // Seed for random number generating
if ( (seed != NULL) ){
srand( *seed ); // Seed for random number generating
printf("srand is reproducable\n");
}
else {
srand((unsigned int)time(NULL));
} else {
srand( (unsigned int)time(NULL) );
printf("srand depends on time\n"); // Default seed is time(NULL)
}
printf("generated weights:\n");
@ -173,11 +171,11 @@ int main(int argc, char **argv) {
fclose(fp0);
/* *math magic* */
localMean(mlData, points);
directPredecessor(mlData, points);
differentialPredecessor(mlData, points);
localMean ( mlData, points );
directPredecessor ( mlData, points);
differentialPredecessor( mlData, points );
if (include == 1) {
if ( include == 1 ) {
mkSvgGraph(points); // Graph building
}
@ -198,20 +196,20 @@ Variant (1/3), substract local mean.
======================================================================================================
*/
void localMean(mldata_t *mlData, point_t points[]) {
double *localWeights = (double *)malloc(sizeof(double) * mlData->windowSize + 1);
void localMean ( mldata_t *mlData, point_t points[] ) {
double *localWeights = (double *) malloc ( sizeof(double) * mlData->windowSize + 1);
localWeights = mlData->weights;
char fileName[50];
double *xError = (double *)malloc(sizeof(double) * mlData->samplesCount + 1); // Includes e(n)
double *xError = (double *) malloc ( sizeof(double) * mlData->samplesCount + 1); // Includes e(n)
memset(xError, 0.0, mlData->samplesCount); // Initialize xError-array with Zero
unsigned i, xCount = 0; // Runtime vars
mkFileName(fileName, sizeof(fileName), LOCAL_MEAN); // Create Logfile and its filename
FILE* fp4 = fopen(fileName, "w");
fprintf(fp4, fileHeader(LOCAL_MEAN_HEADER));
fprintf( fp4, fileHeader(LOCAL_MEAN_HEADER) );
mkFileName(fileName, sizeof(fileName), USED_WEIGHTS_LOCAL_MEAN);
mkFileName ( fileName, sizeof(fileName), USED_WEIGHTS_LOCAL_MEAN);
FILE *fp9 = fopen(fileName, "w");
@ -220,14 +218,14 @@ void localMean(mldata_t *mlData, point_t points[]) {
double xPredicted = 0.0;
double xActual = 0.0;
for (xCount = 1; xCount < mlData->samplesCount - 1; xCount++) { // First value will not get predicted
unsigned _arrayLength = (xCount > mlData->windowSize) ? mlData->windowSize + 1 : xCount; // Ensures corect length at start
for ( xCount = 1; xCount < mlData->samplesCount-1; xCount++ ) { // First value will not get predicted
unsigned _arrayLength = ( xCount > mlData->windowSize ) ? mlData->windowSize + 1 : xCount; // Ensures corect length at start
xMean = (xCount > 0) ? windowXMean(_arrayLength, xCount) : 0;
xPredicted = 0.0;
xActual = xSamples[xCount];
for (i = 1; i < _arrayLength; i++) { // Get predicted value
xPredicted += (localWeights[i - 1] * (xSamples[xCount - i] - xMean));
for ( i = 1; i < _arrayLength; i++ ) { // Get predicted value
xPredicted += ( localWeights[i - 1] * (xSamples[xCount - i] - xMean) );
}
xPredicted += xMean;
xError[xCount] = xActual - xPredicted; // Get error value
@ -235,13 +233,13 @@ void localMean(mldata_t *mlData, point_t points[]) {
for (i = 1; i < _arrayLength; i++) { // Get xSquared
xSquared += pow(xSamples[xCount - i] - xMean, 2);
}
if (xSquared == 0.0) { // Otherwise returns Pred: -1.#IND00 in some occassions
if ( xSquared == 0.0 ) { // Otherwise returns Pred: -1.#IND00 in some occassions
xSquared = 1.0;
}
for (i = 1; i < _arrayLength; i++) { // Update weights
for ( i = 1; i < _arrayLength; i++ ) { // Update weights
localWeights[i] = localWeights[i - 1] + mlData->learnrate * xError[xCount] // Substract localMean
* ((xSamples[xCount - i] - xMean) / xSquared);
fprintf(fp9, "%lf\n", localWeights[i]);
* ( (xSamples[xCount - i] - xMean) / xSquared );
fprintf( fp9, "%lf\n", localWeights[i] );
}
fprintf(fp4, "%d\t%f\t%f\t%f\n", xCount, xPredicted, xActual, xError[xCount]); // Write to logfile
@ -257,7 +255,7 @@ void localMean(mldata_t *mlData, point_t points[]) {
double *xErrorPtr = popNAN(xError); // delete NAN values from xError[]
double xErrorLength = *xErrorPtr; // Watch popNAN()!
xErrorPtr[0] = 0.0;
// printf("Xerrorl:%lf", xErrorLength);
// printf("Xerrorl:%lf", xErrorLength);
double mean = sum_array(xErrorPtr, xErrorLength) / xErrorLength; // Mean
double deviation = 0.0;
@ -267,7 +265,7 @@ void localMean(mldata_t *mlData, point_t points[]) {
deviation /= xErrorLength; // Deviation
printf("mean:%lf, devitation:%lf\t\tlocal Mean\n", mean, deviation);
fprintf(fp4, "\nQuadratische Varianz(x_error): %f\nMittelwert:(x_error): %f\n\n", deviation, mean); // Write to logfile
//free(localWeights);
// free(localWeights);
free(xErrorPtr);
free(xError);
@ -286,12 +284,12 @@ substract direct predecessor
======================================================================================================
*/
void directPredecessor(mldata_t *mlData, point_t points[]) {
double *localWeights = (double *)malloc(sizeof(double) * mlData->windowSize + 1);
void directPredecessor( mldata_t *mlData, point_t points[]) {
double *localWeights = ( double * ) malloc ( sizeof(double) * mlData->windowSize + 1 );
localWeights = mlData->weights;
char fileName[512];
double *xError = (double *)malloc(sizeof(double) * mlData->samplesCount + 1);
double *xError = (double *) malloc ( sizeof(double) * mlData->samplesCount + 1 );
memset(xError, 0.0, mlData->samplesCount);
unsigned xCount = 0, i;
double xActual = 0.0;
@ -299,18 +297,18 @@ void directPredecessor(mldata_t *mlData, point_t points[]) {
mkFileName(fileName, sizeof(fileName), DIRECT_PREDECESSOR); // Logfile and name handling
FILE *fp3 = fopen(fileName, "w");
fprintf(fp3, fileHeader(DIRECT_PREDECESSOR_HEADER));
fprintf( fp3, fileHeader(DIRECT_PREDECESSOR_HEADER) );
mkFileName(fileName, sizeof(fileName), USED_WEIGHTS_DIR_PRED);
mkFileName ( fileName, sizeof(fileName), USED_WEIGHTS_DIR_PRED);
FILE *fp9 = fopen(fileName, "w");
for (xCount = 1; xCount < mlData->samplesCount - 1; xCount++) { // first value will not get predicted
unsigned _arrayLength = (xCount > mlData->windowSize) ? mlData->windowSize + 1 : xCount;
for (xCount = 1; xCount < mlData->samplesCount-1; xCount++) { // first value will not get predicted
unsigned _arrayLength = ( xCount > mlData->windowSize ) ? mlData->windowSize + 1 : xCount;
xPredicted = 0.0;
xActual = xSamples[xCount];
for (i = 1; i < _arrayLength; i++) {
xPredicted += (localWeights[i - 1] * (xSamples[xCount - 1] - xSamples[xCount - i - 1]));
xPredicted += ( localWeights[i - 1] * (xSamples[xCount - 1] - xSamples[xCount - i - 1]));
}
xPredicted += xSamples[xCount - 1];
@ -320,13 +318,13 @@ void directPredecessor(mldata_t *mlData, point_t points[]) {
for (i = 1; i < _arrayLength; i++) {
xSquared += pow(xSamples[xCount - 1] - xSamples[xCount - i - 1], 2); // substract direct predecessor
}
if (xSquared == 0.0) { // Otherwise returns Pred: -1.#IND00 in some occassions
if ( xSquared == 0.0 ) { // Otherwise returns Pred: -1.#IND00 in some occassions
xSquared = 1.0;
}
for (i = 1; i < _arrayLength; i++) { // Update weights
localWeights[i] = localWeights[i - 1] + mlData->learnrate * xError[xCount]
* ((xSamples[xCount - 1] - xSamples[xCount - i - 1]) / xSquared);
fprintf(fp9, "%lf\n", localWeights[i]);
for ( i = 1; i < _arrayLength; i++ ) { // Update weights
localWeights[i] = localWeights[i-1] + mlData->learnrate * xError[xCount]
* ( (xSamples[xCount - 1] - xSamples[xCount - i - 1]) / xSquared);
fprintf( fp9, "%lf\n", localWeights[i] );
}
fprintf(fp3, "%d\t%f\t%f\t%f\n", xCount, xPredicted, xActual, xError[xCount]); // Write to logfile
@ -355,7 +353,7 @@ void directPredecessor(mldata_t *mlData, point_t points[]) {
printf("mean:%lf, devitation:%lf\t\tdirect Predecessor\n", mean, deviation);
fprintf(fp3, "\nQuadratische Varianz(x_error): %f\nMittelwert:(x_error): %f\n\n", deviation, mean);
fclose(fp3);
//free(localWeights);
// free(localWeights);
free(xErrorPtr);
free(xError);
}
@ -370,12 +368,12 @@ differential predecessor.
======================================================================================================
*/
void differentialPredecessor(mldata_t *mlData, point_t points[]) {
double *localWeights = (double *)malloc(sizeof(double) * mlData->windowSize + 1);
void differentialPredecessor ( mldata_t *mlData, point_t points[] ) {
double *localWeights = (double *) malloc ( sizeof(double) * mlData->windowSize + 1 );
localWeights = mlData->weights;
char fileName[512];
double *xError = (double *)malloc(sizeof(double) * mlData->samplesCount + 1);
double *xError = (double *) malloc ( sizeof(double) * mlData->samplesCount + 1);
memset(xError, 0.0, mlData->samplesCount);
unsigned xCount = 0, i;
@ -384,19 +382,19 @@ void differentialPredecessor(mldata_t *mlData, point_t points[]) {
mkFileName(fileName, sizeof(fileName), DIFFERENTIAL_PREDECESSOR); // File handling
FILE *fp6 = fopen(fileName, "w");
fprintf(fp6, fileHeader(DIFFERENTIAL_PREDECESSOR_HEADER));
fprintf(fp6, fileHeader(DIFFERENTIAL_PREDECESSOR_HEADER) );
mkFileName(fileName, sizeof(fileName), USED_WEIGHTS_DIFF_PRED);
mkFileName ( fileName, sizeof(fileName), USED_WEIGHTS_DIFF_PRED);
FILE *fp9 = fopen(fileName, "w");
for (xCount = 1; xCount < mlData->samplesCount - 1; xCount++) { // First value will not get predicted
for (xCount = 1; xCount < mlData->samplesCount-1; xCount++) { // First value will not get predicted
unsigned _arrayLength = (xCount > mlData->windowSize) ? mlData->windowSize + 1 : xCount;
xPredicted = 0.0;
xActual = xSamples[xCount];
for (i = 1; i < _arrayLength; i++) {
xPredicted += (localWeights[i - 1] * (xSamples[xCount - i] - xSamples[xCount - i - 1]));
xPredicted += ( localWeights[i - 1] * (xSamples[xCount - i] - xSamples[xCount - i - 1]));
}
xPredicted += xSamples[xCount - 1];
xError[xCount] = xActual - xPredicted;
@ -405,14 +403,14 @@ void differentialPredecessor(mldata_t *mlData, point_t points[]) {
for (i = 1; i < _arrayLength; i++) {
xSquared += pow(xSamples[xCount - i] - xSamples[xCount - i - 1], 2); // Substract direct predecessor
}
if (xSquared == 0.0) { // Otherwise returns Pred: -1.#IND00 in some occassions
if ( xSquared == 0.0 ) { // Otherwise returns Pred: -1.#IND00 in some occassions
xSquared = 1.0;
}
for (i = 1; i < _arrayLength; i++) {
localWeights[i] = localWeights[i - 1] + mlData->learnrate * xError[xCount]
localWeights[i] = localWeights[i-1] + mlData->learnrate * xError[xCount]
* ((xSamples[xCount - i] - xSamples[xCount - i - 1]) / xSquared);
fprintf(fp9, "%lf\n", localWeights[i]);
fprintf( fp9, "%lf\n", localWeights[i] );
}
fprintf(fp6, "%d\t%f\t%f\t%f\n", xCount, xPredicted, xActual, xError[xCount]); // Write to logfile
@ -427,7 +425,7 @@ void differentialPredecessor(mldata_t *mlData, point_t points[]) {
double *xErrorPtr = popNAN(xError); // delete NAN values from xError[]
double xErrorLength = *xErrorPtr; // Watch popNAN()!
xErrorPtr[0] = 0.0;
// printf("Xerrorl:%lf", xErrorLength);
// printf("Xerrorl:%lf", xErrorLength);
double mean = sum_array(xErrorPtr, xErrorLength) / xErrorLength;
double deviation = 0.0;
@ -440,12 +438,12 @@ void differentialPredecessor(mldata_t *mlData, point_t points[]) {
printf("mean:%lf, devitation:%lf\t\tdifferential Predecessor\n", mean, deviation);
fprintf(fp6, "\nQuadratische Varianz(x_error): %f\nMittelwert:(x_error): %f\n\n", deviation, mean);
fclose(fp6);
//free(localWeights);
// free(localWeights);
free(xErrorPtr);
free(xError);
// weightsLogger( localWeights, USED_WEIGHTS );
// weightsLogger( localWeights, USED_WEIGHTS );
}
/*
@ -480,7 +478,7 @@ Contains and returns every suffix for all existing filenames
======================================================================================================
*/
char * fileSuffix(int id) {
char * fileSuffix ( int id ) {
char * suffix[] = { "_weights_pure.txt",
"_weights_used_dir_pred_.txt",
"_direct_predecessor.txt",
@ -503,7 +501,7 @@ Contains and returns header from logfiles
======================================================================================================
*/
char * fileHeader(int id) {
char * fileHeader ( int id ) {
char * header[] = { "\n=========================== Local Mean ===========================\nNo.\txPredicted\txAcutal\t\txError\n",
"\n=========================== Direct Predecessor ===========================\nNo.\txPredicted\txAcutal\t\txError\n",
"\n=========================== Differential Predecessor ===========================\nNo.\txPredicted\txAcutal\t\txError\n"
@ -520,7 +518,7 @@ Logs used weights to logfile
======================================================================================================
*/
void weightsLogger(double *weights, int val) {
void weightsLogger (double *weights, int val ) {
char fileName[512];
unsigned i;
mkFileName(fileName, sizeof(fileName), val);
@ -537,20 +535,20 @@ void weightsLogger(double *weights, int val) {
bufferLogger
formats output of mkSvgGraph -- Please open graphResults.html to see the output--
[0] = xActual,
[1] = xPredicted from localMean,
[2] = xPredicted from directPredecessor,
[3] = xPredicted from differentialpredecessor,
[4] = xError from localMean,
[5] = xError from directPredecessor,
[6] = xError from differentialPredecessor
[0] = xActual,
[1] = xPredicted from localMean,
[2] = xPredicted from directPredecessor,
[3] = xPredicted from differentialpredecessor,
[4] = xError from localMean,
[5] = xError from directPredecessor,
[6] = xError from differentialPredecessor
======================================================================================================
*/
void bufferLogger(char *buffer, point_t points[]) {
unsigned i;
char _buffer[512] = ""; // TODO: resize buffer and _buffer so greater sampleval can be choosen
// char *_buffer = (char *) malloc ( sizeof(char) * 512 + 1);
// char *_buffer = (char *) malloc ( sizeof(char) * 512 + 1);
for (i = 1; i < mlData->samplesCount - 1; i++) { // xActual
sprintf(_buffer, "L %f %f\n", points[i].xVal[0], points[i].yVal[0]);
strcat(buffer, _buffer);
@ -609,10 +607,10 @@ double *popNAN(double *xError) {
double *tmp = NULL;
double *more_tmp = NULL;
for (i = 0; i < mlData->samplesCount - 1; i++) {
counter++;
more_tmp = (double *)realloc(tmp, counter*(sizeof(double)));
if (!isnan(xError[i])) {
for ( i = 0; i < mlData->samplesCount - 1; i++ ) {
counter ++;
more_tmp = (double *) realloc ( tmp, counter*(sizeof(double) ));
if ( !isnan(xError[i]) ) {
tmp = more_tmp;
tmp[counter - 1] = xError[i];
//printf("xERROR:%lf\n", tmp[counter - 1]);
@ -620,7 +618,7 @@ double *popNAN(double *xError) {
}
}
counter += 1;
more_tmp = (double *)realloc(tmp, counter * sizeof(double));
more_tmp = (double *) realloc ( tmp, counter * sizeof(double) );
tmp = more_tmp;
*tmp = tmpLength; // Length of array is stored inside tmp[0]. tmp[0] is never used anyways
@ -681,7 +679,7 @@ void mkSvgGraph(point_t points[]) {
char buffer[131072] = ""; // Bit dirty
// char *buffer = (char *) malloc ( sizeof(char) * ( ( 3 * mlData->samplesCount ) + fpLength + 1 ) );
// char *buffer = (char *) malloc ( sizeof(char) * ( ( 3 * mlData->samplesCount ) + fpLength + 1 ) );
memset(buffer, '\0', sizeof(buffer));
while (!feof(input)) { // parses file until "firstGraph" has been found
@ -733,30 +731,30 @@ static imagePixel_t *rdPPM(char *fileName) {
c = getc(fp);
}
ungetc(c, fp);
if (fscanf(fp, "%d %d", &image->x, &image->y) != 2) {
if ( fscanf(fp, "%d %d", &image->x, &image->y) != 2 ) {
fprintf(stderr, "Invalid image size in %s\n", fileName);
exit(EXIT_FAILURE);
}
if (fscanf(fp, "%d", &rgbColor) != 1) {
if ( fscanf(fp, "%d", &rgbColor) != 1 ) {
fprintf(stderr, "Invalid rgb component in %s\n", fileName);
}
if (rgbColor != RGB_COLOR) {
if ( rgbColor != RGB_COLOR ) {
fprintf(stderr, "Invalid image color range in %s\n", fileName);
exit(EXIT_FAILURE);
}
while (fgetc(fp) != '\n');
while ( fgetc(fp) != '\n' );
image->data = (colorChannel_t *)malloc(image->x * image->y * sizeof(imagePixel_t));
if (!image) {
fprintf(stderr, "malloc() on image->data failed");
exit(EXIT_FAILURE);
}
if ((image->x * image->y) < mlData->samplesCount) {
printf("Changing \"-n\" to %d, image max data size\n", (image->x * image->y));
tmp = (double *)realloc(xSamples, sizeof(double) * (image->x * image->y));
if ( (image->x * image->y) < mlData->samplesCount) {
printf("Changing \"-n\" to %d, image max data size\n", ( image->x * image->y ) );
tmp = (double *) realloc ( xSamples, sizeof(double) * (image->x * image->y) );
xSamples = tmp;
mlData->samplesCount = (image->x * image->y) / sizeof(double);
mlData->samplesCount = (image->x * image->y ) / sizeof(double);
}
if (fread(image->data, 3 * image->x, image->y, fp) != image->y) {
if ( fread( image->data, 3 * image->x, image->y, fp) != image->y) {
fprintf(stderr, "Loading image failed");
exit(EXIT_FAILURE);
}
@ -800,26 +798,23 @@ int ppmColorChannel(FILE* fp, imagePixel_t *image, char *colorChannel, mldata_t
unsigned i = 0;
printf("colorChannel : %s\n", colorChannel);
if (image) { // RGB channel can be set through args from cli
if (strcmp(colorChannel, "green") == 0) {
for (i = 0; i < mlData->samplesCount - 1; i++) {
fprintf(fp, "%d\n", image->data[i].green);
if ( image ) { // RGB channel can be set through args from cli
if ( strcmp(colorChannel, "green") == 0 ){
for ( i = 0; i < mlData->samplesCount - 1; i++ ) {
fprintf ( fp, "%d\n", image->data[i].green );
}
}
else if (strcmp(colorChannel, "red") == 0) {
for (i = 0; i < mlData->samplesCount - 1; i++) {
fprintf(fp, "%d\n", image->data[i].red);
} else if ( strcmp(colorChannel, "red") == 0 ){
for ( i = 0; i < mlData->samplesCount - 1; i++ ) {
fprintf ( fp, "%d\n", image->data[i].red );
}
} else if ( strcmp(colorChannel, "blue") == 0 ) {
for ( i = 0; i < mlData->samplesCount - 1; i++ ) {
fprintf ( fp, "%d\n", image->data[i].blue );
}
else if (strcmp(colorChannel, "blue") == 0) {
for (i = 0; i < mlData->samplesCount - 1; i++) {
fprintf(fp, "%d\n", image->data[i].blue);
}
}
else {
} else {
printf("Colorchannels are red, green and blue. Pick one of them!");
exit(EXIT_FAILURE);
exit( EXIT_FAILURE );
}
}
fclose(fp);
@ -836,9 +831,9 @@ creating the SVG graph
======================================================================================================
*/
void colorSamples(FILE* fp, mldata_t *mlData) {
void colorSamples ( FILE* fp, mldata_t *mlData ) {
int i = 0;
char *buffer = (char *)malloc(sizeof(char) * mlData->samplesCount + 1);
char *buffer = (char *) malloc(sizeof(char) * mlData->samplesCount + 1);
while (!feof(fp)) {
if (fgets(buffer, mlData->samplesCount, fp) != NULL) {
@ -874,13 +869,13 @@ double windowXMean(int _arraylength, int xCount) {
/*
======================================================================================================
usage
usage
used in conjunction with the args parser. Returns help section of "-h"
used in conjunction with the args parser. Returns help section of "-h"
======================================================================================================
*/
void usage(char **argv) {
void usage ( char **argv ) {
printf("Usage: %s [POSIX style options] -i file ...\n", &argv[0][0]);
printf("POSIX options:\n");
printf("\t-h\t\t\tDisplay this information.\n");
@ -889,7 +884,7 @@ void usage(char **argv) {
printf("\t-c <color>\t\tUse this color channel from inputfile.\n");
printf("\t-w <digit>\t\tCount of used weights (windowSize).\n");
printf("\t-l <digit>\t\tLearnrate, 0 < learnrate < 1.\n");
printf("\t-x true\t\t\tLogfiles only, no graph building.\n\t\t\t\tChoose for intense amount of input data.\n");
printf("\t-g true\t\t\tGraph building.\n\t\t\t\tChoose for n < 1200.\n");
printf("\t-s <digit>\t\tDigit for random seed generator.\n\t\t\t\tSame Digits produce same random values. Default is srand by time.\n");
printf("\n\n");
printf("%s compares prediction methods of least mean square filters.\nBy default it reads ppm file format and return logfiles as well\nas an svg graphs as an output of said least mean square methods.\n\nExample:\n\t%s -i myimage.ppm -w 3 -c green -s 5 -x true\n", &argv[0][0], &argv[0][0]);
@ -899,18 +894,18 @@ void usage(char **argv) {
/*
======================================================================================================
init_mldata_t
init_mldata_t
Contains meachine learning data
Contains meachine learning data
======================================================================================================
*/
mldata_t * init_mldata_t(unsigned windowSize, unsigned samplesCount, double learnrate) {
mlData = (mldata_t *)malloc(sizeof(mldata_t));
mlData = (mldata_t *) malloc( sizeof(mldata_t) );
mlData->windowSize = windowSize;
mlData->samplesCount = samplesCount;
mlData->learnrate = learnrate;
mlData->weights = (double *)malloc(sizeof(double) * windowSize + 1);
mlData->weights = (double *) malloc ( sizeof(double) * windowSize + 1 );
return mlData;
}