Generate different types using a byte array

Use C++ not C

First of all, you are making a lot usage of C, not C++. In C++ you either use the keyword class or struct to declare a class/struct, not together with the keyword typedef.

You are using uint32_t a lot. This is also C style; the proper C++ style is the std::unit32_t type. But most of the time you don't really need to specify the width of your integer directly. This only makes sense if you want to serialize/deserialize them.

Use new and delete instead of malloc and free. Better: use smart pointers like std::unique_ptr and std::shared_ptr.

declare properties private (encapsulate them)

The problem here is, you are using public available objects inside of the IMAGE_STRUCT struct, which can be modified from the outside.

split up your functions

Your atImageEvent function is huge! Split it up into smaller parts.

name conventions

There are no explicit name conventions at all, but you should not declare your classes/structs with only capital characters (like IMAGE_STRUCT). Most of the times words with only capital characters are macros. It's not a mistake rather than a bit of taste.

If I am not totally wrong names beginning with _ are reserved by the standard and should not be used for custom code. To be honest, I am using them myself, but I think it's worth mentioning this.

undefined behaviour

union
{
    uint16_t _imgHeight;
    uint8_t *_byteArray;
}uImgHeight;
memcpy(&uImgHeight._byteArray, imgHeight, heightLength);
free(imgHeight);   
output_image_struct.nHeight = uImgHeight._imgHeight;

You are running into undefined behavior here, because you are reading from a union property without writing to it first. Unions should not be used to convert types to each other. It is not safe!

I am sure, the code doesn't do what you expect. Your code says you are converting a uint8_t pointer to uint16_t integer. You are not accessing the data, just the address!

In the end I did not review the correctness of your code, I just stepped over the obvious mistakes you made in your code.

First of all, please clarify what language you're programming in. You tagged the question both C and C++. The code has elements of both. I'll be commenting from the C angle since the code feels like a C function that was refactored to use cout <<, but the comments should apply in either case.

You make a few repeated mistakes throughout the function. I'll use this block as a representative sample and discuss individual issues in the order that I found them:

id = (uint8_t *)malloc(sizeof(uint32_t));      // #1
memset(id, 0x00, idLength);                    // #2
dataIndex = idLength;
memcpy(id, sfimageData, sizeof(uint32_t));     // #3

union
{
    uint32_t _id;
    uint8_t *_byteArray;
}uId;
memcpy(&uId._byteArray, id, sizeof(uint32_t)); // #4
free(id);

output_image_struct.id = uId._id;              // #5

#1 Dynamically allocating something as small as a 32-bit integer is frequently pointless. The pointer to this new buffer is likely at least 32 bits long. Just declare a 32-bit stack variable and use that instead (bonus perk: no cleanup required).

#2 When you're allocating a buffer and initializing it with memset, make sure you use the exact same size parameters for both function calls. Here, you allocate sizeof(uint32_t) bytes, but you're writing zeroes to idLength bytes. There's nothing forcing those two things to always be equal. Use sizeof(uint32_t) in both places and you don't have to worry about memory corruption due to a variable getting changed.

#3 Why zero out the variable at all? The next thing you do is to memcpy different data into it. The first memset is unnecessary here.

#4 So you've already copied four bytes of sfimageData into buffer id, and now you're copying it into uId._byteArray. Why the additional copy steps?

#5 Okay, now this is the third time you've copied this one piece of data. Just copy it directly here from the beginning. You can replace this entire code block with memcpy(&output_image_struct.id, sfimageData, sizeof(uint32_t)).

Your function has a series of code blocks that all follow this same format, and all seem to suffer from the same problems.

General Comments

Your code makes unsafe assumptions about the way that unions are implemented. The only union member that you can legally read from is the last one that you wrote to. Writing to one member and reading from another is undefined behavior and you can't rely on that code to behave a certain way. You're likely doing that to avoid doing shady things with pointer casting like id = *(uint32_t*)(sfimageData), but the behavior of both techniques are equally undefined. If you eliminate the redundant copy operations, this problem should go away as well.

It appears that the fields in the structure are listed in the same order that they appear in the data buffer. Use this to your advantage and simplify the bulk of your function to:

#pragma pack(push,1)  // structure packing syntax may vary
struct image_struct_data
{
    uint32_t id;
    uint32_t timestamp;
    uint16_t nHeight;
    uint16_t nWidth;
};
#pragma pack(pop)
struct image_struct
{
    image_struct_data data;
    // Buffers
    float *depth_map;
    uint16_t *amplitude_map;
    uint16_t getWidth() {return data.nWidth;};
    uint16_t getHeight() {return data.nHeight;};
};
...
image_struct_data output_image_struct;
memcpy(&output_image_struct, sfimageData, sizeof(output_image_struct));
sfimageData += sizeof(output_image_struct);

int depthFrameLength =  output_image_struct.nHeight * output_image_struct.nWidth * sizeof(float);
int amplitudeMapLength = output_image_struct.nHeight * output_image_struct.nWidth * sizeof(uint16_t);
output_image_struct.depth_map = malloc(depthFrameLength);
memcpy(output_image_struct.depth_map, sfimageData, depthFrameLength);
sfimageData += depthFrameLength;
output_image_struct.amplitude_map = malloc(amplitudeMapLength);
memcpy(output_image_struct.amplitude_map, sfimageData, amplitudeMapLength);
sfimageData += amplitudeMapLength;
...

Instead of manipulating fields individually, you're directly copying the first sizeof(struct image_data) bytes from the input buffer into a local variable, which is essentially what your current code does (but in a very indirect way). From here, all you have left to do is allocate the two variable-length buffers.

Your function takes an arbitrary-sized data buffer for input. You've forced the caller to specify the size of the buffer via dataLength, which is excellent. However, your function never so much as looks at this parameter. That makes it very easy for this function to make an invalid memory access and corrupt memory or crash your program. You need to ensure you never attempt to access beyond offset dataLength into the input buffer. How exactly to handle this is up to you. You can error out of the function if dataLength is less than what you expect, you can read up to dataLength bytes and try using default values for any remaining fields, etc etc.

Also, don't forget that malloc can return NULL. Every time you call malloc, you must check the return value before you try to use it.