tl;dr- You're proposing a key-stretching algorithm that turns 128 bits of input into a much larger key. This isn't as good as simply using a much larger key of the same size, though it's not necessarily as weak as the 128 bits of input. That said, your bitmap looks very ordered, which strongly suggests that it's far weaker than a randomly generated bitmap.
According to @Blender's answer, you're just using 128 bits to generate the picture. I'm guessing that you want the picture itself to count as a key larger than the 128 bits that you put into the algorithm that generated it. And it might.
Specifically, what you're trying to do is create a key-stretching algorithm that attempts to stretch 128 bits of input into a much larger key. This isn't necessarily fruitless, but there're things to be aware of:
A key-stretching algorithm can be vulnerable to brute-force of the input. For example, even if someone couldn't reverse-engineer the picture-generation algorithm, they could try all $2^{128}$ possible inputs to generate all possible $2^{128}$ possible pictures, then try each. To guard against this, you'd need to ensure that the picture-generation algorithm is too expensive for such an attack to be feasible.
Your picture looks far from random at local scales. This is, anyone looking at a few pixels of it can probably guess the neighboring pixels with better-than-random odds of success. This means that the algorithm isn't pseudo-random, even against an attacker who can't reverse-engineer the picture-generation algorithm.
Your picture looks far from random at the global scale. This is, the displayed shapes have global geometry, plus the images waste pixels on a well-behaved background. This significantly weakens the pseudo-randomness again, potentially suggesting that it might be easy to fully break.
There's no real advantage in a key-stretching algorithm producing a picture as opposed to any other representation of the same data. Granted, the stretched key does look pretty as a picture, but that prettiness merely reflects its weakness vs. a randomly generated bitmap.
This website seems to generate random black-and-white bitmaps with specified dimensions. For example, here's a $250 \times 250$-pixel bitmap:
.
This bitmap is (supposed to be) random in that an attacker looking at any combination of its pixels shouldn't have better-than-even odds of guessing what another pixel might be.
How much entropy?
Unfortunately this site doesn't have MathJax enabled, so it's hard to answer your question directly without it looking weird. Here I'll write a response as-though MathJax were available.
The set of randomly generated RGB images of a given length-and-width contains$${\left(n_\text{Red} \, n_\text{Green} \, n_\text{Blue}\right)}^{n_\text{width} \, n_\text{height}} \, \text{members}
\,,$$where:
$n_\text{Red}$ is the number of possible values for a pixel's "red" dimension;
$n_\text{Green}$ is the number of possible values for a pixel's "green" dimension;
$n_\text{Blue}$ is the number of possible values for a pixel's "blue" dimension;
$n_\text{width}$ is the number of pixels in the width; and
$n_\text{length}$ is the number of pixels in the length.
Then since entropy is the $\log_2{\left(n_\text{members}\right)} ,$ this'd be$$
\begin{align}
\left[ \text{entropy} \right]
& ~=~ \log_2{\left(
{\left( n_\text{Red} \, n_\text{Green} \, n_\text{Blue} \right)}
^{n_\text{width} \, n_\text{height}}
\right)} \[5px]
& ~=~ {n_\text{width} \, n_\text{height}} \, \log_2{\left(n_\text{Red} \, n_\text{Green} \, n_\text{Blue}\right)}
\,.\end{align}
$$
In the case of a black-and-white image:
$n_\text{Red}=2 ,$ since there're two possible values for the red channel;
$n_\text{Green}=n_\text{Blue}=1 ,$ since the values of the green and blue channels is defined to equal the red channel (such that all pixels are either black or white;
so the entropy'd be$$
\left[ \text{entropy} \right]
~=~ {n_\text{width} \, n_\text{height}} \, \log_2{\left(2 \times 1 \times 1\right)}
~=~ {n_\text{width} \, n_\text{height}}
\,.
$$
