I have some suggestions.
Binary -> Bitmap positioning methods
What about trying to make the data transform algorithm more complex, to make the images more visually appealing/interesting, or even better: give the user an option to select the transform method.
You could play with various forms of binary -> bitmap transformation. For example provide several ways the data are placed as pixels. How does it work now? Is it simply filling it row after row? What about going in a "square" spiral, starting at the center? What about going zig-zag? Or diagonal?
Or make it pseudo-random - make a function that will randomly generate a pixel position in a way, that it will never use the same pixel more than once so if you have 1Mpx and you'll generate a series of 1 million positions, every one will be unique to cover the whole bitmap, that way the bytes will be seemingly randomly scattered around the picture, but if you use the same seed for randomization for decoding, you can get the same series of positions as well.
Binary -> Bitmap data pixel storage method
Right now, you're simply transforming three bytes of input data to a single RGB888 pixel (in case of RGB24) right? What about complicating the storage itself a bit?
For example, first store one third of the data in red channel, then green, then blue. Or take 8 pixels (8*3 = 24 bytes) and 24 bytes of input data and then take one bit from the first byte of the input data and store the bit in the first pixel. Then take second bit from the first byte of input data and store it in the second pixel and so on. Simply, don't put the whole input byte into a whole byte of one channel, but scatter the bits of the input byte among multiple pixels.
Binary -> Bitmap data encoding
What about not storing the bytes as they are, but for each pixel only storing a difference from the previous pixel? To show an example with a few numbers, imagine you have sequence:
45, 50, 20, 20, 20, 30, 40, 50
And you store the differences (the initial value can be zero for example, so the first number is difference from zero):
45, 5, -30, 0, 0, 10, 10, 10
Try more variants and more complicated encodings than just differences, of course it must be possible to calculate back the original data, the encoding must be reversible method.
You can try first calculating average value of all the data and then store difference from that and try to prevent sharp differences.
Binary -> Bitmap image key encrypting
An idea for actual encrypting - use some original arbitrary picture as a key - only store difference (for example, or XOR) from this picture, so it will be required for decoding as well. The picture will basically become a "password".
Using GIF
Instead of one large picture, generate a series of 8-bit bitmaps and then save them as an animated GIF. Since GIF already uses some compression, it might help to further compress the data. You can use it in combination with the above. You can generate a palette to make the images visually interesting or give user ability to generate a palette, for example using some color gradient.
Binary -> Bitmap pattern organizing
Try to arrange pixels into patterns, for example encode a chunk of data into a triangle using only red channel and overlay it with another pattern that uses green channel and the triangle pattern is shifted and so on. Maybe don't even bother about space that much and simply generate a block that will use only red channel, then another block that will use green, then another that will use green and red (maybe store the same value in both, making it yellow), to make a colorful pattern, rather than random "noise". It will waste some pixel data, but perhaps you could try lossless image compression handle that.
Binary -> Bitmap even more wasting
What about not using just a single pixel to encode a chunk of data, but using a larger chunk and visually stylizing it somehow, for example by making a smooth gradients to neighbouring colors. You can try storing some data only in lower bits of these gradient-transition pixels, for example in the lower two bits, to don't distort the color too much, but get some extra space, while making it look funky.
Compression - using lossless image compression for arbitrary data
Try compressing the resulting images with various lossless algorithms (such as PNG), using various transformation methods I mentioned and seeing the results, how effective it is for various types of data. Make some nice statistics and data from this.
Try using lossy (JPG for example) compression algorithm to compress the image, then calculate difference from the original and compress the difference using lossless algorithm, so you can use the two to reconstruct original data. Will their size combined be smaller than using just a lossless compression?
Library
Wrap it into a nice library that other can use in their software for various purposes. Such design allows you yourself to develop the algorithms independently and just develop a GUI on top of such library. It will allow to automate various tests I mentioned above.
I think that's enough for now, I think if you do all this, you could actually write a paper about it

In fact, it's something I planned to do before, but put away, because I got other projects.