MagickCore 6.9.13-46
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
vision.c
1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% %
6% V V IIIII SSSSS IIIII OOO N N %
7% V V I SS I O O NN N %
8% V V I SSS I O O N N N %
9% V V I SS I O O N NN %
10% V IIIII SSSSS IIIII OOO N N %
11% %
12% %
13% MagickCore Computer Vision Methods %
14% %
15% Software Design %
16% Cristy %
17% September 2014 %
18% %
19% %
20% Copyright 1999 ImageMagick Studio LLC, a non-profit organization %
21% dedicated to making software imaging solutions freely available. %
22% %
23% You may not use this file except in compliance with the License. You may %
24% obtain a copy of the License at %
25% %
26% https://imagemagick.org/license/ %
27% %
28% Unless required by applicable law or agreed to in writing, software %
29% distributed under the License is distributed on an "AS IS" BASIS, %
30% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31% See the License for the specific language governing permissions and %
32% limitations under the License. %
33% %
34%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35%
36%
37*/
38␌
39#include "magick/studio.h"
40#include "magick/artifact.h"
41#include "magick/blob.h"
42#include "magick/cache-view.h"
43#include "magick/color.h"
44#include "magick/color-private.h"
45#include "magick/colormap.h"
46#include "magick/colorspace.h"
47#include "magick/constitute.h"
48#include "magick/decorate.h"
49#include "magick/distort.h"
50#include "magick/draw.h"
51#include "magick/enhance.h"
52#include "magick/exception.h"
53#include "magick/exception-private.h"
54#include "magick/effect.h"
55#include "magick/gem.h"
56#include "magick/geometry.h"
57#include "magick/image-private.h"
58#include "magick/list.h"
59#include "magick/log.h"
60#include "magick/matrix.h"
61#include "magick/memory_.h"
62#include "magick/memory-private.h"
63#include "magick/monitor.h"
64#include "magick/monitor-private.h"
65#include "magick/montage.h"
66#include "magick/morphology.h"
67#include "magick/morphology-private.h"
68#include "magick/opencl-private.h"
69#include "magick/paint.h"
70#include "magick/pixel-accessor.h"
71#include "magick/pixel-private.h"
72#include "magick/property.h"
73#include "magick/quantum.h"
74#include "magick/resource_.h"
75#include "magick/signature-private.h"
76#include "magick/string_.h"
77#include "magick/string-private.h"
78#include "magick/thread-private.h"
79#include "magick/token.h"
80#include "magick/vision.h"
81␌
82/*
83%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
84% %
85% %
86% %
87% C o n n e c t e d C o m p o n e n t s I m a g e %
88% %
89% %
90% %
91%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
92%
93% ConnectedComponentsImage() returns the connected-components of the image
94% uniquely labeled. Choose from 4 or 8-way connectivity.
95%
96% The format of the ConnectedComponentsImage method is:
97%
98% Image *ConnectedComponentsImage(const Image *image,
99% const size_t connectivity,ExceptionInfo *exception)
100%
101% A description of each parameter follows:
102%
103% o image: the image.
104%
105% o connectivity: how many neighbors to visit, choose from 4 or 8.
106%
107% o exception: return any errors or warnings in this structure.
108%
109*/
110
111typedef struct _CCObjectInfo
112{
113 ssize_t
114 id;
115
116 RectangleInfo
117 bounding_box;
118
119 MagickPixelPacket
120 color;
121
122 PointInfo
123 centroid;
124
125 double
126 area,
127 census;
128
129 MagickBooleanType
130 merge;
131} CCObjectInfo;
132
133static int CCObjectInfoCompare(const void *x,const void *y)
134{
135 CCObjectInfo
136 *p,
137 *q;
138
139 p=(CCObjectInfo *) x;
140 q=(CCObjectInfo *) y;
141 return((int) (q->area-(ssize_t) p->area));
142}
143
144MagickExport Image *ConnectedComponentsImage(const Image *image,
145 const size_t connectivity,ExceptionInfo *exception)
146{
147#define ConnectedComponentsImageTag "ConnectedComponents/Image"
148
149 CacheView
150 *component_view,
151 *image_view,
152 *object_view;
153
154 CCObjectInfo
155 *object;
156
157 char
158 *c;
159
160 const char
161 *artifact;
162
163 double
164 max_threshold,
165 min_threshold;
166
167 Image
168 *component_image;
169
170 MagickBooleanType
171 status;
172
173 MagickOffsetType
174 progress;
175
176 MatrixInfo
177 *equivalences;
178
179 ssize_t
180 i;
181
182 size_t
183 size;
184
185 ssize_t
186 background_id,
187 connect4[2][2] = { { -1, 0 }, { 0, -1 } },
188 connect8[4][2] = { { -1, -1 }, { -1, 0 }, { -1, 1 }, { 0, -1 } },
189 dx,
190 dy,
191 first,
192 last,
193 n,
194 step,
195 y;
196
197 /*
198 Initialize connected components image attributes.
199 */
200 assert(image != (Image *) NULL);
201 assert(image->signature == MagickCoreSignature);
202 assert(exception != (ExceptionInfo *) NULL);
203 assert(exception->signature == MagickCoreSignature);
204 if (IsEventLogging() != MagickFalse)
205 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
206 component_image=CloneImage(image,0,0,MagickTrue,exception);
207 if (component_image == (Image *) NULL)
208 return((Image *) NULL);
209 component_image->depth=MAGICKCORE_QUANTUM_DEPTH;
210 if (AcquireImageColormap(component_image,MaxColormapSize) == MagickFalse)
211 {
212 component_image=DestroyImage(component_image);
213 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
214 }
215 /*
216 Initialize connected components equivalences.
217 */
218 size=image->columns*image->rows;
219 if (image->columns != (size/image->rows))
220 {
221 component_image=DestroyImage(component_image);
222 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
223 }
224 equivalences=AcquireMatrixInfo(size,1,sizeof(ssize_t),exception);
225 if (equivalences == (MatrixInfo *) NULL)
226 {
227 component_image=DestroyImage(component_image);
228 return((Image *) NULL);
229 }
230 for (n=0; n < (ssize_t) (image->columns*image->rows); n++)
231 (void) SetMatrixElement(equivalences,n,0,&n);
232 object=(CCObjectInfo *) AcquireQuantumMemory(MaxColormapSize,sizeof(*object));
233 if (object == (CCObjectInfo *) NULL)
234 {
235 equivalences=DestroyMatrixInfo(equivalences);
236 component_image=DestroyImage(component_image);
237 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
238 }
239 (void) memset(object,0,MaxColormapSize*sizeof(*object));
240 for (i=0; i < (ssize_t) MaxColormapSize; i++)
241 {
242 object[i].id=i;
243 object[i].bounding_box.x=(ssize_t) image->columns;
244 object[i].bounding_box.y=(ssize_t) image->rows;
245 GetMagickPixelPacket(image,&object[i].color);
246 }
247 /*
248 Find connected components.
249 */
250 status=MagickTrue;
251 progress=0;
252 image_view=AcquireVirtualCacheView(image,exception);
253 for (n=0; n < (ssize_t) (connectivity > 4 ? 4 : 2); n++)
254 {
255 if (status == MagickFalse)
256 continue;
257 dx=connectivity > 4 ? connect8[n][1] : connect4[n][1];
258 dy=connectivity > 4 ? connect8[n][0] : connect4[n][0];
259 for (y=0; y < (ssize_t) image->rows; y++)
260 {
261 const PixelPacket
262 *magick_restrict p;
263
264 ssize_t
265 x;
266
267 if (status == MagickFalse)
268 continue;
269 p=GetCacheViewVirtualPixels(image_view,0,y-1,image->columns,3,exception);
270 if (p == (const PixelPacket *) NULL)
271 {
272 status=MagickFalse;
273 continue;
274 }
275 p+=(ptrdiff_t) image->columns;
276 for (x=0; x < (ssize_t) image->columns; x++)
277 {
278 ssize_t
279 neighbor_offset,
280 obj,
281 offset,
282 ox,
283 oy,
284 root;
285
286 /*
287 Is neighbor an authentic pixel and a different color than the pixel?
288 */
289 if (((x+dx) < 0) || ((x+dx) >= (ssize_t) image->columns) ||
290 ((y+dy) < 0) || ((y+dy) >= (ssize_t) image->rows))
291 {
292 p++;
293 continue;
294 }
295 neighbor_offset=dy*image->columns+dx;
296 if (IsColorSimilar(image,p,p+neighbor_offset) == MagickFalse)
297 {
298 p++;
299 continue;
300 }
301 /*
302 Resolve this equivalence.
303 */
304 offset=y*image->columns+x;
305 ox=offset;
306 status=GetMatrixElement(equivalences,ox,0,&obj);
307 while (obj != ox)
308 {
309 ox=obj;
310 status=GetMatrixElement(equivalences,ox,0,&obj);
311 }
312 oy=offset+neighbor_offset;
313 status=GetMatrixElement(equivalences,oy,0,&obj);
314 while (obj != oy)
315 {
316 oy=obj;
317 status=GetMatrixElement(equivalences,oy,0,&obj);
318 }
319 if (ox < oy)
320 {
321 status=SetMatrixElement(equivalences,oy,0,&ox);
322 root=ox;
323 }
324 else
325 {
326 status=SetMatrixElement(equivalences,ox,0,&oy);
327 root=oy;
328 }
329 ox=offset;
330 status=GetMatrixElement(equivalences,ox,0,&obj);
331 while (obj != root)
332 {
333 status=GetMatrixElement(equivalences,ox,0,&obj);
334 status=SetMatrixElement(equivalences,ox,0,&root);
335 }
336 oy=offset+neighbor_offset;
337 status=GetMatrixElement(equivalences,oy,0,&obj);
338 while (obj != root)
339 {
340 status=GetMatrixElement(equivalences,oy,0,&obj);
341 status=SetMatrixElement(equivalences,oy,0,&root);
342 }
343 status=SetMatrixElement(equivalences,y*image->columns+x,0,&root);
344 p++;
345 }
346 }
347 }
348 /*
349 Label connected components.
350 */
351 n=0;
352 component_view=AcquireAuthenticCacheView(component_image,exception);
353 for (y=0; y < (ssize_t) component_image->rows; y++)
354 {
355 const IndexPacket
356 *magick_restrict indexes;
357
358 const PixelPacket
359 *magick_restrict p;
360
361 IndexPacket
362 *magick_restrict component_indexes;
363
364 PixelPacket
365 *magick_restrict q;
366
367 ssize_t
368 x;
369
370 if (status == MagickFalse)
371 continue;
372 p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
373 q=QueueCacheViewAuthenticPixels(component_view,0,y,component_image->columns,
374 1,exception);
375 if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
376 {
377 status=MagickFalse;
378 continue;
379 }
380 indexes=GetCacheViewVirtualIndexQueue(image_view);
381 component_indexes=GetCacheViewAuthenticIndexQueue(component_view);
382 for (x=0; x < (ssize_t) component_image->columns; x++)
383 {
384 ssize_t
385 id,
386 offset;
387
388 offset=y*image->columns+x;
389 status=GetMatrixElement(equivalences,offset,0,&id);
390 if (id != offset)
391 status=GetMatrixElement(equivalences,id,0,&id);
392 else
393 {
394 id=n++;
395 if (id >= (ssize_t) MaxColormapSize)
396 break;
397 }
398 status=SetMatrixElement(equivalences,offset,0,&id);
399 if (x < object[id].bounding_box.x)
400 object[id].bounding_box.x=x;
401 if (x >= (ssize_t) object[id].bounding_box.width)
402 object[id].bounding_box.width=(size_t) x;
403 if (y < object[id].bounding_box.y)
404 object[id].bounding_box.y=y;
405 if (y >= (ssize_t) object[id].bounding_box.height)
406 object[id].bounding_box.height=(size_t) y;
407 object[id].color.red+=QuantumScale*(MagickRealType) p->red;
408 object[id].color.green+=QuantumScale*(MagickRealType) p->green;
409 object[id].color.blue+=QuantumScale*(MagickRealType) p->blue;
410 if (image->matte != MagickFalse)
411 object[id].color.opacity+=QuantumScale*(MagickRealType) p->opacity;
412 if (image->colorspace == CMYKColorspace)
413 object[id].color.index+=QuantumScale*(MagickRealType) indexes[x];
414 object[id].centroid.x+=x;
415 object[id].centroid.y+=y;
416 object[id].area++;
417 component_indexes[x]=(IndexPacket) id;
418 p++;
419 q++;
420 }
421 if (n > (ssize_t) MaxColormapSize)
422 break;
423 if (SyncCacheViewAuthenticPixels(component_view,exception) == MagickFalse)
424 status=MagickFalse;
425 if (image->progress_monitor != (MagickProgressMonitor) NULL)
426 {
427 MagickBooleanType
428 proceed;
429
430 progress++;
431 proceed=SetImageProgress(image,ConnectedComponentsImageTag,progress,
432 image->rows);
433 if (proceed == MagickFalse)
434 status=MagickFalse;
435 }
436 }
437 component_view=DestroyCacheView(component_view);
438 image_view=DestroyCacheView(image_view);
439 equivalences=DestroyMatrixInfo(equivalences);
440 if (n > (ssize_t) MaxColormapSize)
441 {
442 object=(CCObjectInfo *) RelinquishMagickMemory(object);
443 component_image=DestroyImage(component_image);
444 ThrowImageException(ResourceLimitError,"TooManyObjects");
445 }
446 background_id=0;
447 min_threshold=0.0;
448 max_threshold=0.0;
449 component_image->colors=(size_t) n;
450 for (i=0; i < (ssize_t) component_image->colors; i++)
451 {
452 object[i].bounding_box.width-=(object[i].bounding_box.x-1);
453 object[i].bounding_box.height-=(object[i].bounding_box.y-1);
454 object[i].color.red/=(QuantumScale*object[i].area);
455 object[i].color.green/=(QuantumScale*object[i].area);
456 object[i].color.blue/=(QuantumScale*object[i].area);
457 if (image->matte != MagickFalse)
458 object[i].color.opacity/=(QuantumScale*object[i].area);
459 if (image->colorspace == CMYKColorspace)
460 object[i].color.index/=(QuantumScale*object[i].area);
461 object[i].centroid.x/=object[i].area;
462 object[i].centroid.y/=object[i].area;
463 max_threshold+=object[i].area;
464 if (object[i].area > object[background_id].area)
465 background_id=i;
466 }
467 max_threshold+=MagickEpsilon;
468 artifact=GetImageArtifact(image,"connected-components:background-id");
469 if (artifact != (const char *) NULL)
470 background_id=(ssize_t) StringToLong(artifact);
471 artifact=GetImageArtifact(image,"connected-components:area-threshold");
472 if (artifact != (const char *) NULL)
473 {
474 /*
475 Merge any object not within the min and max area threshold.
476 */
477 (void) sscanf(artifact,"%lf%*[ -]%lf",&min_threshold,&max_threshold);
478 for (i=0; i < (ssize_t) component_image->colors; i++)
479 if (((object[i].area < min_threshold) ||
480 (object[i].area >= max_threshold)) && (i != background_id))
481 object[i].merge=MagickTrue;
482 }
483 artifact=GetImageArtifact(image,"connected-components:keep-colors");
484 if (artifact != (const char *) NULL)
485 {
486 const char
487 *p;
488
489 /*
490 Keep selected objects based on color, merge others.
491 */
492 for (i=0; i < (ssize_t) component_image->colors; i++)
493 object[i].merge=MagickTrue;
494 for (p=artifact; ; )
495 {
496 char
497 color[MagickPathExtent];
498
499 MagickPixelPacket
500 pixel;
501
502 const char
503 *q;
504
505 for (q=p; *q != '\0'; q++)
506 if (*q == ';')
507 break;
508 (void) CopyMagickString(color,p,(size_t) MagickMin(q-p+1,
509 MagickPathExtent));
510 (void) QueryMagickColor(color,&pixel,exception);
511 for (i=0; i < (ssize_t) component_image->colors; i++)
512 if (IsMagickColorSimilar(&object[i].color,&pixel) != MagickFalse)
513 object[i].merge=MagickFalse;
514 if (*q == '\0')
515 break;
516 p=q+1;
517 }
518 }
519 artifact=GetImageArtifact(image,"connected-components:keep-ids");
520 if (artifact == (const char *) NULL)
521 artifact=GetImageArtifact(image,"connected-components:keep");
522 if (artifact != (const char *) NULL)
523 for (c=(char *) artifact; *c != '\0'; )
524 {
525 /*
526 Keep selected objects based on id, merge others.
527 */
528 for (i=0; i < (ssize_t) component_image->colors; i++)
529 object[i].merge=MagickTrue;
530 while ((isspace((int) ((unsigned char) *c)) != 0) || (*c == ','))
531 c++;
532 first=(ssize_t) strtol(c,&c,10);
533 if (first < 0)
534 first+=(ssize_t) component_image->colors;
535 last=first;
536 while (isspace((int) ((unsigned char) *c)) != 0)
537 c++;
538 if (*c == '-')
539 {
540 last=(ssize_t) strtol(c+1,&c,10);
541 if (last < 0)
542 last+=(ssize_t) component_image->colors;
543 }
544 step=(ssize_t) (first > last ? -1 : 1);
545 for ( ; first != (last+step); first+=step)
546 if ((first >= 0) &&
547 (first < (ssize_t) component_image->colors))
548 object[first].merge=MagickFalse;
549 }
550 artifact=GetImageArtifact(image,"connected-components:keep-top");
551 if (artifact != (const char *) NULL)
552 {
553 CCObjectInfo
554 *top_objects;
555
556 ssize_t
557 top_ids;
558
559 /*
560 Keep top objects.
561 */
562 top_ids=(ssize_t) StringToLong(artifact);
563 top_objects=(CCObjectInfo *) AcquireQuantumMemory(component_image->colors,
564 sizeof(*top_objects));
565 if (top_objects == (CCObjectInfo *) NULL)
566 {
567 object=(CCObjectInfo *) RelinquishMagickMemory(object);
568 component_image=DestroyImage(component_image);
569 ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
570 }
571 (void) memcpy(top_objects,object,component_image->colors*sizeof(*object));
572 qsort((void *) top_objects,component_image->colors,sizeof(*top_objects),
573 CCObjectInfoCompare);
574 for (i=top_ids+1; i < (ssize_t) component_image->colors; i++)
575 {
576 ssize_t id = (ssize_t) top_objects[i].id;
577 if ((id >= 0) && (id < (ssize_t) component_image->colors))
578 object[id].merge=MagickTrue;
579 }
580 top_objects=(CCObjectInfo *) RelinquishMagickMemory(top_objects);
581 }
582 artifact=GetImageArtifact(image,"connected-components:remove-colors");
583 if (artifact != (const char *) NULL)
584 {
585 const char
586 *p;
587
588 /*
589 Remove selected objects based on color, keep others.
590 */
591 for (p=artifact; ; )
592 {
593 char
594 color[MagickPathExtent];
595
596 MagickPixelPacket
597 pixel;
598
599 const char
600 *q;
601
602 for (q=p; *q != '\0'; q++)
603 if (*q == ';')
604 break;
605 (void) CopyMagickString(color,p,(size_t) MagickMin(q-p+1,
606 MagickPathExtent));
607 (void) QueryMagickColor(color,&pixel,exception);
608 for (i=0; i < (ssize_t) component_image->colors; i++)
609 if (IsMagickColorSimilar(&object[i].color,&pixel) != MagickFalse)
610 object[i].merge=MagickTrue;
611 if (*q == '\0')
612 break;
613 p=q+1;
614 }
615 }
616 artifact=GetImageArtifact(image,"connected-components:remove-ids");
617 if (artifact == (const char *) NULL)
618 artifact=GetImageArtifact(image,"connected-components:remove");
619 if (artifact != (const char *) NULL)
620 for (c=(char *) artifact; *c != '\0'; )
621 {
622 /*
623 Remove selected objects based on color, keep others.
624 */
625 while ((isspace((int) ((unsigned char) *c)) != 0) || (*c == ','))
626 c++;
627 first=(ssize_t) strtol(c,&c,10);
628 if (first < 0)
629 first+=(ssize_t) component_image->colors;
630 last=first;
631 while (isspace((int) ((unsigned char) *c)) != 0)
632 c++;
633 if (*c == '-')
634 {
635 last=(ssize_t) strtol(c+1,&c,10);
636 if (last < 0)
637 last+=(ssize_t) component_image->colors;
638 }
639 step=(ssize_t) (first > last ? -1 : 1);
640 for ( ; first != (last+step); first+=step)
641 if ((first >= 0) &&
642 (first < (ssize_t) component_image->colors))
643 object[first].merge=MagickTrue;
644 }
645 /*
646 Merge any object not within the min and max area threshold.
647 */
648 component_view=AcquireAuthenticCacheView(component_image,exception);
649 object_view=AcquireVirtualCacheView(component_image,exception);
650 for (i=0; i < (ssize_t) component_image->colors; i++)
651 {
652 RectangleInfo
653 bounding_box;
654
655 ssize_t
656 j;
657
658 size_t
659 id;
660
661 if (status == MagickFalse)
662 continue;
663 if ((object[i].merge == MagickFalse) || (i == background_id))
664 continue; /* keep object */
665 /*
666 Merge this object.
667 */
668 for (j=0; j < (ssize_t) component_image->colors; j++)
669 object[j].census=0;
670 bounding_box=object[i].bounding_box;
671 for (y=0; y < (ssize_t) bounding_box.height; y++)
672 {
673 const IndexPacket
674 *magick_restrict indexes;
675
676 const PixelPacket
677 *magick_restrict p;
678
679 ssize_t
680 x;
681
682 if (status == MagickFalse)
683 continue;
684 p=GetCacheViewVirtualPixels(component_view,bounding_box.x,
685 bounding_box.y+y,bounding_box.width,1,exception);
686 if (p == (const PixelPacket *) NULL)
687 {
688 status=MagickFalse;
689 continue;
690 }
691 indexes=GetCacheViewVirtualIndexQueue(component_view);
692 for (x=0; x < (ssize_t) bounding_box.width; x++)
693 {
694 size_t
695 k;
696
697 if (status == MagickFalse)
698 continue;
699 j=(ssize_t) indexes[x];
700 if (j == i)
701 for (k=0; k < (ssize_t) (connectivity > 4 ? 4 : 2); k++)
702 {
703 const IndexPacket
704 *magick_restrict indexes;
705
706 const PixelPacket
707 *p;
708
709 /*
710 Compute area of adjacent objects.
711 */
712 if (status == MagickFalse)
713 continue;
714 dx=connectivity > 4 ? connect8[k][1] : connect4[k][1];
715 dy=connectivity > 4 ? connect8[k][0] : connect4[k][0];
716 p=GetCacheViewVirtualPixels(object_view,bounding_box.x+x+dx,
717 bounding_box.y+y+dy,1,1,exception);
718 if (p == (const PixelPacket *) NULL)
719 {
720 status=MagickFalse;
721 break;
722 }
723 indexes=GetCacheViewVirtualIndexQueue(object_view);
724 j=(ssize_t) *indexes;
725 if (j != i)
726 object[j].census++;
727 }
728 }
729 }
730 /*
731 Merge with object of greatest adjacent area.
732 */
733 id=0;
734 for (j=1; j < (ssize_t) component_image->colors; j++)
735 if (object[j].census > object[id].census)
736 id=(size_t) j;
737 object[i].area=0.0;
738 for (y=0; y < (ssize_t) bounding_box.height; y++)
739 {
740 IndexPacket
741 *magick_restrict component_indexes;
742
743 PixelPacket
744 *magick_restrict q;
745
746 ssize_t
747 x;
748
749 if (status == MagickFalse)
750 continue;
751 q=GetCacheViewAuthenticPixels(component_view,bounding_box.x,
752 bounding_box.y+y,bounding_box.width,1,exception);
753 if (q == (PixelPacket *) NULL)
754 {
755 status=MagickFalse;
756 continue;
757 }
758 component_indexes=GetCacheViewAuthenticIndexQueue(component_view);
759 for (x=0; x < (ssize_t) bounding_box.width; x++)
760 {
761 if ((ssize_t) component_indexes[x] == i)
762 component_indexes[x]=(IndexPacket) id;
763 }
764 if (SyncCacheViewAuthenticPixels(component_view,exception) == MagickFalse)
765 status=MagickFalse;
766 }
767 }
768 object_view=DestroyCacheView(object_view);
769 component_view=DestroyCacheView(component_view);
770 artifact=GetImageArtifact(image,"connected-components:mean-color");
771 if (IsMagickTrue(artifact) != MagickFalse)
772 {
773 /*
774 Replace object with mean color.
775 */
776 for (i=0; i < (ssize_t) component_image->colors; i++)
777 {
778 component_image->colormap[i].red=ClampToQuantum(object[i].color.red);
779 component_image->colormap[i].green=ClampToQuantum(
780 object[i].color.green);
781 component_image->colormap[i].blue=ClampToQuantum(object[i].color.blue);
782 component_image->colormap[i].opacity=ClampToQuantum(
783 object[i].color.opacity);
784 }
785 }
786 (void) SyncImage(component_image);
787 artifact=GetImageArtifact(image,"connected-components:verbose");
788 if (IsMagickTrue(artifact) != MagickFalse)
789 {
790 /*
791 Report statistics on each unique objects.
792 */
793 for (i=0; i < (ssize_t) component_image->colors; i++)
794 {
795 object[i].bounding_box.width=0;
796 object[i].bounding_box.height=0;
797 object[i].bounding_box.x=(ssize_t) component_image->columns;
798 object[i].bounding_box.y=(ssize_t) component_image->rows;
799 object[i].centroid.x=0;
800 object[i].centroid.y=0;
801 object[i].census=object[i].area == 0.0 ? 0.0 : 1.0;
802 object[i].area=0;
803 }
804 component_view=AcquireVirtualCacheView(component_image,exception);
805 for (y=0; y < (ssize_t) component_image->rows; y++)
806 {
807 const IndexPacket
808 *indexes;
809
810 const PixelPacket
811 *magick_restrict p;
812
813 ssize_t
814 x;
815
816 if (status == MagickFalse)
817 continue;
818 p=GetCacheViewVirtualPixels(component_view,0,y,
819 component_image->columns,1,exception);
820 if (p == (const PixelPacket *) NULL)
821 {
822 status=MagickFalse;
823 continue;
824 }
825 indexes=GetCacheViewVirtualIndexQueue(component_view);
826 for (x=0; x < (ssize_t) component_image->columns; x++)
827 {
828 size_t
829 id;
830
831 id=(size_t) indexes[x];
832 if (x < object[id].bounding_box.x)
833 object[id].bounding_box.x=x;
834 if (x > (ssize_t) object[id].bounding_box.width)
835 object[id].bounding_box.width=(size_t) x;
836 if (y < object[id].bounding_box.y)
837 object[id].bounding_box.y=y;
838 if (y > (ssize_t) object[id].bounding_box.height)
839 object[id].bounding_box.height=(size_t) y;
840 object[id].centroid.x+=x;
841 object[id].centroid.y+=y;
842 object[id].area++;
843 }
844 }
845 for (i=0; i < (ssize_t) component_image->colors; i++)
846 {
847 object[i].bounding_box.width-=(object[i].bounding_box.x-1);
848 object[i].bounding_box.height-=(object[i].bounding_box.y-1);
849 object[i].centroid.x=object[i].centroid.x/object[i].area;
850 object[i].centroid.y=object[i].centroid.y/object[i].area;
851 }
852 component_view=DestroyCacheView(component_view);
853 qsort((void *) object,component_image->colors,sizeof(*object),
854 CCObjectInfoCompare);
855 artifact=GetImageArtifact(image,"connected-components:exclude-header");
856 if (IsStringTrue(artifact) == MagickFalse)
857 (void) fprintf(stdout,
858 "Objects (id: bounding-box centroid area mean-color):\n");
859 for (i=0; i < (ssize_t) component_image->colors; i++)
860 if (object[i].census > 0.0)
861 {
862 char
863 mean_color[MaxTextExtent];
864
865 GetColorTuple(&object[i].color,MagickFalse,mean_color);
866 (void) fprintf(stdout,
867 " %.20g: %.20gx%.20g%+.20g%+.20g %.1f,%.1f %.20g %s\n",(double)
868 object[i].id,(double) object[i].bounding_box.width,(double)
869 object[i].bounding_box.height,(double) object[i].bounding_box.x,
870 (double) object[i].bounding_box.y,object[i].centroid.x,
871 object[i].centroid.y,(double) object[i].area,mean_color);
872 }
873 }
874 object=(CCObjectInfo *) RelinquishMagickMemory(object);
875 return(component_image);
876}
_CCObjectInfo
Definition vision.c:112