← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/imagemagick/oneiric-updates

« back to all changes in this revision

Viewing changes to magick/paint.c

  • Committer: Bazaar Package Importer
  • Author(s): Nelson A. de Oliveira
  • Date: 2010-06-20 19:59:55 UTC
  • mfrom: (6.2.8 sid)
  • Revision ID: james.westby@ubuntu.com-20100620195955-n3eq0yenhycw888i
Tags: 7:6.6.2.6-1
http://bugs.debian.org/579775
http://bugs.debian.org/582073
http://bugs.debian.org/583024
* New upstream release;
* Change Recommends on ufraw to ufraw-batch (Closes: #579775);
* Fix FTBFS when using dash to run the configure script, by setting
  CONFIG_SHELL=/bin/bash (Closes: #582073, #583024). Thank you, Niko Tyni!

Show diffs side-by-side

added added

removed removed

Lines of Context:
magick/paint.c
17
17
%                                 July 1998                                   %
18
18
%                                                                             %
19
19
%                                                                             %
20
 
%  Copyright 1999-2009 ImageMagick Studio LLC, a non-profit organization      %
 
20
%  Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization      %
21
21
%  dedicated to making software imaging solutions freely available.           %
22
22
%                                                                             %
23
23
%  You may not use this file except in compliance with the License.  You may  %
88
88
%
89
89
%      MagickBooleanType FloodfillPaintImage(Image *image,
90
90
%        const ChannelType channel,const DrawInfo *draw_info,
91
 
%        const MagickPixelPacket target,const long x_offset,const long y_offset,
 
91
%        const MagickPixelPacket target,const ssize_t x_offset,const ssize_t y_offset,
92
92
%        const MagickBooleanType invert)
93
93
%
94
94
%  A description of each parameter follows:
108
108
*/
109
109
MagickExport MagickBooleanType FloodfillPaintImage(Image *image,
110
110
  const ChannelType channel,const DrawInfo *draw_info,
111
 
  const MagickPixelPacket *target,const long x_offset,const long y_offset,
 
111
  const MagickPixelPacket *target,const ssize_t x_offset,const ssize_t y_offset,
112
112
  const MagickBooleanType invert)
113
113
{
114
114
#define MaxStacksize  (1UL << 15)
118
118
    ThrowBinaryException(DrawError,"SegmentStackOverflow",image->filename) \
119
119
  else \
120
120
    { \
121
 
      if ((((up)+(delta)) >= 0) && (((up)+(delta)) < (long) image->rows)) \
 
121
      if ((((up)+(delta)) >= 0) && (((up)+(delta)) < (ssize_t) image->rows)) \
122
122
        { \
123
123
          s->x1=(double) (left); \
124
124
          s->y1=(double) (up); \
135
135
  Image
136
136
    *floodplane_image;
137
137
 
138
 
  long
 
138
  ssize_t
139
139
    offset,
140
140
    start,
141
141
    x,
168
168
    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
169
169
  assert(draw_info != (DrawInfo *) NULL);
170
170
  assert(draw_info->signature == MagickSignature);
171
 
  if ((x_offset < 0) || (x_offset >= (long) image->columns))
 
171
  if ((x_offset < 0) || (x_offset >= (ssize_t) image->columns))
172
172
    return(MagickFalse);
173
 
  if ((y_offset < 0) || (y_offset >= (long) image->rows))
 
173
  if ((y_offset < 0) || (y_offset >= (ssize_t) image->rows))
174
174
    return(MagickFalse);
175
175
  if (SetImageStorageClass(image,DirectClass) == MagickFalse)
176
176
    return(MagickFalse);
206
206
  while (s > segment_stack)
207
207
  {
208
208
    register const IndexPacket
209
 
      *__restrict indexes;
 
209
      *restrict indexes;
210
210
 
211
211
    register const PixelPacket
212
 
      *__restrict p;
 
212
      *restrict p;
213
213
 
214
 
    register long
 
214
    register ssize_t
215
215
      x;
216
216
 
217
217
    register PixelPacket
218
 
      *__restrict q;
 
218
      *restrict q;
219
219
 
220
220
    /*
221
221
      Pop segment off stack.
222
222
    */
223
223
    s--;
224
 
    x1=(long) s->x1;
225
 
    x2=(long) s->x2;
226
 
    offset=(long) s->y2;
227
 
    y=(long) s->y1+offset;
 
224
    x1=(ssize_t) s->x1;
 
225
    x2=(ssize_t) s->x2;
 
226
    offset=(ssize_t) s->y2;
 
227
    y=(ssize_t) s->y1+offset;
228
228
    /*
229
229
      Recolor neighboring pixels.
230
230
    */
231
 
    p=GetVirtualPixels(image,0,y,(unsigned long) (x1+1),1,exception);
232
 
    q=GetAuthenticPixels(floodplane_image,0,y,(unsigned long) (x1+1),1,
 
231
    p=GetVirtualPixels(image,0,y,(size_t) (x1+1),1,exception);
 
232
    q=GetAuthenticPixels(floodplane_image,0,y,(size_t) (x1+1),1,
233
233
      exception);
234
234
    if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
235
235
      break;
261
261
    {
262
262
      if (skip == MagickFalse)
263
263
        {
264
 
          if (x < (long) image->columns)
 
264
          if (x < (ssize_t) image->columns)
265
265
            {
266
266
              p=GetVirtualPixels(image,x,y,image->columns-x,1,exception);
267
267
              q=GetAuthenticPixels(floodplane_image,x,y,image->columns-x,1,
270
270
                  (q == (PixelPacket *) NULL))
271
271
                break;
272
272
              indexes=GetVirtualIndexQueue(image);
273
 
              for ( ; x < (long) image->columns; x++)
 
273
              for ( ; x < (ssize_t) image->columns; x++)
274
274
              {
275
275
                if (q->opacity == (Quantum) TransparentOpacity)
276
276
                  break;
292
292
      x++;
293
293
      if (x <= x2)
294
294
        {
295
 
          p=GetVirtualPixels(image,x,y,(unsigned long) (x2-x+1),1,exception);
296
 
          q=GetAuthenticPixels(floodplane_image,x,y,(unsigned long) (x2-x+1),1,
 
295
          p=GetVirtualPixels(image,x,y,(size_t) (x2-x+1),1,exception);
 
296
          q=GetAuthenticPixels(floodplane_image,x,y,(size_t) (x2-x+1),1,
297
297
            exception);
298
298
          if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
299
299
            break;
312
312
      start=x;
313
313
    } while (x <= x2);
314
314
  }
315
 
  for (y=0; y < (long) image->rows; y++)
 
315
  for (y=0; y < (ssize_t) image->rows; y++)
316
316
  {
317
317
    register const PixelPacket
318
 
      *__restrict p;
 
318
      *restrict p;
319
319
 
320
320
    register IndexPacket
321
 
      *__restrict indexes;
 
321
      *restrict indexes;
322
322
 
323
 
    register long
 
323
    register ssize_t
324
324
      x;
325
325
 
326
326
    register PixelPacket
327
 
      *__restrict q;
 
327
      *restrict q;
328
328
 
329
329
    /*
330
330
      Tile fill color onto floodplane.
334
334
    if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
335
335
      break;
336
336
    indexes=GetAuthenticIndexQueue(image);
337
 
    for (x=0; x < (long) image->columns; x++)
 
337
    for (x=0; x < (ssize_t) image->columns; x++)
338
338
    {
339
339
      if (p->opacity != OpaqueOpacity)
340
340
        {
343
343
          if (image->colorspace == CMYKColorspace)
344
344
            ConvertRGBToCMYK(&fill);
345
345
          if ((channel & RedChannel) != 0)
346
 
            q->red=RoundToQuantum(fill.red);
 
346
            q->red=ClampToQuantum(fill.red);
347
347
          if ((channel & GreenChannel) != 0)
348
 
            q->green=RoundToQuantum(fill.green);
 
348
            q->green=ClampToQuantum(fill.green);
349
349
          if ((channel & BlueChannel) != 0)
350
 
            q->blue=RoundToQuantum(fill.blue);
 
350
            q->blue=ClampToQuantum(fill.blue);
351
351
          if ((channel & OpacityChannel) != 0)
352
 
            q->opacity=RoundToQuantum(fill.opacity);
 
352
            q->opacity=ClampToQuantum(fill.opacity);
353
353
          if (((channel & IndexChannel) != 0) &&
354
354
              (image->colorspace == CMYKColorspace))
355
 
            indexes[x]=RoundToQuantum(fill.index);
 
355
            indexes[x]=ClampToQuantum(fill.index);
356
356
        }
357
357
      p++;
358
358
      q++;
362
362
  }
363
363
  segment_stack=(SegmentInfo *) RelinquishMagickMemory(segment_stack);
364
364
  floodplane_image=DestroyImage(floodplane_image);
365
 
  return(y == (long) image->rows ? MagickTrue : MagickFalse);
 
365
  return(y == (ssize_t) image->rows ? MagickTrue : MagickFalse);
366
366
}
367
367
 
368
368
/*
416
416
  MagickBooleanType
417
417
    status;
418
418
 
419
 
  register long
 
419
  register ssize_t
420
420
    i;
421
421
 
422
422
  /*
452
452
      image->filename);
453
453
  (void) ResetMagickMemory(gradient->stops,0,gradient->number_stops*
454
454
    sizeof(*gradient->stops));
455
 
  for (i=0; i < (long) gradient->number_stops; i++)
 
455
  for (i=0; i < (ssize_t) gradient->number_stops; i++)
456
456
    GetMagickPixelPacket(image,&gradient->stops[i].color);
457
457
  SetMagickPixelPacket(image,start_color,(IndexPacket *) NULL,
458
458
    &gradient->stops[0].color);
504
504
%
505
505
*/
506
506
 
507
 
static unsigned long **DestroyHistogramThreadSet(unsigned long **histogram)
 
507
static size_t **DestroyHistogramThreadSet(size_t **histogram)
508
508
{
509
 
  register long
 
509
  register ssize_t
510
510
    i;
511
511
 
512
 
  assert(histogram != (unsigned long **) NULL);
513
 
  for (i=0; i < (long) GetOpenMPMaximumThreads(); i++)
514
 
    if (histogram[i] != (unsigned long *) NULL)
515
 
      histogram[i]=(unsigned long *) RelinquishMagickMemory(histogram[i]);
516
 
  histogram=(unsigned long **) RelinquishAlignedMemory(histogram);
 
512
  assert(histogram != (size_t **) NULL);
 
513
  for (i=0; i < (ssize_t) GetOpenMPMaximumThreads(); i++)
 
514
    if (histogram[i] != (size_t *) NULL)
 
515
      histogram[i]=(size_t *) RelinquishMagickMemory(histogram[i]);
 
516
  histogram=(size_t **) RelinquishAlignedMemory(histogram);
517
517
  return(histogram);
518
518
}
519
519
 
520
 
static unsigned long **AcquireHistogramThreadSet(const size_t count)
 
520
static size_t **AcquireHistogramThreadSet(const size_t count)
521
521
{
522
 
  register long
 
522
  register ssize_t
523
523
    i;
524
524
 
525
 
  unsigned long
 
525
  size_t
526
526
    **histogram,
527
527
    number_threads;
528
528
 
529
529
  number_threads=GetOpenMPMaximumThreads();
530
 
  histogram=(unsigned long **) AcquireAlignedMemory(number_threads,
 
530
  histogram=(size_t **) AcquireAlignedMemory(number_threads,
531
531
    sizeof(*histogram));
532
 
  if (histogram == (unsigned long **) NULL)
533
 
    return((unsigned long **) NULL);
 
532
  if (histogram == (size_t **) NULL)
 
533
    return((size_t **) NULL);
534
534
  (void) ResetMagickMemory(histogram,0,number_threads*sizeof(*histogram));
535
 
  for (i=0; i < (long) number_threads; i++)
 
535
  for (i=0; i < (ssize_t) number_threads; i++)
536
536
  {
537
 
    histogram[i]=(unsigned long *) AcquireQuantumMemory(count,
 
537
    histogram[i]=(size_t *) AcquireQuantumMemory(count,
538
538
      sizeof(**histogram));
539
 
    if (histogram[i] == (unsigned long *) NULL)
 
539
    if (histogram[i] == (size_t *) NULL)
540
540
      return(DestroyHistogramThreadSet(histogram));
541
541
  }
542
542
  return(histogram);
548
548
#define NumberPaintBins  256
549
549
#define OilPaintImageTag  "OilPaint/Image"
550
550
 
 
551
  CacheView
 
552
    *image_view,
 
553
    *paint_view;
 
554
 
551
555
  Image
552
556
    *paint_image;
553
557
 
554
 
  long
555
 
    progress,
556
 
    y;
557
 
 
558
558
  MagickBooleanType
559
559
    status;
560
560
 
561
 
  unsigned long
562
 
    **histograms,
 
561
  MagickOffsetType
 
562
    progress;
 
563
 
 
564
  size_t
 
565
    **restrict histograms,
563
566
    width;
564
567
 
565
 
  CacheView
566
 
    *image_view,
567
 
    *paint_view;
 
568
  ssize_t
 
569
    y;
568
570
 
569
571
  /*
570
572
    Initialize painted image attributes.
588
590
      return((Image *) NULL);
589
591
    }
590
592
  histograms=AcquireHistogramThreadSet(NumberPaintBins);
591
 
  if (histograms == (unsigned long **) NULL)
 
593
  if (histograms == (size_t **) NULL)
592
594
    {
593
595
      paint_image=DestroyImage(paint_image);
594
596
      ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
603
605
#if defined(MAGICKCORE_OPENMP_SUPPORT)
604
606
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
605
607
#endif
606
 
  for (y=0; y < (long) image->rows; y++)
 
608
  for (y=0; y < (ssize_t) image->rows; y++)
607
609
  {
608
610
    register const IndexPacket
609
 
      *__restrict indexes;
 
611
      *restrict indexes;
610
612
 
611
613
    register const PixelPacket
612
 
      *__restrict p;
 
614
      *restrict p;
613
615
 
614
616
    register IndexPacket
615
 
      *__restrict paint_indexes;
 
617
      *restrict paint_indexes;
616
618
 
617
 
    register long
 
619
    register ssize_t
618
620
      x;
619
621
 
620
622
    register PixelPacket
621
 
      *__restrict q;
 
623
      *restrict q;
622
624
 
623
 
    register unsigned long
 
625
    register size_t
624
626
      *histogram;
625
627
 
626
628
    if (status == MagickFalse)
627
629
      continue;
628
 
    p=GetCacheViewVirtualPixels(image_view,-((long) width/2L),y-(long) (width/
 
630
    p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y-(ssize_t) (width/
629
631
      2L),image->columns+width,width,exception);
630
632
    q=QueueCacheViewAuthenticPixels(paint_view,0,y,paint_image->columns,1,
631
633
      exception);
637
639
    indexes=GetCacheViewVirtualIndexQueue(image_view);
638
640
    paint_indexes=GetCacheViewAuthenticIndexQueue(paint_view);
639
641
    histogram=histograms[GetOpenMPThreadId()];
640
 
    for (x=0; x < (long) image->columns; x++)
 
642
    for (x=0; x < (ssize_t) image->columns; x++)
641
643
    {
642
 
      long
 
644
      ssize_t
643
645
        j,
644
646
        k,
645
647
        v;
646
648
 
647
 
      register long
 
649
      register ssize_t
648
650
        i,
649
651
        u;
650
652
 
651
 
      unsigned long
 
653
      size_t
652
654
        count;
653
655
 
654
656
      /*
658
660
      j=0;
659
661
      count=0;
660
662
      (void) ResetMagickMemory(histogram,0,NumberPaintBins*sizeof(*histogram));
661
 
      for (v=0; v < (long) width; v++)
 
663
      for (v=0; v < (ssize_t) width; v++)
662
664
      {
663
 
        for (u=0; u < (long) width; u++)
 
665
        for (u=0; u < (ssize_t) width; u++)
664
666
        {
665
 
          k=(long) ScaleQuantumToChar(PixelIntensityToQuantum(p+u+i));
 
667
          k=(ssize_t) ScaleQuantumToChar(PixelIntensityToQuantum(p+u+i));
666
668
          histogram[k]++;
667
669
          if (histogram[k] > count)
668
670
            {
670
672
              count=histogram[k];
671
673
            }
672
674
        }
673
 
        i+=image->columns+width;
 
675
        i+=(ssize_t) (image->columns+width);
674
676
      }
675
677
      *q=(*(p+j));
676
678
      if (image->colorspace == CMYKColorspace)
757
759
{
758
760
#define OpaquePaintImageTag  "Opaque/Image"
759
761
 
 
762
  CacheView
 
763
    *image_view;
 
764
 
760
765
  ExceptionInfo
761
766
    *exception;
762
767
 
763
 
  long
764
 
    progress,
765
 
    y;
766
 
 
767
768
  MagickBooleanType
768
769
    status;
769
770
 
 
771
  MagickOffsetType
 
772
    progress;
 
773
 
770
774
  MagickPixelPacket
771
775
    zero;
772
776
 
773
 
  CacheView
774
 
    *image_view;
 
777
  ssize_t
 
778
    y;
775
779
 
776
780
  assert(image != (Image *) NULL);
777
781
  assert(image->signature == MagickSignature);
792
796
#if defined(MAGICKCORE_OPENMP_SUPPORT)
793
797
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
794
798
#endif
795
 
  for (y=0; y < (long) image->rows; y++)
 
799
  for (y=0; y < (ssize_t) image->rows; y++)
796
800
  {
797
801
    MagickPixelPacket
798
802
      pixel;
799
803
 
800
804
    register IndexPacket
801
 
      *__restrict indexes;
 
805
      *restrict indexes;
802
806
 
803
 
    register long
 
807
    register ssize_t
804
808
      x;
805
809
 
806
810
    register PixelPacket
807
 
      *__restrict q;
 
811
      *restrict q;
808
812
 
809
813
    if (status == MagickFalse)
810
814
      continue;
816
820
      }
817
821
    indexes=GetCacheViewAuthenticIndexQueue(image_view);
818
822
    pixel=zero;
819
 
    for (x=0; x < (long) image->columns; x++)
 
823
    for (x=0; x < (ssize_t) image->columns; x++)
820
824
    {
821
825
      SetMagickPixelPacket(image,q,indexes+x,&pixel);
822
826
      if (IsMagickColorSimilar(&pixel,target) != invert)
823
827
        {
824
828
          if ((channel & RedChannel) != 0)
825
 
            q->red=RoundToQuantum(fill->red);
 
829
            q->red=ClampToQuantum(fill->red);
826
830
          if ((channel & GreenChannel) != 0)
827
 
            q->green=RoundToQuantum(fill->green);
 
831
            q->green=ClampToQuantum(fill->green);
828
832
          if ((channel & BlueChannel) != 0)
829
 
            q->blue=RoundToQuantum(fill->blue);
 
833
            q->blue=ClampToQuantum(fill->blue);
830
834
          if ((channel & OpacityChannel) != 0)
831
 
            q->opacity=RoundToQuantum(fill->opacity);
 
835
            q->opacity=ClampToQuantum(fill->opacity);
832
836
          if (((channel & IndexChannel) != 0) &&
833
837
              (image->colorspace == CMYKColorspace))
834
 
            indexes[x]=RoundToQuantum(fill->index);
 
838
            indexes[x]=ClampToQuantum(fill->index);
835
839
        }
836
840
      q++;
837
841
    }
898
902
{
899
903
#define TransparentPaintImageTag  "Transparent/Image"
900
904
 
 
905
  CacheView
 
906
    *image_view;
 
907
 
901
908
  ExceptionInfo
902
909
    *exception;
903
910
 
904
 
  long
905
 
    progress,
906
 
    y;
907
 
 
908
911
  MagickBooleanType
909
912
    status;
910
913
 
 
914
  MagickOffsetType
 
915
    progress;
 
916
 
911
917
  MagickPixelPacket
912
918
    zero;
913
919
 
914
 
  CacheView
915
 
    *image_view;
 
920
  ssize_t
 
921
    y;
916
922
 
917
923
  assert(image != (Image *) NULL);
918
924
  assert(image->signature == MagickSignature);
934
940
#if defined(MAGICKCORE_OPENMP_SUPPORT)
935
941
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
936
942
#endif
937
 
  for (y=0; y < (long) image->rows; y++)
 
943
  for (y=0; y < (ssize_t) image->rows; y++)
938
944
  {
939
945
    MagickPixelPacket
940
946
      pixel;
941
947
 
942
948
    register IndexPacket
943
 
      *__restrict indexes;
 
949
      *restrict indexes;
944
950
 
945
 
    register long
 
951
    register ssize_t
946
952
      x;
947
953
 
948
954
    register PixelPacket
949
 
      *__restrict q;
 
955
      *restrict q;
950
956
 
951
957
    if (status == MagickFalse)
952
958
      continue;
958
964
      }
959
965
    indexes=GetCacheViewAuthenticIndexQueue(image_view);
960
966
    pixel=zero;
961
 
    for (x=0; x < (long) image->columns; x++)
 
967
    for (x=0; x < (ssize_t) image->columns; x++)
962
968
    {
963
969
      SetMagickPixelPacket(image,q,indexes+x,&pixel);
964
970
      if (IsMagickColorSimilar(&pixel,target) != invert)
1031
1037
{
1032
1038
#define TransparentPaintImageTag  "Transparent/Image"
1033
1039
 
 
1040
  CacheView
 
1041
    *image_view;
 
1042
 
1034
1043
  ExceptionInfo
1035
1044
    *exception;
1036
1045
 
1037
 
  long
1038
 
    progress,
1039
 
    y;
1040
 
 
1041
1046
  MagickBooleanType
1042
1047
    status;
1043
1048
 
1044
 
  CacheView
1045
 
    *image_view;
 
1049
  MagickOffsetType
 
1050
    progress;
 
1051
 
 
1052
  ssize_t
 
1053
    y;
1046
1054
 
1047
1055
  assert(image != (Image *) NULL);
1048
1056
  assert(image->signature == MagickSignature);
1064
1072
#if defined(MAGICKCORE_OPENMP_SUPPORT)
1065
1073
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
1066
1074
#endif
1067
 
  for (y=0; y < (long) image->rows; y++)
 
1075
  for (y=0; y < (ssize_t) image->rows; y++)
1068
1076
  {
1069
1077
    MagickBooleanType
1070
1078
      match;
1073
1081
      pixel;
1074
1082
 
1075
1083
    register IndexPacket
1076
 
      *__restrict indexes;
 
1084
      *restrict indexes;
1077
1085
 
1078
 
    register long
 
1086
    register ssize_t
1079
1087
      x;
1080
1088
 
1081
1089
    register PixelPacket
1082
 
      *__restrict q;
 
1090
      *restrict q;
1083
1091
 
1084
1092
    if (status == MagickFalse)
1085
1093
      continue;
1091
1099
      }
1092
1100
    indexes=GetCacheViewAuthenticIndexQueue(image_view);
1093
1101
    GetMagickPixelPacket(image,&pixel);
1094
 
    for (x=0; x < (long) image->columns; x++)
 
1102
    for (x=0; x < (ssize_t) image->columns; x++)
1095
1103
    {
1096
1104
      SetMagickPixelPacket(image,q,indexes+x,&pixel);
1097
1105
      match=((pixel.red >= low->red) && (pixel.red <= high->red) &&