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

some functions done

This commit is contained in:
Friese 2018-05-07 15:36:46 +02:00
parent b4d2569f46
commit 7b1c1cedb0
1 changed files with 480 additions and 421 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

469
bin/NLMSvariants.c
View File

@ -3,7 +3,7 @@
// NLMSvariants.c // NLMSvariants.c
// //
// Created by FBRDNLMS on 26.04.18. // Created by FBRDNLMS on 26.04.18.
// Copyright © 2018 FBRDNLMS. All rights reserved. // Copyright © 2018 FBRDNLMS. All rights reserved.
// //
#include <stdio.h> #include <stdio.h>
@ -22,10 +22,26 @@
#define DIRECT_PREDECESSOR 2 #define DIRECT_PREDECESSOR 2
#define LOCAL_MEAN 4 #define LOCAL_MEAN 4
#define RGB_COLOR 255 #define RGB_COLOR 255
double x[] = {0}; #if defined(_MSC_VER)
double _x[M] = {0}; #include <BaseTsd.h>
double w [M][M]={{0},{0}}; #include <codecvt> // std::codecvt_utf8_utf16
#include <locale> // std::wstring_convert
#include <string> // std::wstring
typedef SSIZE_T ssize_t;
#endif
double x[] = { 0 };
double _x[M] = { 0 };
double w[M][M] = { { 0 },{ 0 } };
#if defined(_MSC_VER)
/* UTF-8 to UTF-16 win Format*/
auto wstring_from_utf8(char const* const utf8_string)
-> std::wstring
{
std::wstring_convert< std::codecvt_utf8_utf16< wchar_t > > converter;
return converter.from_bytes(utf8_string);
}
#endif
/* *svg graph building* */ /* *svg graph building* */
typedef struct { typedef struct {
@ -35,58 +51,58 @@ typedef struct {
point_t points[M]; // [0]=xActual, [1]=xPredicted from directPredecessor, [2]=xPredicted from localMean point_t points[M]; // [0]=xActual, [1]=xPredicted from directPredecessor, [2]=xPredicted from localMean
/* *ppm reader/writer* */ /* *ppm reader/writer* */
typedef struct { typedef struct {
unsigned char red, green, blue; unsigned char red, green, blue;
}colorChannel_t; }colorChannel_t;
typedef struct { typedef struct {
int x,y; int x, y;
colorChannel_t *data; colorChannel_t *data;
}imagePixel_t; }imagePixel_t;
static imagePixel_t * readPPM( char *fileName ); static imagePixel_t * readPPM(char *fileName);
void mkPpmFile( char *fileNamem, imagePixel_t *image ); void mkPpmFile(char *fileNamem, imagePixel_t *image);
int * ppmColorChannel( imagePixel_t *image ); int * ppmColorChannel(imagePixel_t *image);
/* *file handling* */ /* *file handling* */
char * mkFileName( char* buffer, size_t max_len, int suffixId ); char * mkFileName(char* buffer, size_t max_len, int suffixId);
char *fileSuffix( int id ); char *fileSuffix(int id);
void myLogger( FILE* fp, point_t points[]); void myLogger(FILE* fp, point_t points[]);
#ifdef _WIN32 #ifdef _WIN32
size_t getline( char **lineptr, size_t *n, FILE *stream ); size_t getline(char **lineptr, size_t *n, FILE *stream);
#endif #endif
void mkSvgGraph( point_t points[]); void mkSvgGraph(point_t points[]);
/* *rand seed* */ /* *rand seed* */
double r2( void ); double r2(void);
double rndm( void ); double rndm(void);
/* *math* */ /* *math* */
double sum_array( double x[], int length ); double sum_array(double x[], int length);
void directPredecessor( void ); void directPredecessor(void);
void localMean( void ); void localMean(void);
int main(int argc, char **argv ) { int main(int argc, char **argv) {
char fileName[50]; char fileName[50];
int i; int i;
srand( (unsigned int) time(NULL) ); srand((unsigned int)time(NULL));
for (i = 0; i < M; i++) { for (i = 0; i < M; i++) {
_x[i] += ((255.0 / M) * i); // Init test values _x[i] += ((255.0 / M) * i); // Init test values
for (int k = 0; k < M; k++){ for (int k = 0; k < M; k++) {
w[k][i] = rndm(); // Init weights w[k][i] = rndm(); // Init weights
} }
} }
mkFileName( fileName, sizeof(fileName), PURE_WEIGHTS); mkFileName(fileName, sizeof(fileName), PURE_WEIGHTS);
// save plain test_array before math magic happens // save plain test_array before math magic happens
FILE *fp0 = fopen(fileName,"w"); FILE *fp0 = fopen(fileName, "w");
for (i = 0; i <= tracking; i++){ for (i = 0; i <= tracking; i++) {
for ( int k = 0; k < tracking; k++ ){ for (int k = 0; k < tracking; k++) {
fprintf(fp0, "[%d][%d] %lf\n", k, i, w[k][i]); fprintf(fp0, "[%d][%d] %lf\n", k, i, w[k][i]);
} }
} }
@ -99,11 +115,11 @@ int main(int argc, char **argv ) {
// save test_array after math magic happened // save test_array after math magic happened
// memset( fileName, '\0', sizeof(fileName) ); // memset( fileName, '\0', sizeof(fileName) );
mkFileName( fileName, sizeof(fileName), USED_WEIGHTS); mkFileName(fileName, sizeof(fileName), USED_WEIGHTS);
FILE *fp1 = fopen(fileName,"w"); FILE *fp1 = fopen(fileName, "w");
for (i = 0; i < tracking; i++) { for (i = 0; i < tracking; i++) {
for (int k = 0; k < tracking; k++) { for (int k = 0; k < tracking; k++) {
fprintf(fp1, "[%d][%d] %lf\n", k,i, w[k][i]); fprintf(fp1, "[%d][%d] %lf\n", k, i, w[k][i]);
} }
} }
@ -116,51 +132,51 @@ int main(int argc, char **argv ) {
/* /*
======================================================================================= =======================================================================================
localMean localMean
Variant (1/3), substract local mean. Variant (1/3), substract local mean.
======================================================================================= =======================================================================================
*/ */
void localMean( void ) { void localMean(void) {
char fileName[50]; char fileName[50];
double xError[M]; // includes e(n) double xError[M]; // includes e(n)
memset(xError, 0, M);// initialize xError-array with Zero memset(xError, 0, M);// initialize xError-array with Zero
int xCount = 0; // runtime var int xCount = 0; // runtime var
int i; int i;
mkFileName(fileName, sizeof(fileName), LOCAL_MEAN ); mkFileName(fileName, sizeof(fileName), LOCAL_MEAN);
FILE* fp4 = fopen(fileName, "w"); FILE* fp4 = fopen(fileName, "w");
fprintf(fp4, "\n\n\n\n*********************LocalMean*********************\n"); fprintf(fp4, "\n\n\n\n*********************LocalMean*********************\n");
for (xCount = 1; xCount < M; xCount++){ for (xCount = 1; xCount < M; xCount++) {
//double xPartArray[xCount]; //includes all values at the size of runtime var //double xPartArray[xCount]; //includes all values at the size of runtime var
double xMean = ( xCount > 0 ) ? ( sum_array(_x, xCount) / xCount ) : 0;// xCount can not be zero double xMean = (xCount > 0) ? (sum_array(_x, xCount) / xCount) : 0;// xCount can not be zero
double xPredicted = 0.0; double xPredicted = 0.0;
double xActual = _x[xCount + 1]; double xActual = _x[xCount + 1];
for ( i = 1; i < xCount; i++ ){ //get predicted value for (i = 1; i < xCount; i++) { //get predicted value
xPredicted += ( w[i][xCount] * ( _x[xCount - i] - xMean )) ; xPredicted += (w[i][xCount] * (_x[xCount - i] - xMean));
} }
xPredicted += xMean; xPredicted += xMean;
xError [xCount] = xActual - xPredicted; xError[xCount] = xActual - xPredicted;
points[xCount].xVal[2] = xCount; points[xCount].xVal[2] = xCount;
points[xCount].yVal[2] = xPredicted; points[xCount].yVal[2] = xPredicted;
double xSquared = 0.0; double xSquared = 0.0;
for ( i = 1; i < xCount; i++ ){ //get x squared for (i = 1; i < xCount; i++) { //get x squared
xSquared =+ pow(_x[xCount-i],2); xSquared = +pow(_x[xCount - i], 2);
} }
for ( i - 1; i < xCount; i++ ){ //update weights for (i - 1; i < xCount; i++) { //update weights
w[i][xCount+1] = w[i][xCount] + learnrate * xError[xCount] * (_x[xCount - i] / xSquared); w[i][xCount + 1] = w[i][xCount] + learnrate * xError[xCount] * (_x[xCount - i] / xSquared);
} }
fprintf(fp4, "{%d}.\txPredicted{%f}\txActual{%f}\txError{%f}\n", xCount, xPredicted, xActual, xError[xCount]); fprintf(fp4, "{%d}.\txPredicted{%f}\txActual{%f}\txError{%f}\n", xCount, xPredicted, xActual, xError[xCount]);
@ -170,14 +186,14 @@ void localMean( void ) {
double deviation = 0.0; double deviation = 0.0;
// Mean square // Mean square
for( i = 0; i < M - 1; i++ ){ for (i = 0; i < M - 1; i++) {
deviation += pow( xError[i], 2 ); deviation += pow(xError[i], 2);
} }
deviation /= xErrorLength; deviation /= xErrorLength;
// write in file // write in file
mkFileName( fileName, sizeof(fileName), RESULTS ); mkFileName(fileName, sizeof(fileName), RESULTS);
FILE *fp2 = fopen(fileName, "w"); FILE *fp2 = fopen(fileName, "w");
fprintf(fp2, "quadr. Varianz(x_error): {%f}\nMittelwert:(x_error): {%f}\n\n", deviation, mean); fprintf(fp2, "quadr. Varianz(x_error): {%f}\nMittelwert:(x_error): {%f}\n\n", deviation, mean);
fclose(fp2); fclose(fp2);
@ -186,36 +202,36 @@ void localMean( void ) {
/* /*
=================================== ===================================
directPredecessor directPredecessor
Variant (2/3), Variant (2/3),
substract direct predecessor substract direct predecessor
=================================== ===================================
*/ */
void directPredecessor( void ) { void directPredecessor(void) {
char fileName[50]; char fileName[512];
double xError [M]; double xError[2048];
int xCount = 0, i; int xCount = 0, i;
double xActual; double xActual;
// File handling // File handling
mkFileName( fileName, sizeof(fileName), DIRECT_PREDECESSOR); mkFileName(fileName, sizeof(fileName), DIRECT_PREDECESSOR);
FILE *fp3 = fopen(fileName, "w"); FILE *fp3 = fopen(fileName, "w");
fprintf(fp3, "\n\n\n\n*********************DirectPredecessor*********************\n"); fprintf(fp3, "\n\n\n\n*********************DirectPredecessor*********************\n");
for ( xCount = 1; xCount < M+1; xCount++ ){ for (xCount = 1; xCount < M + 1; xCount++) {
xActual = _x[xCount+1]; xActual = _x[xCount + 1];
double xPredicted = 0.0; double xPredicted = 0.0;
for ( i = 1; i < xCount; i++ ){ for (i = 1; i < xCount; i++) {
xPredicted += ( w[i][xCount] * ( _x[xCount - i] - _x[xCount - i - 1] )); xPredicted += (w[i][xCount] * (_x[xCount - i] - _x[xCount - i - 1]));
} }
xPredicted += _x[xCount-1]; xPredicted += _x[xCount - 1];
xError[xCount] = xActual - xPredicted; xError[xCount] = xActual - xPredicted;
fprintf(fp3, "{%d}.\txPredicted{%f}\txActual{%f}\txError{%f}\n", xCount, xPredicted, xActual, xError[xCount]); fprintf(fp3, "{%d}.\txPredicted{%f}\txActual{%f}\txError{%f}\n", xCount, xPredicted, xActual, xError[xCount]);
@ -226,11 +242,11 @@ void directPredecessor( void ) {
double xSquared = 0.0; double xSquared = 0.0;
for ( i = 1; i < xCount; i++ ){ for (i = 1; i < xCount; i++) {
xSquared += pow( _x[xCount - i] - _x[xCount - i - 1], 2); // substract direct predecessor xSquared += pow(_x[xCount - i] - _x[xCount - i - 1], 2); // substract direct predecessor
} }
for ( i = 1; i < xCount; i++){ for (i = 1; i < xCount; i++) {
w[i][xCount+1] = w[i][xCount] + learnrate * xError[xCount] * ( ( _x[xCount - i] - _x[xCount - i - 1] ) / xSquared ); //TODO: double val out of bounds w[i][xCount + 1] = w[i][xCount] + learnrate * xError[xCount] * ((_x[xCount - i] - _x[xCount - i - 1]) / xSquared); //TODO: double val out of bounds
} }
} }
@ -238,12 +254,12 @@ void directPredecessor( void ) {
double mean = sum_array(xError, xErrorLength) / xErrorLength; double mean = sum_array(xError, xErrorLength) / xErrorLength;
double deviation = 0.0; double deviation = 0.0;
for ( i = 0; i < xErrorLength -1; i++ ){ for (i = 0; i < xErrorLength - 1; i++) {
deviation += pow( xError[i] - mean, 2); deviation += pow(xError[i] - mean, 2);
} }
mkSvgGraph( points); mkSvgGraph(points);
fprintf(fp3, "{%d}.\tLeast Mean Squared{%f}\tMean{%f}\n\n", xCount, deviation, mean); fprintf(fp3, "{%d}.\tLeast Mean Squared{%f}\tMean{%f}\n\n", xCount, deviation, mean);
fclose(fp3); fclose(fp3);
} }
@ -252,108 +268,128 @@ void directPredecessor( void ) {
/* /*
========================================================================= =========================================================================
mkFileName mkFileName
Writes the current date plus the suffix with index suffixId Writes the current date plus the suffix with index suffixId
into the given buffer. If[M ?K the total length is longer than max_len, into the given buffer. If[M ?K the total length is longer than max_len,
only max_len characters will be written. only max_len characters will be written.
========================================================================= =========================================================================
*/ */
char *mkFileName( char* buffer, size_t max_len, int suffixId) { char *mkFileName(char* buffer, size_t max_len, int suffixId) {
const char * format_str = "%Y-%m-%d_%H_%M_%S"; const char * format_str = "%Y-%m-%d_%H_%M_%S";
size_t date_len; size_t date_len;
const char * suffix = fileSuffix( suffixId ); const char * suffix = fileSuffix(suffixId);
time_t now = time(NULL); time_t now = time(NULL);
strftime( buffer, max_len, format_str, localtime(&now) ); strftime(buffer, max_len, format_str, localtime(&now));
date_len = strlen(buffer); date_len = strlen(buffer);
strncat( buffer, suffix, max_len - date_len ); strncat(buffer, suffix, max_len - date_len);
return buffer;
} }
/* /*
========================================================================= =========================================================================
fileSuffix fileSuffix
Contains and returns every suffix for all existing filenames Contains and returns every suffix for all existing filenames
========================================================================== ==========================================================================
*/ */
char * fileSuffix( int id ) { char * fileSuffix(int id) {
char * suffix[] = {"_weights_pure.txt", "_weights_used.txt", "_direct_predecessor.txt", "_ergebnisse.txt", "_localMean.txt"}; char * suffix[] = { "_weights_pure.txt", "_weights_used.txt", "_direct_predecessor.txt", "_ergebnisse.txt", "_localMean.txt" };
return suffix[id]; return suffix[id];
} }
/* /*
========================================================================== ==========================================================================
svgGraph svgGraph
========================================================================== ==========================================================================
*/ */
/* /*
void Graph ( ) { void Graph ( ) {
char fileName[50]; char fileName[50];
mkFileName(fileName, sizeof(fileName), GRAPH); mkFileName(fileName, sizeof(fileName), GRAPH);
FILE* fp4 = fopen(fileName, "w"); FILE* fp4 = fopen(fileName, "w");
pfrintf pfrintf
*/ */
/* /*
========================================================================== ==========================================================================
myLogger myLogger
Logs on filepointer, used for svg graphing Logs on filepointer, used for svg graphing
========================================================================== ==========================================================================
*/ */
/*
void myLogger ( FILE* fp, point_t points[] ){ void myLogger(FILE* fp, point_t points[]) {
int i; int i;
for( i = 0; i <= M; i++ ){ // xActual for (i = 0; i <= M; i++) { // xActual
fprintf( fp, "L %f %f\n", points[i].xVal[0], points[i].yVal[0]); fprintf(fp, "L %f %f\n", points[i].xVal[0], points[i].yVal[0]);
} }
fprintf(fp, "\" fill=\"none\" stroke=\"blue\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n"); fprintf(fp, "\" fill=\"none\" stroke=\"blue\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
for( i = 0; i < M-1; i++ ) { // xPred from directPredecessor for (i = 0; i < M - 1; i++) { // xPred from directPredecessor
fprintf( fp, "L %f %f\n", points[i].xVal[1], points[i].yVal[1]); fprintf(fp, "L %f %f\n", points[i].xVal[1], points[i].yVal[1]);
} }
fprintf(fp, "\" fill=\"none\" stroke=\"green\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n"); fprintf(fp, "\" fill=\"none\" stroke=\"green\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
for( i = 0; i <= M; i++ ) { //xPred from lastMean for (i = 0; i <= M; i++) { //xPred from lastMean
fprintf(fp, "L %f %f\n", points[i].xVal[2], points[i].yVal[2]); fprintf(fp, "L %f %f\n", points[i].xVal[2], points[i].yVal[2]);
} }
} }
*/
void bufferLogger(char *buffer, point_t points[]) {
int i;
char _buffer[512] = "";
for (i = 0; i <= M; i++) { // xActual
sprintf(_buffer, "L %f %f\n", points[i].xVal[0], points[i].yVal[0]);
strcat(buffer, _buffer);
}
strcat(buffer, "\" fill=\"none\" stroke=\"blue\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
for (i = 0; i < M - 1; i++) { // xPred from directPredecessor
sprintf(_buffer, "L %f %f\n", points[i].xVal[1], points[i].yVal[1]);
strcat(buffer, _buffer);
}
strcat(buffer, "\" fill=\"none\" stroke=\"green\" stroke-width=\"0.4px\"/>\n<path d=\"M0 0\n");
for (i = 0; i <= M; i++) { //xPred from lastMean
sprintf(_buffer, "L %f %f\n", points[i].xVal[2], points[i].yVal[2]);
strcat(buffer, _buffer);
}
}
/* /*
========================================================================= =========================================================================
sum_array sum_array
Sum of all elements in x within a defined length Sum of all elements in x within a defined length
========================================================================= =========================================================================
*/ */
double sum_array( double x[], int length ){ double sum_array(double x[], int length) {
int i = 0; int i = 0;
double sum = 0.0; double sum = 0.0;
for( i=0; i< length; i++ ) { for (i = 0; i< length; i++) {
sum += x[i]; sum += x[i];
} }
return sum; return sum;
@ -361,47 +397,47 @@ double sum_array( double x[], int length ){
/* /*
========================================================================== ==========================================================================
r2 r2
returns a random double value between 0 and 1 returns a random double value between 0 and 1
========================================================================== ==========================================================================
*/ */
double r2( void ) { double r2(void) {
return((rand() % 10000) / 10000.0); return((rand() % 10000) / 10000.0);
} }
/* /*
========================================================================== ==========================================================================
rndm rndm
fills a double variable with random value and returns it fills a double variable with random value and returns it
========================================================================== ==========================================================================
*/ */
double rndm( void ) { double rndm(void) {
double rndmval= r2(); double rndmval = r2();
return rndmval; return rndmval;
} }
/* /*
========================================================================== ==========================================================================
getline getline
This code is public domain -- Will Hartung 4/9/09 This code is public domain -- Will Hartung 4/9/09 //edited by Kevin Becker
Microsoft Windows is not POSIX conform and does not support getline. Microsoft Windows is not POSIX conform and does not support getline.
========================================================================= =========================================================================
*/ */
#ifdef _WIN32 #ifdef _WIN32
size_t getline(char **lineptr, size_t *n, FILE *stream) { size_t getline(char **lineptr, size_t *n, FILE *stream) {
@ -427,17 +463,19 @@ size_t getline(char **lineptr, size_t *n, FILE *stream) {
return -1; return -1;
} }
if (bufptr == NULL) { if (bufptr == NULL) {
bufptr = malloc(128); char c[128];
memset(c, 0, sizeof(c));
bufptr = c;
if (bufptr == NULL) { if (bufptr == NULL) {
return -1; return -1;
} }
size = 128; size = 128;
} }
p = bufptr; p = bufptr;
while(c != EOF) { while (c != EOF) {
if ((p - bufptr) > (size - 1)) { if ((p - bufptr) > (size - 1)) {
size = size + 128; size = size + 128;
bufptr = realloc(bufptr, size); realloc(bufptr, size);
if (bufptr == NULL) { if (bufptr == NULL) {
return -1; return -1;
} }
@ -459,103 +497,124 @@ size_t getline(char **lineptr, size_t *n, FILE *stream) {
/* /*
========================================================================== ==========================================================================
mkSvgGraph mkSvgGraph
parses template.svg and writes results in said template parses template.svg and writes results in said template
========================================================================== ==========================================================================
*/ */
void mkSvgGraph( point_t points[] ) { void mkSvgGraph(point_t points[]) {
FILE *input = fopen ( "template.svg", "r" ); FILE *input = fopen("template.svg", "r");
FILE *target = fopen ( "output.svg", "w" ); FILE *target = fopen("output.svg", "w");
char *line = NULL; char line[512];
// char *ptr; // char *ptr;
size_t len = 0; //size_t len = 0;
ssize_t read; //ssize_t read;
char values[64]; //char values[64];
char firstGraph[15] = {"<path d=\"M0 0"}; /* There is a space behind the last zero, char firstGraph[15] = { "<path d=\"M0 0" };
but windows does not recognize it in strtsr() ?!
so no output will return*/
if( input == NULL ) { if (input == NULL) {
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
while ( ( read = getline(&line, &len, input) ) != -1) { char buffer[131072] = "";
//printf("Retrieved line of length %zu :\n", read);
//puts(line); // debug purpose memset(buffer, '\0', sizeof(buffer));
fprintf(target, "%s",line); //int length = 0;
if( strstr(line, firstGraph) != NULL ) { while(!feof(input)) {
//fprintf(target,"HECK!!!\n"); fgets(line, 512, input);
myLogger( target, points ); strncat(buffer, line,strlen(line));
} printf("%s\n", line);
if (strstr(line, firstGraph) != NULL) {
bufferLogger(buffer, points);
} }
free(line); }
// free(target); fprintf(target, buffer);
// free(input); //int c = 0;
puts(buffer);
//getchar();
//if (strstr(line, firstGraph) != NULL) {
// //fprintf(target,"HECK!!!\n");
// bufferLogger(strstr(line, firstGraph),sizeof(firstGraph), points);
//}
/*while ((read = getline(&line, &len, input)) != -1) {
//printf("Retrieved line of length %zu :\n", read);
//puts(line); // debug purpose
fprintf(target, "%s", line);
if (strstr(line, firstGraph) != NULL) {
fprintf(target,"HECK!!!\n");
myLogger(target, points);
}
}*/
/*free(line);
free(target);
free(input);*/
//exit(EXIT_SUCCESS); //exit(EXIT_SUCCESS);
} }
/* /*
=========================================================================== ===========================================================================
rdPPM rdPPM
reads data from file of type PPM, stores colorchannels in a struct in the reads data from file of type PPM, stores colorchannels in a struct in the
size of given picture size of given picture
========================================================================== ==========================================================================
*/ */
static imagePixel_t *rdPPM ( const char *fileName ) { static imagePixel_t *rdPPM(const char *fileName) {
char buffer [16]; char buffer[16];
imagePixel_t *image; imagePixel_t *image;
int c, rgbColor; int c, rgbColor;
FILE *fp = fopen ( fileName, "rb" ); FILE *fp = fopen(fileName, "rb");
if ( !fp ) { if (!fp) {
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if ( !fgets (buffer, sizeof(buffer), fp) ) { if (!fgets(buffer, sizeof(buffer), fp)) {
perror(fileName); perror(fileName);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if ( buffer[0] != 'P' || buffer[1] != '6' ) { if (buffer[0] != 'P' || buffer[1] != '6') {
fprintf(stderr,"No PPM file format\n"); fprintf(stderr, "No PPM file format\n");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
image = (imagePixel_t *) malloc (sizeof(imagePixel_t)); image = (imagePixel_t *)malloc(sizeof(imagePixel_t));
if (!image ) { if (!image) {
fprintf(stderr, "malloc() failed"); fprintf(stderr, "malloc() failed");
} }
c = getc(fp); c = getc(fp);
while ( c == '#' ) { while (c == '#') {
while ( getc(fp) != '\n' ); while (getc(fp) != '\n');
c = getc(fp); c = getc(fp);
} }
ungetc(c, 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); fprintf(stderr, "Invalid image size in %s\n", fileName);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if ( fscanf(fp, "%d", &rgbColor) != 1 ) { if (fscanf(fp, "%d", &rgbColor) != 1) {
fprintf(stderr, "Invalid rgb component in %s\n", fileName); 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 ); fprintf(stderr, "Invalid image color range in %s\n", fileName);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
while ( fgetc(fp) != '\n' ); while (fgetc(fp) != '\n');
image->data = (imagePixel_t *) malloc(image->x * image->y * sizeof(imagePixel_t)); image->data = (colorChannel_t *)malloc(image->x * image->y * sizeof(imagePixel_t));
if ( !image ) { if (!image) {
fprintf(stderr, "malloc() failed" ); fprintf(stderr, "malloc() failed");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
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"); fprintf(stderr, "Loading image failed");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
@ -566,46 +625,48 @@ static imagePixel_t *rdPPM ( const char *fileName ) {
/* /*
======================================================================================= =======================================================================================
mkPpmFile mkPpmFile
gets output from the result of rdPpmFile and writes a new mkPpmFile. Best Case is a gets output from the result of rdPpmFile and writes a new mkPpmFile. Best Case is a
carbon copy of the source image carbon copy of the source image
======================================================================================= =======================================================================================
*/ */
void mkPpmFile ( char *fileName, imagePixel_t *image ) { void mkPpmFile(char *fileName, imagePixel_t *image) {
FILE* fp = fopen(fileName, "wb" ); FILE* fp = fopen(fileName, "wb");
if ( !fp ) { if (!fp) {
fprintf(stderr, "Opening file failed." ); fprintf(stderr, "Opening file failed.");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
fprintf(fp, "P6\n"); fprintf(fp, "P6\n");
fprintf(fp, "%d %d\n", image->x, image->y); fprintf(fp, "%d %d\n", image->x, image->y);
fprintf(fp, "%d\n", RGB_COLOR); fprintf(fp, "%d\n", RGB_COLOR);
fwrite(image->data, 3* image->x, image->y, fp); fwrite(image->data, 3 * image->x, image->y, fp);
fclose(fp); fclose(fp);
} }
/* /*
====================================================================================== ======================================================================================
ppmColorChannel ppmColorChannel
gets one of the rgb color channels and returns the array gets one of the rgb color channels and returns the array
====================================================================================== ======================================================================================
*/ */
int * ppmColorChannel( imagePixel_t *image ) { int * ppmColorChannel(imagePixel_t *image) {
int length = (image->x * image->y)/3, i; int length = (image->x * image->y) / 3;
int buffer[length]; int i = 0;
int buffer[10];
realloc(buffer,length);
printf("%d\n", length); printf("%d\n", length);
if ( image ){ if (image) {
for ( i = 0; i < length; i++ ) { for (i = 0; i < length; i++) {
buffer[i] = image->data[i].green; buffer[i] = image->data[i].green;
//output[i] = image->data[i].blue; //output[i] = image->data[i].blue;
//output[i] = image->data[i].red; //output[i] = image->data[i].red;
@ -613,5 +674,3 @@ int * ppmColorChannel( imagePixel_t *image ) {
} }
return buffer; return buffer;
} }