2 * Image Library -- Duplicates Comparison
4 * (c) 2006 Pavel Charvat <pchar@ucw.cz>
6 * This software may be freely distributed and used according to the terms
7 * of the GNU Lesser General Public License.
13 #include "lib/mempool.h"
14 #include "lib/fastbuf.h"
15 #include "images/images.h"
16 #include "images/duplicates.h"
28 err_sum(byte *pos1, byte *pos2, uns count)
33 uns e = err(*pos1++, *pos2++);
34 e += err(*pos1++, *pos2++);
35 e += err(*pos1++, *pos2++);
42 err_sum_transformed(byte *pos1, byte *pos2, uns cols, uns rows, int row_step_1, int col_step_2, int row_step_2)
44 DBG("err_sum_transformed(pos1=%p pos2=%p cols=%u rows=%u row_step_1=%d col_step_2=%d row_step_2=%d)",
45 pos1, pos2, cols, rows, row_step_1, col_step_2, row_step_2);
47 for (uns j = rows; j--; )
52 for (uns i = cols; i--; )
54 e += err(p1[0], p2[0]);
55 e += err(p1[1], p2[1]);
56 e += err(p1[2], p2[2]);
68 aspect_ratio_test(struct image_dup_context *ctx, uns cols1, uns rows1, uns cols2, uns rows2)
70 DBG("aspect_ratio_test(cols1=%u rows1=%u cols2=%u rows2=%u)", cols1, rows1, cols2, rows2);
71 uns r1 = cols1 * rows2;
72 uns r2 = rows1 * cols2;
74 r1 <= ((r2 * ctx->ratio_threshold) >> 7) &&
75 r2 <= ((r1 * ctx->ratio_threshold) >> 7);
79 average_compare(struct image_dup_context *ctx, struct image_dup *dup1, struct image_dup *dup2)
81 byte *block1 = image_dup_block(dup1, 0, 0);
82 byte *block2 = image_dup_block(dup2, 0, 0);
84 err(block1[0], block2[0]) +
85 err(block1[1], block2[1]) +
86 err(block1[2], block2[2]);
87 return e <= ctx->error_threshold;
91 blocks_compare(struct image_dup_context *ctx, struct image_dup *dup1, struct image_dup *dup2, uns tab_col, uns tab_row, uns trans)
93 DBG("blocks_compare(tab_col=%d tab_row=%d trans=%d)", tab_col, tab_row, trans);
94 ctx->sum_pixels += 1 << (tab_col + tab_row);
95 byte *block1 = image_dup_block(dup1, tab_col, tab_row);
97 int col_step, row_step;
99 block2 = image_dup_block(dup2, tab_col, tab_row);
101 block2 = image_dup_block(dup2, tab_row, tab_col);
105 uns err = (err_sum(block1, block2, 1 << (tab_col + tab_row)) >> (tab_col + tab_row));
106 DBG("average error=%d", err);
107 return err <= ctx->error_threshold;
110 row_step = (3 << tab_col);
111 block2 += row_step - 3;
115 row_step = -(3 << tab_col);
116 block2 += (3 << (tab_col + tab_row)) + row_step;
120 row_step = -(3 << tab_col);
121 block2 += (3 << (tab_col + tab_row)) - 3;
124 col_step = (3 << tab_row);
128 col_step = -(3 << tab_row);
130 block2 += (3 << (tab_col + tab_row)) + col_step;
133 col_step = (3 << tab_row);
135 block2 += col_step - 3;
138 col_step = -(3 << tab_row);
140 block2 += (3 << (tab_col + tab_row)) - 3;
145 uns err = (err_sum_transformed(block1, block2, (1 << tab_col), (1 << tab_row), (3 << tab_col), col_step, row_step) >> (tab_col + tab_row));
146 DBG("average error=%d", err);
147 return err <= ctx->error_threshold;
151 same_size_compare(struct image_dup_context *ctx, struct image_dup *dup1, struct image_dup *dup2, uns trans)
153 struct image *img1 = &dup1->image;
154 struct image *img2 = &dup2->image;
155 if (!img1->pixels || !img2->pixels)
157 ctx->sum_pixels += img1->cols * img1->rows;
158 byte *block1 = img1->pixels;
159 byte *block2 = img2->pixels;
160 int col_step, row_step;
161 DBG("same_size_compare(trans=%d)", trans);
166 row_step = img2->row_size;
170 row_step = img2->row_size;
171 block2 += 3 * (img2->cols - 1);
175 row_step = -img2->row_size;
176 block2 += img2->row_size * (img2->rows - 1);
180 row_step = -img2->row_size;
181 block2 += img2->row_size * (img2->rows - 1) + 3 * (img2->cols - 1);
184 col_step = img2->row_size;
188 col_step = -img2->row_size;
190 block2 += img2->row_size * (img2->rows - 1);
193 col_step = img2->row_size;
195 block2 += 3 * (img2->cols - 1);
198 col_step = -img2->row_size;
200 block2 += img2->row_size * (img2->rows - 1) + 3 * (img2->cols - 1);
205 uns err = (err_sum_transformed(block1, block2, img1->cols, img1->rows, img1->row_size, col_step, row_step) / ((u64)img1->cols * img1->rows));
206 DBG("average error=%d", err);
207 return err <= ctx->error_threshold;
211 image_dup_compare(struct image_dup_context *ctx, struct image_dup *dup1, struct image_dup *dup2)
213 DBG("image_dup_compare()");
214 if (!average_compare(ctx, dup1, dup2))
216 struct image *img1 = &dup1->image;
217 struct image *img2 = &dup2->image;
218 uns flags = ctx->flags;
219 if (flags & IMAGE_DUP_SCALE)
221 DBG("Scale support");
222 if (!aspect_ratio_test(ctx, img1->cols, img1->rows, img2->cols, img2->rows))
224 if (!aspect_ratio_test(ctx, img1->cols, img1->rows, img2->rows, img2->cols))
229 DBG("No scale support");
230 if (!(img1->cols == img2->cols && img1->rows == img2->rows))
232 if (!(img1->cols == img2->rows && img1->rows == img2->cols))
240 uns cols = MIN(dup1->tab_cols, dup2->tab_cols);
241 uns rows = MIN(dup1->tab_rows, dup2->tab_rows);
242 for (uns t = 0; t < 4; t++)
243 if (flags & (1 << t))
245 DBG("Testing trans %d", t);
246 uns i = MAX(cols, rows), depth = 1;
250 uns col = MAX(0, (int)(cols - i));
251 uns row = MAX(0, (int)(rows - i));
252 if (!blocks_compare(ctx, dup1, dup2, col, row, t))
255 (img1->cols != img2->cols || img1->rows != img2->rows ||
256 same_size_compare(ctx, dup1, dup2, t)))
259 if (!(flags & IMAGE_DUP_WANT_ALL))
265 ctx->sum_depth += depth;
270 uns cols = MIN(dup1->tab_cols, dup2->tab_rows);
271 uns rows = MIN(dup1->tab_rows, dup2->tab_cols);
272 for (uns t = 4; t < 8; t++)
273 if (flags & (1 << t))
275 DBG("Testing trans %d", t);
276 uns i = MAX(cols, rows), depth = 1;
280 uns col = MAX(0, (int)(cols - i));
281 uns row = MAX(0, (int)(rows - i));
282 if (!blocks_compare(ctx, dup1, dup2, col, row, t))
285 (img1->cols != img2->rows || img1->rows != img2->cols ||
286 same_size_compare(ctx, dup1, dup2, t)) )
289 if (!(flags & IMAGE_DUP_WANT_ALL))
295 ctx->sum_depth += depth;