# Monthly Archives: May 2013

## unwatermarking images

I’ve started a website where I intend to sell thousands of products from a number of distributors through drop-shipping (the products go directly to the customer).

For reasons that I don’t understand, the distributors have watermarked their images, and don’t provide unwatermarked versions unless you’re an already well-established customer of theirs.

For the purpose of this demo, a watermark is a constant-colour “stamp” which is given opacity and pasted into the original image.

As I intend to be a good customer, I figured it would be okay for me to simply “unwatermark” the images.

There are a number of instructions online which show how to /fake/ an unwatermaking – by basically smudging the area where the watermark is.

However, as most watermarking appears to follow a single method, it is actually possible to simply reverse the process and remove the watermark, after a little trial and error.

Let’s consider an example. Here is an image, a stamp, and the merge of the two:

To reverse this, you need to know what algorithm was used to create the watermark, and what the original watermark was.

Most people use a fairly simple method to watermark their images:

The stamp is one single colour, usually gray (#808080 in RGB) which will be visible on images which are both light and dark.

The stamp is then given an opacity (30% in my case above), and pasted directly over the original image.

The formula for any particular colour channel (R, G and B) on any pixel is: C3=(1-p)C1+pC2, where p is opacity (0 to 1), C1 is the colour value for the original image, C2 is the stamp’s colour value, and C3 is the resulting image’s colour value.

To reverse the watermarking, you need to convert the formula to see what it is in respect to C1: C1=(C3-pC2)/(1-p).

As most stamps will be using a middle gray (#808080), you just have to guess at the opacity. .3 is a good start.

For some reason I’m not yet sure of, the code I came up with did unwatermark the image, but too much… the points where the watermark were, ended up being too bright. So I needed to add a darkening aspect, reducing the brightness of the result of the above calculation.

I’m not going to hold your hand if you can’t make this work, but here’s the code I ended up with (assumes the images are exactly 400×400 in size). The original should be ‘original.jpg’, and the stamp should be ‘stamp.png’ (with white where transparent pixels should be).

```\$p=.3; // opacity

\$f1=imagecreatefrompng('stamp.png');
imagepalettetotruecolor(\$f1);
\$f2=imagecreatetruecolor(400, 400);
\$f3=imagecreatefromjpeg('original.jpg');
imagepalettetotruecolor(\$f3);

for (\$x=0;\$x<400; ++\$x) {
for (\$y=0; \$y<400; ++\$y) {
\$rgb1=imagecolorat(\$f1, \$x, \$y);
\$rgb3=imagecolorat(\$f3, \$x, \$y);
\$r3 = (\$rgb3 >> 16) & 0xFF;
\$g3 = (\$rgb3 >> 8) & 0xFF;
\$b3 = \$rgb3 & 0xFF;
if (\$rgb1==16777215) { // white. just copy
\$c=imagecolorallocate(\$f2, \$r3, \$g3, \$b3);
imagesetpixel(\$f2, \$x, \$y, \$c);
continue;
}
\$r1 = (\$rgb1 >> 16) & 0xFF;
\$g1 = (\$rgb1 >> 8) & 0xFF;
\$b1 = \$rgb1 & 0xFF;
\$r2=c(\$r1, \$r3, \$p);
\$g2=c(\$g1, \$g3, \$p);
\$b2=c(\$b1, \$b3, \$p);
\$c=imagecolorallocate(\$f2, \$r2, \$g2, \$b2);
imagesetpixel(\$f2, \$x, \$y, \$c);
}
}
imagejpeg(\$f2, 'unwatermarked.jpg');

function c(\$c1, \$c2, \$p) {
\$c=c1(\$c1, \$c2, \$p);
\$c3=\$c-(255-\$c)*.2;
return \$c3<0?0:(int)\$c3;
}
function c1(\$c2, \$c3, \$p) {
\$c=(\$c3-\$c2*\$p)/(1-\$p);
return \$c>255?255:(int)\$c;
}
```