Dear Vitaliy,

I have opened a new discussion on the complexity measure based on compression rates: Sweeping parameter spaces using "gzip-Entropy". I hope that the post illustrates the main idea. I have also added a section on Mathematica's Compress function. It is interesting that we get similar results, because it is usually claimed that one has to use gzip (not even bzip2). I did not have time/space to explore the use of our computer cluster to sweep parameter spaces, but that is obviously very straight forward with Mathematica's HPC capabilities. I have not yet access to GPUs, but I suppose that one could use that effectively for these brute force studies.

I am quite aware of the Wolfram Science Summer School, which has generated quite some interest of students here. We will certainly look into it. It sounds very exciting. Shame that there is none of the in Europe/the UK.

Of course, I read your article on Visibility Graphs. Very intersting. I have applied it to some systems we have interest in. I have also been working a wee bit with a somewhat similar method. If I have time, I'll post something soon. 

Dear Sam,

yes, that can happen. The method I was adapting is called "Error Level Analysis" (ELA). I only used a very naive implementation. 

Please have a look at this website:
http://fotoforensics.com/tutorial-ela.php
I can also provide references to publications if anyone is interested.

In the tutorial it says:This might explain your observation; in fact, your image provides a beautiful illustration of that effect.

There are many obvious improvements, which are very easy to implement in Mathematica.

PS: There is, by the way, a very similar and simple trick, which one can use to estimate the complexity of time series based on compression rates. Using an algorithm such as gzip one can very crudely estimate the so called algorithmic complexity. It is very easy and fast to study the parameter space of a dynamical system and look e.g. for chaotic regions.

Dear all,

the following two-liner is based on the fact that the different parts of a fake image might have different compression rates in certain image formats, such as jpg etc. Loss-less formats do not work for this. 

We start with a fake jpg-image downloaded from the internet:



First I import the image from the desktop:


Then I export it with a low compression rate:

I then import the new image

and then substract the images and adjust the colour range.

In the resulting image the forged parts are supposed to light up. Here only slightly; it will work better once the compression rate is adapted.



This illustrates just the general idea. There is an "aura" of brighter pixels around the object that is copied in.
Everything can be joined up into a (kind of) one-liner. I then wrap a little manipulate command around it, to vary the compression rate. In order to make this work one needs to play a bit with the compression rates, i.e. move the slider.

Summary: (i) this is only a very crude algorithm, but it works in some cases, (ii) Mathematica certainly has all the algorithms to detect forgery in images, (iii) the shark in the image appears to be copied in :-)

A nice game is to write a little web-crawler to download images from common social network sites and analyse how many of them are fake. Note, that this particular algorithm is not particularly useful to detect forgeries of photos on facebook or dating websites, because they are often not "copy-and-paste", but rather "increase or decrease" the size of certain parts of an image. 

Here is another example:



The output of the program is:


It is important to note that this method is not at all fool-proof; often there are false positives. 

It might be worth mentioning that ImageKeypoints provided by Mathematica uses a SURF ( http://en.wikipedia.org/wiki/SURF ) detector to find keypoints. SURF is development partially based on SIFT, which authors of the referred paper have obviously used. ImageCorrespondingPoints and ImageFeatureTrack use SURF data from ImageKeypoints to do their job.