On Monday, November 25, 2019 at 12:53:10 AM UTC-8, Gert wrote:

> I have a black-box system that ingests digital images, can perform a
> number of transformations on it, and later spits some of them out in
> random order. My goal is to create an algorithm to generate digital
> images I sent into the system so that I can identify them when/if they
> come out, and tell which kind of transformations they have undergone.

There are some watermark systems for digital images, such as JPG,
that depend on some property of the less significant bits of the
image.  Some can survive some transforms, though the usual intent
is to make illegal copying, possibly with transforms, difficult.
(Some even to detect scanning of a printed image.)

It sounds like you are not trying to detect illegal copying,
but only legal transforms.  (That is, no nefarious intent.)

As above, many depend on changing the less significant bits,
and assuming that can survive some transforms.

If there is no nefarious intent, you can ask yourself what effect
each transformation will cause and plan accordingly.

Am 25.11.19 um 09:53 schrieb Gert:
> - Cropping. there is of course only so much cropping you can undergo
>    without losing information.
> 
> - Affine transforms (zooming, rotation). The same goes here: simple
>    affines should be easy to catch, but when scaling one axis to 0%
>    information is always lost.
> 
> - Color space conversion: RGB to greyscale, interleaved to planar,
>    anything is possible here.
> 
> I have a setup that is kind-of-functional based on QR codes with some
> additional colored marks, but I find it lacking in a lot of ways, as it
> is not very robust against some transforms like cropping.

If you can use larger images, I would put more QR codes in the image, 
i.e. create a checkerboard of QR codes.

Since all the trasnforms you describe are linear, you could also put in 
some arbitrary basis functions like polynomials (i.e., plot x^2 y in 2D).

	Christian

Hi DSP people,

I have a black-box system that ingests digital images, can perform a
number of transformations on it, and later spits some of them out in
random order. My goal is to create an algorithm to generate digital
images I sent into the system so that I can identify them when/if they
come out, and tell which kind of transformations they have undergone.

The images I put in have a number of properties:

- Each one has an unique ID. Since there is a limited number of images
  'in flight' at any time, this ID can typically be quite small - no
  more then a few hundred. I need to be able to tell the ID of images
  coming out to match them to the images I put in.

- Images come in all kinds of color formats and spaces from 1bb to
  RGBA32, YUV420, etc.

- Image size is arbritrary, but I expect there is a practical lower
  limit to make this work - 64x64px would be nice, 128x128px would be 
  acceptable.

The system can perform a number of transformations to the images. It
would be nice to survive and/or detect all or most of those up to a
reasonable level.

- Cropping. there is of course only so much cropping you can undergo
  without losing information.

- Affine transforms (zooming, rotation). The same goes here: simple
  affines should be easy to catch, but when scaling one axis to 0%
  information is always lost.

- Color space conversion: RGB to greyscale, interleaved to planar,
  anything is possible here.

I have a setup that is kind-of-functional based on QR codes with some
additional colored marks, but I find it lacking in a lot of ways, as it
is not very robust against some transforms like cropping.

Are there any well-known methods for attacking this problem? I feel that
putting in information in the frequency domain might make things much
more resiliant against most of these transformations, but I am not quite
sure yet where to go with this. Any links to algorithms or papers much
appreciated.

Thanks!

Gert