Thread: Read in binary file ( pointers )

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;
}

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;
}

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