Read in binary file ( pointers )

Hi, having some problems reading in a binary file, using the fread() command.

The function below is meant to take in a filename and header structure (structure not important) and open the file, which is a .ppm file if you are interested, then skip through the header of the file (which i believe it does) then fread all of the rest of the data in the file into one big array (width * height of ppm image). After this return the pointer (to the array where it has stored all of this data) to the function that called it....only problem is, that when i try to print out the buffer (variable - ptr_data in my code) i dont get what is in the file, and the fread only reads one item then terminates...

any help would be appreciated

Code:

---


int *ReadImageData(char * fname, headerstruct *temp_head){
       
        int *ptr_data;//, *ptr_data_G, *ptr_data_B;
        int i=0, NumByteRead = 0, count = 0;
        FILE *fptr;
        size_t j=0;

        NumByteRead = (atoi(temp_head->width) * atoi(temp_head->height));
        ptr_data = new int[NumByteRead];
        if((fptr = fopen(fname,"r")) == NULL) {
                printf("\nFailed to Open file -: %s\n", fname);
                exit(-1);
        }
        else{
                while(j<(temp_head->headerend)){j++;getc(fptr);}
                //printf("\nSkipping through header %d",j);
                if(count = (fread(ptr_data, 1, NumByteRead, fptr)) != NumByteRead)
                {
                        printf("\nTo few charaters read at fread %d - actual count %d\n", NumByteRead, count);
                        printf("\nValue in buffer - %x", ptr_data);
                        exit(-1);
                }
        }

        fclose(fptr);
        return (ptr_data);//, ptr_data_G, ptr_data_B);
}

---

just incase it is important

Code:

---

struct headerstruct{
        char fullheader[32];
    char prefix[4];
        char width[4];
        char height[4];
        char pixelmaxvalue[4];
        size_t headerend;
};

---

Doin this on Windows? If so you MUST open the file in binary mode!

You should realize that it is unsafe to use the width*height values supplied in the file directly, always do some sanity checking on them before allocating memory.

okay, obvious question time :S

how do i open the file in binary mode and what does fopen() do ?

fopen(fname,"rb");

What do you mean what does fopen do? It opens the file for input or output (or both).

sorry got confused about fopen and if there was a different binary variation, but got it now.

Anyway I am still getting the wrong data back, I have even gone as far as found out the total count (as fread() is meant to return total number of items read) but when the value of count is printed out it returns (EDIT)the correct amount (which for a ppm image of 492 by 708 is 1045008 [3*width*height])(EDIT)

any other ideas :/ about what could be affecting the fread line/or function as a whole?

thanks for the help,
Giant.

p.s. I used fopen(fname, "rb") and this passed the if defination on the fread line, but like i said above still getting wrong values back :_(

Post your updated code and I will take a look. If you have some sample input, you can attatch that as well.

read up abit ;) so apparently the count of fread thinks it is taking in the full amount....

i have just worked out what it is doing,

it is reading in the correct hex values but as it reads more it it pushes them along the buffer so my output looks like -: 6a293870, the hex file actually goes (after header) 70 38 29 6a

when infact i need the output to be 70 (and thats it) any ideas why i am going wrong on that front ?

i have just checked and it seems to be reading the file in, in 4 byte chunks per array

EDIT:

Code:

---

if((count = (fread(ptr_data, 1, 3*NumByteRead, fptr))) != 3*NumByteRead)

---

returns the same 4 byte chunk as ->

Code:

---

if((count = (fread(ptr_data, 100, 3*NumByteRead, fptr))) != 3*NumByteRead)

---

I think you need to post some code. Strip the problematic code out to a separate program and make it as small as you can that still replicates the problem. Be sure to include the appropriate data file!

Well that didnt take long to shorten as i thought it would ;)....

anyway here is the code, still giving me the same error :(

Code:

---

#include "practice.h"
/*
        Expect a series of images of the form base0000.ppm, base0001.ppm, etc
        Supports forward or reverse image ordering
*/
void ReadImageData(char *, headerstruct*);
int main(int argc, char **argv)
{
        filenamestruct *ptr_file;
        headerstruct *ptr_header;
        ptr_file = new filenamestruct;
        ptr_header = new headerstruct;
       
        strncpy(ptr_file->nextFileName,argv[1], strlen(ptr_file->nextFileName));
        strncpy(ptr_header->height,"708",3);
        strncpy(ptr_header->width,"492",3);
        ptr_header->headerend = 15;

        ReadImageData(ptr_file->nextFileName, ptr_header);
}

void ReadImageData(char * fname, headerstruct *temp_head){
       
        int *ptr_data;
        int i=0, NumByteRead = 0;
        FILE *temp_fptr;
        size_t j=0, count = 0, sizeofoneitem = 1;

        NumByteRead = (atoi(temp_head->width) * atoi(temp_head->height));
        ptr_data = new int[3*NumByteRead];

        temp_fptr = fopen(fname,"rb");
        while(j<(temp_head->headerend)){j++;getc(temp_fptr);}

        fread(ptr_data, sizeofoneitem, (3*NumByteRead), temp_fptr);
        printf("\nValue in first buffer(ptr_data[0]) - %x", ptr_data[0]); //max of 261251
        fclose(temp_fptr);
}

---

Code:

---


struct filenamestruct{
        char basename[128];
        char basefolder[128];
        char basenumber[128];
        char nextFileName[256];
        size_t maximagenumber;
        size_t originalbasenumber;
};

struct headerstruct{
        char fullheader[32];
        char prefix[4];
        char width[4];
        char height[4];
        char pixelmaxvalue[4];
        size_t headerend;
};

---

sorry forgot structures

What is in practice.h?

Nothing much just the includes (you can see them below as i hav streamlined some more to make it as simple as possible, though i still cant see where i am going wrong :( )

Code:

---

#include <iostream>
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "ctype.h"
using namespace std;/*
        Expect a series of images of the form base0000.ppm, base0001.ppm, etc
        Supports forward or reverse image ordering
*/
int main(int argc, char **argv)
{
        int *ptr_data;
        int i=0, NumByteRead = 0, height, width;
        FILE *temp_fptr;//, *test;
        size_t j=0, count = 0, sizeofoneitem = 1,headerend=0;

        height=708;
        width=492;
        headerend = 15;
       
        NumByteRead = 3*width*height;

        ptr_data = new int[NumByteRead];
        temp_fptr = fopen(argv[1],"rb");

        while(j<headerend){
                j++;
                //fprintf(test,"%2x",
                getc(temp_fptr);//);
        } //jumps through header file

        fread(ptr_data, sizeofoneitem, (NumByteRead), temp_fptr);
        printf("\nValue in first buffer(ptr_data[0]) - %02x", ptr_data[0]); //max of 261251
       
        fclose(temp_fptr);
}

---

Is this what you are working on: http://netpbm.sourceforge.net/doc/ppm.html? If so, why reinvent the wheel?

In order to debug your code I will need the exact ppm file you are using (it sounds like you can zip it up and get it very small).

BTW, this is the exact code I will be working with (I cleaned it up and formatted it):

Code:

---

#include <cstdio>

using namespace std;
/*
    Expect a series of images of the form base0000.ppm, base0001.ppm, etc
    Supports forward or reverse image ordering
*/
int main(int argc, char **argv) {
    int *ptr_data;
    int i=0, NumByteRead = 0, height, width;
    FILE *temp_fptr;
    size_t j=0, count = 0, sizeofoneitem = 1,headerend=0;

    height=708;
    width=492;
    headerend = 15;

    NumByteRead = 3*width*height;

    ptr_data = new int[NumByteRead];
    temp_fptr = fopen(argv[1],"rb");

    while(j<headerend) {
        j++;
        getc(temp_fptr);
    }

    fread(ptr_data, sizeofoneitem, (NumByteRead), temp_fptr);
    printf("\nValue in first buffer(ptr_data[0]) - %02x", ptr_data[0]);
    fclose(temp_fptr);
    return 0;
}

---

I havent seen that webapge before tbh, i am on student placement right now from university, and my boss wants me to do things with .ppm files, but before i can manipulate them I need to be able to read them into a suitable array.

how do you want me to send you the .ppm file (its 740 kb, which isnt a problem for me to send to you) ?

Zip it up and post it as an attatchment. If you click on 'post reply' on the left-hand side of the screen (as opposed to using the 'Quick Reply' box) you have many more options. I am leaving in about a half hour, but I will try to get something for you either today or tomorrow if no one else helps out.

it wont let me upload it as it isnt a recognised filetype, and when i change the name it limits everything to 193.0 kb and this is 760 :S

Try to zip it up and then rename it to .txt and see what happens.

If you have a web server somewhere you can put it on and give me a link we can do it that way.

i already tried the zip (the file is originally 1Mb) i dont have hosting but asking a mate now, could i not email it to you ?

I don't care for large files emailed to me. I probably won't be home after work for a couple of hours, but I can try to work on it this evening if you have worked out a place to put it where I can reach it. Do you have a smaller ppm file? I am quite certain you have made some fatal assumptions about the file format and are reading in junk as a consequence, but unless I see exactly what you are doing (i.e., can run a debugger with your datafile), I can't be certain it isn't just a simple little mistake. There are dozens (probably hundreds) of image file format each with probably at least a half-dozen different variations. The only way you can be positive your program will always handle the data correctly is to either get a third-party library (like at the link I suggested) or only read files generated by the same program. Giving a quick look at the ppm file format, it looks like there is a huge amount of variability in the whitespace layout, simply getting this into a block of memory is not likely to solve your long-term problem.

my good friend and soon to be flatmate has come through for me once again and the file is hosted (it its original format) here : http://adrock.ath.cx/img0061.ppm

thanks again for the help,
Matt.

i can deal with the whitespace layout (in fact my full program ignores it completely) and 'headerend' (in the full program) is generated by counting how much whitespace+header+comment the program ahs to deal with before the header ends.

I was led to believe that with a .ppm file after the header file, the information has to be giving (usually from pixel top to bottom, left to right) in a uniform manner (i.e. after header no whitespace and no comments) I got this from http://astronomy.swin.edu.au/~pbourke/dataformats/ppm/ though I may be wrong (i frequently am :S).

Code:

---

int *ptr_data;

---

Shouldn't it be an unsigned char*?

I can't access the server to get the file.

The ppm file format is not 'binary' data, it is human-readable ASCII data and as such your attempts to read it as a binary chunk via fread is basically doomed to failure. You need to read in each pixel value into an integer via fscanf() or cin (depending on C vs C++ respectively) in some sort of loop. If I get time tonight (and I can get your file to download) or tomorrow morning if I don't get time tonight, I can put together a program based on the URL you supplied to read in the data.

If the .zip version isn't small enough, try .rar ing it with WinRAR. RAR is usually smaller than ZIP. And WinRAR can do both formats.

Quote:

---

Originally Posted by mitakeet

The ppm file format is not 'binary' data, it is human-readable ASCII data

---

Or it isn't. From what I've read, it depends.

Quote:

---

Quote:
Originally Posted by mitakeet
The ppm file format is not 'binary' data, it is human-readable ASCII data

---

yeah depending on what is set up in the header portion of the file, if it is in 'p3' format then it is ASCII but if it is in p6 format then its in simple byte format.

Quote:

---

If the PPM magic identifier is "P6" then the image data is stored in byte format, one byte per colour component (r,g,b).

---

i will have alook at fscanf() to see what that returns. (it can't be any worse.....;) )

cheers,
matt

Looking at the file (I was able to download it) it sure ain't ASCII. I will try to develop a program to read the file and store it in a structure for you.

This works on Windows and on Solaris (Unix):

Code:

---

#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

/*
    Expect a series of images of the form base0000.ppm, base0001.ppm, etc
    Supports forward or reverse image ordering
*/
int main(int argc, char **argv) {
    unsigned char *ptr_data;
    int i=0, height, width, color;
    FILE *temp_fptr;
    size_t totBytes, bytesRead;
    const char *fileName = "img0061.ppm"; /* get from the command line */
    char buf[BUFSIZ];

    temp_fptr = fopen(fileName,"rb");
    if (!temp_fptr){
        fprintf(stderr, "Can't open file!\n");
        exit(1);
    }

    /* get and check magic number */
    i=0;
    while (!isspace(buf[i] = fgetc(temp_fptr))){i++;}
    buf[i] = '\0';
    if (strncmp(buf, "P6", 2)){
        fprintf(stderr, "File's magic number is invalid! (only read P6 files)\n");
        exit(1);
    }

    /* get and check width */
    i=0;
    while (!isspace(buf[i] = fgetc(temp_fptr))){i++;}
    buf[i] = '\0';
    if (sscanf(buf, "%d", &width) != 1){
        fprintf(stderr, "Failed to read in width correctly!\n");
        exit(1);
    }
    if (width < 1 || width > 65536){ /* arbitrary upper limit, you can change this */
        fprintf(stderr, "Invalid or out-of-bounds value for width!\n");
        exit(1);
    }

    /* get and check height */
    i=0;
    while (!isspace(buf[i] = fgetc(temp_fptr))){i++;}
    buf[i] = '\0';
    if (sscanf(buf, "%d", &height) != 1){
        fprintf(stderr, "Failed to read in height correctly!\n");
        exit(1);
    }
    if (height < 1 || height > 65536){ /* arbitrary upper limit, you can change this */
        fprintf(stderr, "Invalid or out-of-bounds value for height!\n");
        exit(1);
    }


    /* get color (don't care about validity) */
    i=0;
    while (!isspace(buf[i] = fgetc(temp_fptr))){i++;}
    buf[i] = '\0';
    if (sscanf(buf, "%d", &color) != 1){
        fprintf(stderr, "Failed to read in color correctly!\n");
        exit(1);
    }
    totBytes = 3*width*height;

    ptr_data = (unsigned char *) malloc(totBytes);
    if (!ptr_data){
        fprintf(stderr, "Failed to allocate %d bytes of memory!\n", totBytes);
        exit(1);
    }
    bytesRead = fread(ptr_data, 1, (totBytes), temp_fptr);

    printf("\nbytesRead: %d\nFirst 10 bytes in hex:\n", bytesRead);
    for (i=0; i<10; i++){
        printf("%02X ", ptr_data[i]);
    }
    printf("\n");

    fclose(temp_fptr);
    free(ptr_data);

    return 0;
}

---

My output:


bytesRead: 1045008
First 10 bytes in hex:
70 38 29 6A 3B 2A 59 31 27 51

:D I do not know how to thank you enough....i have been working on this problem for 3 straight days and now (thanks to your good self) it is working a treat :) thanks again

Matt.

p.s. its my birthday today as well, so cheers for the random present ;)

Happy Birthday! Happy to help.

Right...here's an interesting question (i hope ;) ).


I believe what is happen in the program you made, is that you are making a pointer to an array then saving all the relevant pixel information to that array. If i was to pass that pointer back to the function that called it (which in turn stores each pointer into an array), would that work? because at present it does not seem too

basically the function call is:

Code:

---

ptr_pixeldata[i] = *ReadImageData(ptr_file->nextFileName, ptr_header);

---

with 'i' increasing as the filenumber increases (this is all done automatically and works fine),

when i use your script as function ReadImageData and print information form within that function it is fine and as you would expect, but when i want to print information from within the function where the call line resides, it wont work.

I am using:

Code:

---

for (k=0; k<10; k++){
printf("%02X \n", ptr_pixeldata[i][j]);
//this returns error C2109: subscript requires array or pointer type
//so output is with ptr_pixeldata[i]
}

---

to try and print the first ten values of the specific photo that i represents....
any reason why this shouldn't work ?

output:

Output From File Number 0061 is: 70
70
70
70
70
70
70
70
70
70

my return line is

Code:

---

return(ptr_data);

---

I may root around and try to put together a Windows program to actually display this, if so I will post back with the image. Does this help you?

Code:

---

#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

/* note that most compilers will pad this structure to 4 bytes! */
struct PixelRGB{
    unsigned char Red, Green, Blue;
};

/*
    Expect a series of images of the form base0000.ppm, base0001.ppm, etc
    Supports forward or reverse image ordering
*/
int main(int argc, char **argv) {
    int i, j, height, width, color;
    FILE *temp_fptr;
    size_t totBytes, bytesRead;
    const char *fileName = "img0061.ppm"; /* get from the command line */
    char buf[BUFSIZ];
    struct PixelRGB **image;

    temp_fptr = fopen(fileName,"rb");
    if (!temp_fptr){
        fprintf(stderr, "Can't open file!\n");
        exit(1);
    }

    /* get and check magic number */
    i=0;
    while (!isspace(buf[i] = fgetc(temp_fptr))){i++;}
    buf[i] = '\0';
    if (strncmp(buf, "P6", 2)){
        fprintf(stderr, "File's magic number is invalid! (only read P6 files)\n");
        exit(1);
    }

    /* get and check width */
    i=0;
    while (!isspace(buf[i] = fgetc(temp_fptr))){i++;}
    buf[i] = '\0';
    if (sscanf(buf, "%d", &width) != 1){
        fprintf(stderr, "Failed to read in width correctly!\n");
        exit(1);
    }
    if (width < 1 || width > 65536){ /* arbitrary upper limit, you can change this */
        fprintf(stderr, "Invalid or out-of-bounds value for width!\n");
        exit(1);
    }

    /* get and check height */
    i=0;
    while (!isspace(buf[i] = fgetc(temp_fptr))){i++;}
    buf[i] = '\0';
    if (sscanf(buf, "%d", &height) != 1){
        fprintf(stderr, "Failed to read in height correctly!\n");
        exit(1);
    }
    if (height < 1 || height > 65536){ /* arbitrary upper limit, you can change this */
        fprintf(stderr, "Invalid or out-of-bounds value for height!\n");
        exit(1);
    }


    /* get color (don't care about validity) */
    i=0;
    while (!isspace(buf[i] = fgetc(temp_fptr))){i++;}
    buf[i] = '\0';
    if (sscanf(buf, "%d", &color) != 1){
        fprintf(stderr, "Failed to read in color correctly!\n");
        exit(1);
    }
    totBytes = 3*width*height;


    image = (struct PixelRGB **) malloc(width * sizeof(struct PixelRGB *));
    if (!image){
        fprintf(stderr, "Failed to allocate %d bytes of memory for first dimension of image array!\n", width * sizeof(struct PixelRGB *));
        exit(1);
    }
    for (i=0; i<width; i++){
        image[i] = (struct PixelRGB *) malloc(height * sizeof(struct PixelRGB));
        if (!image[i]){
            fprintf(stderr, "Failed to allocate %d bytes of memory for second dimension of image array %d!\n", height * sizeof(struct PixelRGB), i+1);
            exit(1);
        }
    }

    /* I am only reading in the bytes one at a time for clarity, this could be buffered
      though the performance gain would be marginal */
    bytesRead = 0;
    for (i=0; i<width; i++){
        for (j=0; j<height; j++){
            image[i][j].Red  = (unsigned char) fgetc(temp_fptr);
            image[i][j].Green = (unsigned char) fgetc(temp_fptr);
            image[i][j].Blue  = (unsigned char) fgetc(temp_fptr);
            bytesRead += 3;
            if (feof(temp_fptr)) break;
        }
        if (feof(temp_fptr)) break;
    }
    fclose(temp_fptr);

    printf("\nbytesRead: %d\nFirst 9 bytes in hex:\n", bytesRead);
    for (i=0; i<3; i++){
        printf("%02X ", image[0][i].Red);
        printf("%02X ", image[0][i].Green);
        printf("%02X ", image[0][i].Blue);
    }
    printf("\n");


    /* deallocate memory */
    for (i=0; i<width; i++){
        free(image[i]);
    }
    free(image);

    return 0;
}

---

erm sort of , you do give me a clearer indication of what I need to do, though i am still pretty lost :(, below is a simplified version of my code as it stands (most of the validation and header checking have been taking out)

Code:

---

#include <iostream>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "practice.h"
/*
        Expect a series of images of the form base0000.ppm, base0001.ppm, etc
        Supports forward or reverse image ordering
*/
filenamestruct* GetImageBase(char *, filenamestruct*);
headerstruct* GetHeader(char *, headerstruct*);
unsigned char* ReadImageData(const char *, headerstruct*);
int CheckHeader(char*, headerstruct*);

int main(int argc, char **argv)
{
        //intialisation code
        size_t i=0,k=0, flag_done= 0, maximagenumber;
        filenamestruct *ptr_file;
        headerstruct *ptr_header;
//        char *ptr_pixeldata;
    unsigned char *ptr_pixeldata;
        int bn = 0;
        char bn_ch[4];

        ptr_file = new filenamestruct;
        ptr_header = new headerstruct;

        maximagenumber = 1;

        ptr_pixeldata = (unsigned char *) malloc(maximagenumber);

        while(i<(maximagenumber))
        {
                ptr_pixeldata[i] = (unsigned char) malloc((atoi(ptr_header->width))*(atoi(ptr_header->height)));
                ptr_pixeldata[i] = *ReadImageData(argv[1], ptr_header);

                printf("\nOutput From File is: ");
                for (k=0; k<10; k++){
        printf("%02X \n", ptr_pixeldata[i][k]);
        }
                  i++;
                //get next filename here at the moment just use one filename
        }

}

unsigned char* ReadImageData(const char *fileName, headerstruct *temp_head){
       
        unsigned char *ptr_data;
    FILE *temp_fptr;
    size_t j=0,totBytes, bytesRead;
   
    temp_fptr = fopen(fileName,"rb");
    if (!temp_fptr){
        fprintf(stderr, "Can't open file!\n");
        exit(1);
    }

    while(j<(temp_head->headerend)){j++;getc(temp_fptr);}//jump header

        totBytes = 3*(atoi(temp_head->height))*(atoi(temp_head->width));

    ptr_data = (unsigned char *) malloc(totBytes);
    if (!ptr_data){
        fprintf(stderr, "Failed to allocate %d bytes of memory!\n", totBytes);
        exit(1);
    }
    bytesRead = fread(ptr_data, 1, (totBytes), temp_fptr); //if does not equal count then errorz

    fclose(temp_fptr);
    return (ptr_data);
}

---

ha, got it working, cheers for the help, definatly pointed me in the right direction ;)

Correct me if my assumptions are incorrect, but don't you want to read the image data into a 2d array of RGB values for manipulation/display? That is exactly what my code is doing. Without spending a lot of time looking at your code, I am pretty sure you have massive memory leaks (allocating memory but never deallocating it). This is not fatal as once the program exits the OS cleans up after the app, but it is very poor programming practice.

Perhaps if you explain what you are trying to do and give some very high-level pseudo code I can be of more help.

BTW, you are using plenty of C++ constructs yet are posting on a C board. Are you doing that on purpose or do you not realize the differences? Encapsulating this in classes would be a much cleaner way of handling things.

this is where the fact that i dont know either C or C++ well (certainly C better than C++) at all comes out :(. And I thought I was using C enough to warrent posting on this board, though i could be wrong.

What I am wanting to do is:

Take in an[EDIT]series of .ppm images and store each image in an array of pixelvalues, then store this array in another array of all images. Obviously I don't want to be copying big files from one array to another, so I was hoping to take in an image to an array then pass the pointer to this array back to another array, where I could call it like: i.e.

Code:

---

pixelvalue[photonumber][pixellocation]

---

pixel location is set in one field (and not [x][y], though i suppose it could be, as later I will be processing every pixel so it doesnt matter how they are stored as long as they are in order)

Each pixel is made up of 3 8 bit values (RGB, Red, Green and Blue) and each image is logically a 2d array of pixels, so the format I provided will make it easiest for any post-processing. This will give you an idea of where to go, but it needs some tweaking. Personally I would do all this in C++ classes so you don't have to remember to deallocate memory all the time.

Code:

---

#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

/* note that most compilers will pad this structure to 4 bytes! */
struct PixelRGB{
    unsigned char Red, Green, Blue;
};


struct PixelRGB **getImageIntoArray(const char *fileName) {/* returns NULL if error */
    int i, j, height, width, color;
    FILE *temp_fptr;
    size_t bytesRead;
    char buf[BUFSIZ];
    struct PixelRGB **image;

    temp_fptr = fopen(fileName,"rb");
    if (!temp_fptr){
        fprintf(stderr, "Can't open file!\n");
        return NULL;
    }

    /* get and check magic number */
    i=0;
    while (!isspace(buf[i] = fgetc(temp_fptr))){i++;}
    buf[i] = '\0';
    if (strncmp(buf, "P6", 2)){
        fprintf(stderr, "File's magic number is invalid! (only read P6 files)\n");
        return NULL;
    }

    /* get and check width */
    i=0;
    while (!isspace(buf[i] = fgetc(temp_fptr))){i++;}
    buf[i] = '\0';
    if (sscanf(buf, "%d", &width) != 1){
        fprintf(stderr, "Failed to read in width correctly!\n");
        return NULL;
    }
    if (width < 1 || width > 65536){ /* arbitrary upper limit, you can change this */
        fprintf(stderr, "Invalid or out-of-bounds value for width!\n");
        return NULL;
    }

    /* get and check height */
    i=0;
    while (!isspace(buf[i] = fgetc(temp_fptr))){i++;}
    buf[i] = '\0';
    if (sscanf(buf, "%d", &height) != 1){
        fprintf(stderr, "Failed to read in height correctly!\n");
        return NULL;
    }
    if (height < 1 || height > 65536){ /* arbitrary upper limit, you can change this */
        fprintf(stderr, "Invalid or out-of-bounds value for height!\n");
        return NULL;
    }


    /* get color (don't care about validity) */
    i=0;
    while (!isspace(buf[i] = fgetc(temp_fptr))){i++;}
    buf[i] = '\0';
    if (sscanf(buf, "%d", &color) != 1){
        fprintf(stderr, "Failed to read in color correctly!\n");
        return NULL;
    }


    image = (struct PixelRGB **) malloc(width * sizeof(struct PixelRGB *));
    if (!image){
        fprintf(stderr, "Failed to allocate %d bytes of memory for first dimension of image array!\n", width * sizeof(struct PixelRGB *));
        return NULL;
    }
    for (i=0; i<width; i++){
        image[i] = (struct PixelRGB *) malloc(height * sizeof(struct PixelRGB));
        if (!image[i]){
            fprintf(stderr, "Failed to allocate %d bytes of memory for second dimension of image array %d!\n", height * sizeof(struct PixelRGB), i+1);
            return NULL;
        }
    }

    /* I am only reading in the bytes one at a time for clarity, this could be buffered
      though the performance gain would be marginal */
    bytesRead = 0;
    for (i=0; i<width; i++){
        for (j=0; j<height; j++){
            image[i][j].Red  = (unsigned char) fgetc(temp_fptr);
            image[i][j].Green = (unsigned char) fgetc(temp_fptr);
            image[i][j].Blue  = (unsigned char) fgetc(temp_fptr);
            bytesRead += 3;
            if (feof(temp_fptr)) break;
        }
        if (feof(temp_fptr)) break;
    }
    fclose(temp_fptr);

    printf("width: %d\n", width);
    printf("height: %d\n", height);
    printf("bytesRead: %d\n", bytesRead);
    printf("First 9 bytes in hex:\n");
    for (i=0; i<3; i++){
        printf("%02X ", image[0][i].Red);
        printf("%02X ", image[0][i].Green);
        printf("%02X ", image[0][i].Blue);
    }
    printf("\n");


    return image;
}

int main(int argc, char **argv) {
    int i, j, numImages = 3;/* hard-coded for convinence */
    const char *fileName = "img0061.ppm"; /* get from the command line */
    struct PixelRGB ***imageMatrix;/* a pointer to a series of 2d arrays */




    imageMatrix = (struct PixelRGB ***) malloc(numImages * sizeof(struct PixelRGB ***));
    if (!imageMatrix){
        fprintf(stderr, "Failed to allocate memory for imageMatrix array!\n");
        exit(1);
    }
    for (i=0; i<numImages; i++){
        imageMatrix[i] = getImageIntoArray(fileName);
    }

    printf("\n\nFrom main()\n\n");

    for (j=0; j<numImages; j++){
        printf("image number %d\n", j+1);
        printf("First 9 bytes in hex:\n");
        for (i=0; i<3; i++){
            printf("%02X ", imageMatrix[j][0][i].Red);
            printf("%02X ", imageMatrix[j][0][i].Green);
            printf("%02X ", imageMatrix[j][0][i].Blue);
        }
        printf("\n");
    }


    /* deallocate memory */
    for (j=0; j<numImages; j++){
        for (i=0; i<492; i++){ /* width hard-coded here, the best way to handle this is to use classes */
            free(imageMatrix[j][i]);
        }
        free(imageMatrix[j]);
    }
    free(imageMatrix);

    return 0;
}

---

i have to go now :( meeting the parents for dinner :), but i will work on this tomorrow, thanks for all your help (AGAIN!)

just a quick update, slotted your program into my existing code, and it showed me where I was going wrong (especially with allocating memory) and even showed me where I was getting memory leaks which was v. good. All I need to do now is some post processing (which wont be easy, but determined to do this on my own [its all maths rather than hard programming ;)]). So thanks alot for all your help, there is no way i would be at this stage with out it :D.

No problemo, happy to help. Good luck on the rest of your project and don't hessitate to ask if you have problems!