← Back to branch summary

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

« back to all changes in this revision

Viewing changes to magick/effect.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson
  • Date: 2011-06-15 11:05:28 UTC
  • mfrom: (6.2.11 sid)
  • Revision ID: james.westby@ubuntu.com-20110615110528-08jgo07a4846xh8d
Tags: 8:6.6.0.4-3ubuntu1
https://launchpad.net/bugs/797595
* Resynchronise with Debian (LP: #797595).  Remaining changes:
  - Make ufraw-batch (universe) a suggestion instead of a recommendation.
  - Make debian/rules install target depend on check; they cannot reliably
    be run in parallel.
  - Don't set MAKEFLAGS in debian/rules; just pass it to the build.

Show diffs side-by-side

added added

removed removed

Lines of Context:
magick/effect.c
156
156
    *edge_image,
157
157
    *gaussian_image;
158
158
 
 
159
  long
 
160
    j,
 
161
    k,
 
162
    progress,
 
163
    u,
 
164
    v,
 
165
    y;
 
166
 
159
167
  MagickBooleanType
160
168
    status;
161
169
 
162
 
  MagickOffsetType
163
 
    progress;
164
 
 
165
170
  MagickPixelPacket
166
171
    bias;
167
172
 
168
 
  register ssize_t
 
173
  register long
169
174
    i;
170
175
 
171
 
  size_t
 
176
  unsigned long
172
177
    width;
173
178
 
174
 
  ssize_t
175
 
    j,
176
 
    k,
177
 
    u,
178
 
    v,
179
 
    y;
180
 
 
181
179
  assert(image != (const Image *) NULL);
182
180
  assert(image->signature == MagickSignature);
183
181
  if (image->debug != MagickFalse)
224
222
      ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
225
223
    }
226
224
  (void) ResetMagickMemory(kernel,0,(size_t) width*sizeof(*kernel));
227
 
  for (i=0; i < (ssize_t) width; i+=2)
 
225
  for (i=0; i < (long) width; i+=2)
228
226
  {
229
227
    kernel[i]=(double *) AcquireQuantumMemory((size_t) (width-i),(width-i)*
230
228
      sizeof(**kernel));
231
229
    if (kernel[i] == (double *) NULL)
232
230
      break;
233
231
    normalize=0.0;
234
 
    j=(ssize_t) (width-i)/2;
 
232
    j=(long) (width-i)/2;
235
233
    k=0;
236
234
    for (v=(-j); v <= j; v++)
237
235
    {
249
247
    for (k=0; k < (j*j); k++)
250
248
      kernel[i][k]=normalize*kernel[i][k];
251
249
  }
252
 
  if (i < (ssize_t) width)
 
250
  if (i < (long) width)
253
251
    {
254
252
      for (i-=2; i >= 0; i-=2)
255
253
        kernel[i]=(double *) RelinquishMagickMemory(kernel[i]);
271
269
#if defined(MAGICKCORE_OPENMP_SUPPORT)
272
270
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
273
271
#endif
274
 
  for (y=0; y < (ssize_t) blur_image->rows; y++)
 
272
  for (y=0; y < (long) blur_image->rows; y++)
275
273
  {
276
274
    register const IndexPacket
277
275
      *restrict indexes;
283
281
    register IndexPacket
284
282
      *restrict blur_indexes;
285
283
 
286
 
    register ssize_t
 
284
    register long
287
285
      x;
288
286
 
289
287
    register PixelPacket
300
298
        continue;
301
299
      }
302
300
    blur_indexes=GetCacheViewAuthenticIndexQueue(blur_view);
303
 
    for (x=0; x < (ssize_t) blur_image->columns; x++)
 
301
    for (x=0; x < (long) blur_image->columns; x++)
304
302
    {
305
303
      MagickPixelPacket
306
304
        pixel;
312
310
      register const double
313
311
        *restrict k;
314
312
 
315
 
      register ssize_t
 
313
      register long
316
314
        i,
317
315
        u,
318
316
        v;
319
317
 
320
318
      gamma=0.0;
321
 
      i=(ssize_t) ceil((double) width*QuantumScale*PixelIntensity(r)-0.5);
 
319
      i=(long) (width*QuantumScale*PixelIntensity(r)+0.5);
322
320
      if (i < 0)
323
321
        i=0;
324
322
      else
325
 
        if (i > (ssize_t) width)
326
 
          i=(ssize_t) width;
 
323
        if (i > (long) width)
 
324
          i=(long) width;
327
325
      if ((i & 0x01) != 0)
328
326
        i--;
329
 
      p=GetCacheViewVirtualPixels(image_view,x-((ssize_t) (width-i)/2L),y-(ssize_t)
 
327
      p=GetCacheViewVirtualPixels(image_view,x-((long) (width-i)/2L),y-(long)
330
328
        ((width-i)/2L),width-i,width-i,exception);
331
329
      if (p == (const PixelPacket *) NULL)
332
330
        break;
333
331
      indexes=GetCacheViewVirtualIndexQueue(image_view);
334
332
      pixel=bias;
335
333
      k=kernel[i];
336
 
      for (v=0; v < (ssize_t) (width-i); v++)
 
334
      for (v=0; v < (long) (width-i); v++)
337
335
      {
338
 
        for (u=0; u < (ssize_t) (width-i); u++)
 
336
        for (u=0; u < (long) (width-i); u++)
339
337
        {
340
338
          alpha=1.0;
341
339
          if (((channel & OpacityChannel) != 0) &&
393
391
  edge_view=DestroyCacheView(edge_view);
394
392
  image_view=DestroyCacheView(image_view);
395
393
  edge_image=DestroyImage(edge_image);
396
 
  for (i=0; i < (ssize_t) width;  i+=2)
 
394
  for (i=0; i < (long) width;  i+=2)
397
395
    kernel[i]=(double *) RelinquishMagickMemory(kernel[i]);
398
396
  kernel=(double **) RelinquishMagickMemory(kernel);
399
397
  if (status == MagickFalse)
473
471
    *edge_image,
474
472
    *gaussian_image;
475
473
 
 
474
  long
 
475
    j,
 
476
    k,
 
477
    progress,
 
478
    u,
 
479
    v,
 
480
    y;
 
481
 
476
482
  MagickBooleanType
477
483
    status;
478
484
 
479
 
  MagickOffsetType
480
 
    progress;
481
 
 
482
485
  MagickPixelPacket
483
486
    bias;
484
487
 
485
 
  register ssize_t
 
488
  register long
486
489
    i;
487
490
 
488
 
  size_t
 
491
  unsigned long
489
492
    width;
490
493
 
491
 
  ssize_t
492
 
    j,
493
 
    k,
494
 
    u,
495
 
    v,
496
 
    y;
497
 
 
498
494
  assert(image != (const Image *) NULL);
499
495
  assert(image->signature == MagickSignature);
500
496
  if (image->debug != MagickFalse)
541
537
      ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
542
538
    }
543
539
  (void) ResetMagickMemory(kernel,0,(size_t) width*sizeof(*kernel));
544
 
  for (i=0; i < (ssize_t) width; i+=2)
 
540
  for (i=0; i < (long) width; i+=2)
545
541
  {
546
542
    kernel[i]=(double *) AcquireQuantumMemory((size_t) (width-i),(width-i)*
547
543
      sizeof(**kernel));
548
544
    if (kernel[i] == (double *) NULL)
549
545
      break;
550
546
    normalize=0.0;
551
 
    j=(ssize_t) (width-i)/2;
 
547
    j=(long) (width-i)/2;
552
548
    k=0;
553
549
    for (v=(-j); v <= j; v++)
554
550
    {
566
562
    for (k=0; k < (j*j); k++)
567
563
      kernel[i][k]=normalize*kernel[i][k];
568
564
  }
569
 
  if (i < (ssize_t) width)
 
565
  if (i < (long) width)
570
566
    {
571
567
      for (i-=2; i >= 0; i-=2)
572
568
        kernel[i]=(double *) RelinquishMagickMemory(kernel[i]);
588
584
#if defined(MAGICKCORE_OPENMP_SUPPORT)
589
585
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
590
586
#endif
591
 
  for (y=0; y < (ssize_t) sharp_image->rows; y++)
 
587
  for (y=0; y < (long) sharp_image->rows; y++)
592
588
  {
593
589
    register const IndexPacket
594
590
      *restrict indexes;
600
596
    register IndexPacket
601
597
      *restrict sharp_indexes;
602
598
 
603
 
    register ssize_t
 
599
    register long
604
600
      x;
605
601
 
606
602
    register PixelPacket
617
613
        continue;
618
614
      }
619
615
    sharp_indexes=GetCacheViewAuthenticIndexQueue(sharp_view);
620
 
    for (x=0; x < (ssize_t) sharp_image->columns; x++)
 
616
    for (x=0; x < (long) sharp_image->columns; x++)
621
617
    {
622
618
      MagickPixelPacket
623
619
        pixel;
629
625
      register const double
630
626
        *restrict k;
631
627
 
632
 
      register ssize_t
 
628
      register long
633
629
        i,
634
630
        u,
635
631
        v;
636
632
 
637
633
      gamma=0.0;
638
 
      i=(ssize_t) ceil((double) width*(QuantumRange-QuantumScale*
639
 
        PixelIntensity(r))-0.5);
 
634
      i=(long) (width*(QuantumRange-QuantumScale*PixelIntensity(r))+0.5);
640
635
      if (i < 0)
641
636
        i=0;
642
637
      else
643
 
        if (i > (ssize_t) width)
644
 
          i=(ssize_t) width;
 
638
        if (i > (long) width)
 
639
          i=(long) width;
645
640
      if ((i & 0x01) != 0)
646
641
        i--;
647
 
      p=GetCacheViewVirtualPixels(image_view,x-((ssize_t) (width-i)/2L),y-(ssize_t)
 
642
      p=GetCacheViewVirtualPixels(image_view,x-((long) (width-i)/2L),y-(long)
648
643
        ((width-i)/2L),width-i,width-i,exception);
649
644
      if (p == (const PixelPacket *) NULL)
650
645
        break;
651
646
      indexes=GetCacheViewVirtualIndexQueue(image_view);
652
647
      k=kernel[i];
653
648
      pixel=bias;
654
 
      for (v=0; v < (ssize_t) (width-i); v++)
 
649
      for (v=0; v < (long) (width-i); v++)
655
650
      {
656
 
        for (u=0; u < (ssize_t) (width-i); u++)
 
651
        for (u=0; u < (long) (width-i); u++)
657
652
        {
658
653
          alpha=1.0;
659
654
          if (((channel & OpacityChannel) != 0) &&
711
706
  edge_view=DestroyCacheView(edge_view);
712
707
  image_view=DestroyCacheView(image_view);
713
708
  edge_image=DestroyImage(edge_image);
714
 
  for (i=0; i < (ssize_t) width;  i+=2)
 
709
  for (i=0; i < (long) width;  i+=2)
715
710
    kernel[i]=(double *) RelinquishMagickMemory(kernel[i]);
716
711
  kernel=(double **) RelinquishMagickMemory(kernel);
717
712
  if (status == MagickFalse)
771
766
  return(blur_image);
772
767
}
773
768
 
774
 
static double *GetBlurKernel(const size_t width,const double sigma)
 
769
static double *GetBlurKernel(const unsigned long width,const double sigma)
775
770
{
776
771
  double
777
772
    *kernel,
778
773
    normalize;
779
774
 
780
 
  ssize_t
 
775
  long
781
776
    j,
782
777
    k;
783
778
 
784
 
  register ssize_t
 
779
  register long
785
780
    i;
786
781
 
787
782
  /*
792
787
  if (kernel == (double *) NULL)
793
788
    return(0);
794
789
  normalize=0.0;
795
 
  j=(ssize_t) width/2;
 
790
  j=(long) width/2;
796
791
  i=0;
797
792
  for (k=(-j); k <= j; k++)
798
793
  {
801
796
    normalize+=kernel[i];
802
797
    i++;
803
798
  }
804
 
  for (i=0; i < (ssize_t) width; i++)
 
799
  for (i=0; i < (long) width; i++)
805
800
    kernel[i]/=normalize;
806
801
  return(kernel);
807
802
}
822
817
  Image
823
818
    *blur_image;
824
819
 
825
 
  MagickBooleanType
826
 
    status;
827
 
 
828
 
  MagickOffsetType
829
 
    progress;
830
 
 
831
 
  MagickPixelPacket
832
 
    bias;
833
 
 
834
 
  register ssize_t
835
 
    i;
836
 
 
837
 
  size_t
838
 
    width;
839
 
 
840
 
  ssize_t
 
820
  long
 
821
    progress,
841
822
    x,
842
823
    y;
843
824
 
 
825
  MagickBooleanType
 
826
    status;
 
827
 
 
828
  MagickPixelPacket
 
829
    bias;
 
830
 
 
831
  register long
 
832
    i;
 
833
 
 
834
  unsigned long
 
835
    width;
 
836
 
844
837
  /*
845
838
    Initialize blur image attributes.
846
839
  */
878
871
        *k;
879
872
 
880
873
      (void) LogMagickEvent(TransformEvent,GetMagickModule(),
881
 
        "  BlurImage with %.20g kernel:",(double) width);
 
874
        "  BlurImage with %ld kernel:",width);
882
875
      message=AcquireString("");
883
876
      k=kernel;
884
 
      for (i=0; i < (ssize_t) width; i++)
 
877
      for (i=0; i < (long) width; i++)
885
878
      {
886
879
        *message='\0';
887
 
        (void) FormatMagickString(format,MaxTextExtent,"%.20g: ",(double) i);
 
880
        (void) FormatMagickString(format,MaxTextExtent,"%ld: ",i);
888
881
        (void) ConcatenateString(&message,format);
889
882
        (void) FormatMagickString(format,MaxTextExtent,"%g ",*k++);
890
883
        (void) ConcatenateString(&message,format);
904
897
#if defined(MAGICKCORE_OPENMP_SUPPORT)
905
898
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
906
899
#endif
907
 
  for (y=0; y < (ssize_t) blur_image->rows; y++)
 
900
  for (y=0; y < (long) blur_image->rows; y++)
908
901
  {
909
902
    register const IndexPacket
910
903
      *restrict indexes;
915
908
    register IndexPacket
916
909
      *restrict blur_indexes;
917
910
 
918
 
    register ssize_t
 
911
    register long
919
912
      x;
920
913
 
921
914
    register PixelPacket
923
916
 
924
917
    if (status == MagickFalse)
925
918
      continue;
926
 
    p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y,image->columns+
 
919
    p=GetCacheViewVirtualPixels(image_view,-((long) width/2L),y,image->columns+
927
920
      width,1,exception);
928
921
    q=GetCacheViewAuthenticPixels(blur_view,0,y,blur_image->columns,1,
929
922
      exception);
934
927
      }
935
928
    indexes=GetCacheViewVirtualIndexQueue(image_view);
936
929
    blur_indexes=GetCacheViewAuthenticIndexQueue(blur_view);
937
 
    for (x=0; x < (ssize_t) blur_image->columns; x++)
 
930
    for (x=0; x < (long) blur_image->columns; x++)
938
931
    {
939
932
      MagickPixelPacket
940
933
        pixel;
945
938
      register const PixelPacket
946
939
        *restrict kernel_pixels;
947
940
 
948
 
      register ssize_t
 
941
      register long
949
942
        i;
950
943
 
951
944
      pixel=bias;
953
946
      kernel_pixels=p;
954
947
      if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
955
948
        {
956
 
          for (i=0; i < (ssize_t) width; i++)
 
949
          for (i=0; i < (long) width; i++)
957
950
          {
958
951
            pixel.red+=(*k)*kernel_pixels->red;
959
952
            pixel.green+=(*k)*kernel_pixels->green;
971
964
            {
972
965
              k=kernel;
973
966
              kernel_pixels=p;
974
 
              for (i=0; i < (ssize_t) width; i++)
 
967
              for (i=0; i < (long) width; i++)
975
968
              {
976
969
                pixel.opacity+=(*k)*kernel_pixels->opacity;
977
970
                k++;
987
980
 
988
981
              k=kernel;
989
982
              kernel_indexes=indexes;
990
 
              for (i=0; i < (ssize_t) width; i++)
 
983
              for (i=0; i < (long) width; i++)
991
984
              {
992
985
                pixel.index+=(*k)*(*kernel_indexes);
993
986
                k++;
1003
996
            gamma;
1004
997
 
1005
998
          gamma=0.0;
1006
 
          for (i=0; i < (ssize_t) width; i++)
 
999
          for (i=0; i < (long) width; i++)
1007
1000
          {
1008
1001
            alpha=(MagickRealType) (QuantumScale*
1009
1002
              GetAlphaPixelComponent(kernel_pixels));
1025
1018
            {
1026
1019
              k=kernel;
1027
1020
              kernel_pixels=p;
1028
 
              for (i=0; i < (ssize_t) width; i++)
 
1021
              for (i=0; i < (long) width; i++)
1029
1022
              {
1030
1023
                pixel.opacity+=(*k)*kernel_pixels->opacity;
1031
1024
                k++;
1042
1035
              k=kernel;
1043
1036
              kernel_pixels=p;
1044
1037
              kernel_indexes=indexes;
1045
 
              for (i=0; i < (ssize_t) width; i++)
 
1038
              for (i=0; i < (long) width; i++)
1046
1039
              {
1047
1040
                alpha=(MagickRealType) (QuantumScale*
1048
1041
                  GetAlphaPixelComponent(kernel_pixels));
1084
1077
#if defined(MAGICKCORE_OPENMP_SUPPORT)
1085
1078
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
1086
1079
#endif
1087
 
  for (x=0; x < (ssize_t) blur_image->columns; x++)
 
1080
  for (x=0; x < (long) blur_image->columns; x++)
1088
1081
  {
1089
1082
    register const IndexPacket
1090
1083
      *restrict indexes;
1095
1088
    register IndexPacket
1096
1089
      *restrict blur_indexes;
1097
1090
 
1098
 
    register ssize_t
 
1091
    register long
1099
1092
      y;
1100
1093
 
1101
1094
    register PixelPacket
1103
1096
 
1104
1097
    if (status == MagickFalse)
1105
1098
      continue;
1106
 
    p=GetCacheViewVirtualPixels(image_view,x,-((ssize_t) width/2L),1,image->rows+
 
1099
    p=GetCacheViewVirtualPixels(image_view,x,-((long) width/2L),1,image->rows+
1107
1100
      width,exception);
1108
1101
    q=GetCacheViewAuthenticPixels(blur_view,x,0,1,blur_image->rows,exception);
1109
1102
    if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
1113
1106
      }
1114
1107
    indexes=GetCacheViewVirtualIndexQueue(image_view);
1115
1108
    blur_indexes=GetCacheViewAuthenticIndexQueue(blur_view);
1116
 
    for (y=0; y < (ssize_t) blur_image->rows; y++)
 
1109
    for (y=0; y < (long) blur_image->rows; y++)
1117
1110
    {
1118
1111
      MagickPixelPacket
1119
1112
        pixel;
1124
1117
      register const PixelPacket
1125
1118
        *restrict kernel_pixels;
1126
1119
 
1127
 
      register ssize_t
 
1120
      register long
1128
1121
        i;
1129
1122
 
1130
1123
      pixel=bias;
1132
1125
      kernel_pixels=p;
1133
1126
      if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
1134
1127
        {
1135
 
          for (i=0; i < (ssize_t) width; i++)
 
1128
          for (i=0; i < (long) width; i++)
1136
1129
          {
1137
1130
            pixel.red+=(*k)*kernel_pixels->red;
1138
1131
            pixel.green+=(*k)*kernel_pixels->green;
1150
1143
            {
1151
1144
              k=kernel;
1152
1145
              kernel_pixels=p;
1153
 
              for (i=0; i < (ssize_t) width; i++)
 
1146
              for (i=0; i < (long) width; i++)
1154
1147
              {
1155
1148
                pixel.opacity+=(*k)*kernel_pixels->opacity;
1156
1149
                k++;
1166
1159
 
1167
1160
              k=kernel;
1168
1161
              kernel_indexes=indexes;
1169
 
              for (i=0; i < (ssize_t) width; i++)
 
1162
              for (i=0; i < (long) width; i++)
1170
1163
              {
1171
1164
                pixel.index+=(*k)*(*kernel_indexes);
1172
1165
                k++;
1182
1175
            gamma;
1183
1176
 
1184
1177
          gamma=0.0;
1185
 
          for (i=0; i < (ssize_t) width; i++)
 
1178
          for (i=0; i < (long) width; i++)
1186
1179
          {
1187
1180
            alpha=(MagickRealType) (QuantumScale*
1188
1181
              GetAlphaPixelComponent(kernel_pixels));
1204
1197
            {
1205
1198
              k=kernel;
1206
1199
              kernel_pixels=p;
1207
 
              for (i=0; i < (ssize_t) width; i++)
 
1200
              for (i=0; i < (long) width; i++)
1208
1201
              {
1209
1202
                pixel.opacity+=(*k)*kernel_pixels->opacity;
1210
1203
                k++;
1221
1214
              k=kernel;
1222
1215
              kernel_pixels=p;
1223
1216
              kernel_indexes=indexes;
1224
 
              for (i=0; i < (ssize_t) width; i++)
 
1217
              for (i=0; i < (long) width; i++)
1225
1218
              {
1226
1219
                alpha=(MagickRealType) (QuantumScale*
1227
1220
                  GetAlphaPixelComponent(kernel_pixels));
1277
1270
%
1278
1271
%  The format of the ConvolveImage method is:
1279
1272
%
1280
 
%      Image *ConvolveImage(const Image *image,const size_t order,
 
1273
%      Image *ConvolveImage(const Image *image,const unsigned long order,
1281
1274
%        const double *kernel,ExceptionInfo *exception)
1282
1275
%      Image *ConvolveImageChannel(const Image *image,const ChannelType channel,
1283
 
%        const size_t order,const double *kernel,
 
1276
%        const unsigned long order,const double *kernel,
1284
1277
%        ExceptionInfo *exception)
1285
1278
%
1286
1279
%  A description of each parameter follows:
1297
1290
%
1298
1291
*/
1299
1292
 
1300
 
MagickExport Image *ConvolveImage(const Image *image,const size_t order,
 
1293
MagickExport Image *ConvolveImage(const Image *image,const unsigned long order,
1301
1294
  const double *kernel,ExceptionInfo *exception)
1302
1295
{
1303
1296
  Image
1309
1302
}
1310
1303
 
1311
1304
MagickExport Image *ConvolveImageChannel(const Image *image,
1312
 
  const ChannelType channel,const size_t order,const double *kernel,
 
1305
  const ChannelType channel,const unsigned long order,const double *kernel,
1313
1306
  ExceptionInfo *exception)
1314
1307
{
1315
1308
#define ConvolveImageTag  "Convolve/Image"
1324
1317
  Image
1325
1318
    *convolve_image;
1326
1319
 
 
1320
  long
 
1321
    progress,
 
1322
    y;
 
1323
 
1327
1324
  MagickBooleanType
1328
1325
    status;
1329
1326
 
1330
 
  MagickOffsetType
1331
 
    progress;
1332
 
 
1333
1327
  MagickPixelPacket
1334
1328
    bias;
1335
1329
 
1336
1330
  MagickRealType
1337
1331
    gamma;
1338
1332
 
1339
 
  register ssize_t
 
1333
  register long
1340
1334
    i;
1341
1335
 
1342
 
  size_t
 
1336
  unsigned long
1343
1337
    width;
1344
1338
 
1345
 
  ssize_t
1346
 
    y;
1347
 
 
1348
1339
  /*
1349
1340
    Initialize convolve image attributes.
1350
1341
  */
1372
1363
        format[MaxTextExtent],
1373
1364
        *message;
1374
1365
 
1375
 
      ssize_t
 
1366
      long
1376
1367
        u,
1377
1368
        v;
1378
1369
 
1380
1371
        *k;
1381
1372
 
1382
1373
      (void) LogMagickEvent(TransformEvent,GetMagickModule(),
1383
 
        "  ConvolveImage with %.20gx%.20g kernel:",(double) width,(double)
1384
 
        width);
 
1374
        "  ConvolveImage with %ldx%ld kernel:",width,width);
1385
1375
      message=AcquireString("");
1386
1376
      k=kernel;
1387
 
      for (v=0; v < (ssize_t) width; v++)
 
1377
      for (v=0; v < (long) width; v++)
1388
1378
      {
1389
1379
        *message='\0';
1390
 
        (void) FormatMagickString(format,MaxTextExtent,"%.20g: ",(double) v);
 
1380
        (void) FormatMagickString(format,MaxTextExtent,"%ld: ",v);
1391
1381
        (void) ConcatenateString(&message,format);
1392
 
        for (u=0; u < (ssize_t) width; u++)
 
1382
        for (u=0; u < (long) width; u++)
1393
1383
        {
1394
1384
          (void) FormatMagickString(format,MaxTextExtent,"%g ",*k++);
1395
1385
          (void) ConcatenateString(&message,format);
1409
1399
      ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
1410
1400
    }
1411
1401
  gamma=0.0;
1412
 
  for (i=0; i < (ssize_t) (width*width); i++)
 
1402
  for (i=0; i < (long) (width*width); i++)
1413
1403
    gamma+=kernel[i];
1414
1404
  gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
1415
 
  for (i=0; i < (ssize_t) (width*width); i++)
 
1405
  for (i=0; i < (long) (width*width); i++)
1416
1406
    normal_kernel[i]=gamma*kernel[i];
1417
1407
  /*
1418
1408
    Convolve image.
1426
1416
#if defined(MAGICKCORE_OPENMP_SUPPORT)
1427
1417
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
1428
1418
#endif
1429
 
  for (y=0; y < (ssize_t) image->rows; y++)
 
1419
  for (y=0; y < (long) image->rows; y++)
1430
1420
  {
1431
1421
    MagickBooleanType
1432
1422
      sync;
1440
1430
    register IndexPacket
1441
1431
      *restrict convolve_indexes;
1442
1432
 
1443
 
    register ssize_t
 
1433
    register long
1444
1434
      x;
1445
1435
 
1446
1436
    register PixelPacket
1448
1438
 
1449
1439
    if (status == MagickFalse)
1450
1440
      continue;
1451
 
    p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y-(ssize_t) (width/
 
1441
    p=GetCacheViewVirtualPixels(image_view,-((long) width/2L),y-(long) (width/
1452
1442
      2L),image->columns+width,width,exception);
1453
1443
    q=GetCacheViewAuthenticPixels(convolve_view,0,y,convolve_image->columns,1,
1454
1444
      exception);
1459
1449
      }
1460
1450
    indexes=GetCacheViewVirtualIndexQueue(image_view);
1461
1451
    convolve_indexes=GetCacheViewAuthenticIndexQueue(convolve_view);
1462
 
    for (x=0; x < (ssize_t) image->columns; x++)
 
1452
    for (x=0; x < (long) image->columns; x++)
1463
1453
    {
1464
 
      ssize_t
 
1454
      long
1465
1455
        v;
1466
1456
 
1467
1457
      MagickPixelPacket
1473
1463
      register const PixelPacket
1474
1464
        *restrict kernel_pixels;
1475
1465
 
1476
 
      register ssize_t
 
1466
      register long
1477
1467
        u;
1478
1468
 
1479
1469
      pixel=bias;
1481
1471
      kernel_pixels=p;
1482
1472
      if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
1483
1473
        {
1484
 
          for (v=0; v < (ssize_t) width; v++)
 
1474
          for (v=0; v < (long) width; v++)
1485
1475
          {
1486
 
            for (u=0; u < (ssize_t) width; u++)
 
1476
            for (u=0; u < (long) width; u++)
1487
1477
            {
1488
1478
              pixel.red+=(*k)*kernel_pixels[u].red;
1489
1479
              pixel.green+=(*k)*kernel_pixels[u].green;
1502
1492
            {
1503
1493
              k=normal_kernel;
1504
1494
              kernel_pixels=p;
1505
 
              for (v=0; v < (ssize_t) width; v++)
 
1495
              for (v=0; v < (long) width; v++)
1506
1496
              {
1507
 
                for (u=0; u < (ssize_t) width; u++)
 
1497
                for (u=0; u < (long) width; u++)
1508
1498
                {
1509
1499
                  pixel.opacity+=(*k)*kernel_pixels[u].opacity;
1510
1500
                  k++;
1521
1511
 
1522
1512
              k=normal_kernel;
1523
1513
              kernel_indexes=indexes;
1524
 
              for (v=0; v < (ssize_t) width; v++)
 
1514
              for (v=0; v < (long) width; v++)
1525
1515
              {
1526
 
                for (u=0; u < (ssize_t) width; u++)
 
1516
                for (u=0; u < (long) width; u++)
1527
1517
                {
1528
1518
                  pixel.index+=(*k)*kernel_indexes[u];
1529
1519
                  k++;
1540
1530
            gamma;
1541
1531
 
1542
1532
          gamma=0.0;
1543
 
          for (v=0; v < (ssize_t) width; v++)
 
1533
          for (v=0; v < (long) width; v++)
1544
1534
          {
1545
 
            for (u=0; u < (ssize_t) width; u++)
 
1535
            for (u=0; u < (long) width; u++)
1546
1536
            {
1547
1537
              alpha=(MagickRealType) (QuantumScale*(QuantumRange-
1548
1538
                kernel_pixels[u].opacity));
1565
1555
            {
1566
1556
              k=normal_kernel;
1567
1557
              kernel_pixels=p;
1568
 
              for (v=0; v < (ssize_t) width; v++)
 
1558
              for (v=0; v < (long) width; v++)
1569
1559
              {
1570
 
                for (u=0; u < (ssize_t) width; u++)
 
1560
                for (u=0; u < (long) width; u++)
1571
1561
                {
1572
1562
                  pixel.opacity+=(*k)*kernel_pixels[u].opacity;
1573
1563
                  k++;
1585
1575
              k=normal_kernel;
1586
1576
              kernel_pixels=p;
1587
1577
              kernel_indexes=indexes;
1588
 
              for (v=0; v < (ssize_t) width; v++)
 
1578
              for (v=0; v < (long) width; v++)
1589
1579
              {
1590
 
                for (u=0; u < (ssize_t) width; u++)
 
1580
                for (u=0; u < (long) width; u++)
1591
1581
                {
1592
1582
                  alpha=(MagickRealType) (QuantumScale*(QuantumRange-
1593
1583
                    kernel_pixels[u].opacity));
1657
1647
 
1658
1648
static Quantum **DestroyPixelThreadSet(Quantum **pixels)
1659
1649
{
1660
 
  register ssize_t
 
1650
  register long
1661
1651
    i;
1662
1652
 
1663
1653
  assert(pixels != (Quantum **) NULL);
1664
 
  for (i=0; i < (ssize_t) GetOpenMPMaximumThreads(); i++)
 
1654
  for (i=0; i < (long) GetOpenMPMaximumThreads(); i++)
1665
1655
    if (pixels[i] != (Quantum *) NULL)
1666
1656
      pixels[i]=(Quantum *) RelinquishMagickMemory(pixels[i]);
1667
1657
  pixels=(Quantum **) RelinquishAlignedMemory(pixels);
1670
1660
 
1671
1661
static Quantum **AcquirePixelThreadSet(const size_t count)
1672
1662
{
1673
 
  register ssize_t
 
1663
  register long
1674
1664
    i;
1675
1665
 
1676
1666
  Quantum
1677
1667
    **pixels;
1678
1668
 
1679
 
  size_t
 
1669
  unsigned long
1680
1670
    number_threads;
1681
1671
 
1682
1672
  number_threads=GetOpenMPMaximumThreads();
1684
1674
  if (pixels == (Quantum **) NULL)
1685
1675
    return((Quantum **) NULL);
1686
1676
  (void) ResetMagickMemory(pixels,0,number_threads*sizeof(*pixels));
1687
 
  for (i=0; i < (ssize_t) number_threads; i++)
 
1677
  for (i=0; i < (long) number_threads; i++)
1688
1678
  {
1689
1679
    pixels[i]=(Quantum *) AcquireQuantumMemory(count,sizeof(**pixels));
1690
1680
    if (pixels[i] == (Quantum *) NULL)
1693
1683
  return(pixels);
1694
1684
}
1695
1685
 
1696
 
static void Hull(const ssize_t x_offset,const ssize_t y_offset,
1697
 
  const size_t columns,const size_t rows,Quantum *f,Quantum *g,
 
1686
static void Hull(const long x_offset,const long y_offset,
 
1687
  const unsigned long columns,const unsigned long rows,Quantum *f,Quantum *g,
1698
1688
  const int polarity)
1699
1689
{
1700
 
  ssize_t
 
1690
  long
1701
1691
    y;
1702
1692
 
1703
1693
  MagickRealType
1704
1694
    v;
1705
1695
 
1706
 
  register ssize_t
 
1696
  register long
1707
1697
    x;
1708
1698
 
1709
1699
  register Quantum
1716
1706
  assert(g != (Quantum *) NULL);
1717
1707
  p=f+(columns+2);
1718
1708
  q=g+(columns+2);
1719
 
  r=p+(y_offset*((ssize_t) columns+2)+x_offset);
1720
 
  for (y=0; y < (ssize_t) rows; y++)
 
1709
  r=p+(y_offset*((long) columns+2)+x_offset);
 
1710
  for (y=0; y < (long) rows; y++)
1721
1711
  {
1722
1712
    p++;
1723
1713
    q++;
1724
1714
    r++;
1725
1715
    if (polarity > 0)
1726
 
      for (x=(ssize_t) columns; x != 0; x--)
 
1716
      for (x=(long) columns; x != 0; x--)
1727
1717
      {
1728
1718
        v=(MagickRealType) (*p);
1729
1719
        if ((MagickRealType) *r >= (v+(MagickRealType) ScaleCharToQuantum(2)))
1734
1724
        r++;
1735
1725
      }
1736
1726
    else
1737
 
      for (x=(ssize_t) columns; x != 0; x--)
 
1727
      for (x=(long) columns; x != 0; x--)
1738
1728
      {
1739
1729
        v=(MagickRealType) (*p);
1740
1730
        if ((MagickRealType) *r <= (v-(MagickRealType) ScaleCharToQuantum(2)))
1741
 
          v-=(ssize_t) ScaleCharToQuantum(1);
 
1731
          v-=(long) ScaleCharToQuantum(1);
1742
1732
        *q=(Quantum) v;
1743
1733
        p++;
1744
1734
        q++;
1750
1740
  }
1751
1741
  p=f+(columns+2);
1752
1742
  q=g+(columns+2);
1753
 
  r=q+(y_offset*((ssize_t) columns+2)+x_offset);
1754
 
  s=q-(y_offset*((ssize_t) columns+2)+x_offset);
1755
 
  for (y=0; y < (ssize_t) rows; y++)
 
1743
  r=q+(y_offset*((long) columns+2)+x_offset);
 
1744
  s=q-(y_offset*((long) columns+2)+x_offset);
 
1745
  for (y=0; y < (long) rows; y++)
1756
1746
  {
1757
1747
    p++;
1758
1748
    q++;
1759
1749
    r++;
1760
1750
    s++;
1761
1751
    if (polarity > 0)
1762
 
      for (x=(ssize_t) columns; x != 0; x--)
 
1752
      for (x=(long) columns; x != 0; x--)
1763
1753
      {
1764
1754
        v=(MagickRealType) (*q);
1765
1755
        if (((MagickRealType) *s >=
1773
1763
        s++;
1774
1764
      }
1775
1765
    else
1776
 
      for (x=(ssize_t) columns; x != 0; x--)
 
1766
      for (x=(long) columns; x != 0; x--)
1777
1767
      {
1778
1768
        v=(MagickRealType) (*q);
1779
1769
        if (((MagickRealType) *s <=
1804
1794
  Image
1805
1795
    *despeckle_image;
1806
1796
 
1807
 
  ssize_t
 
1797
  long
1808
1798
    channel;
1809
1799
 
1810
1800
  MagickBooleanType
1817
1807
  size_t
1818
1808
    length;
1819
1809
 
1820
 
  static const ssize_t
 
1810
  static const int
1821
1811
    X[4] = {0, 1, 1,-1},
1822
1812
    Y[4] = {1, 0, 1, 1};
1823
1813
 
1866
1856
#endif
1867
1857
  for (channel=0; channel <= 3; channel++)
1868
1858
  {
1869
 
    ssize_t
 
1859
    long
1870
1860
      j,
1871
1861
      y;
1872
1862
 
1873
 
    register ssize_t
 
1863
    register long
1874
1864
      i,
1875
1865
      id,
1876
1866
      x;
1885
1875
    pixel=pixels[id];
1886
1876
    (void) ResetMagickMemory(pixel,0,length*sizeof(*pixel));
1887
1877
    buffer=buffers[id];
1888
 
    j=(ssize_t) image->columns+2;
1889
 
    for (y=0; y < (ssize_t) image->rows; y++)
 
1878
    j=(long) image->columns+2;
 
1879
    for (y=0; y < (long) image->rows; y++)
1890
1880
    {
1891
1881
      register const PixelPacket
1892
1882
        *restrict p;
1895
1885
      if (p == (const PixelPacket *) NULL)
1896
1886
        break;
1897
1887
      j++;
1898
 
      for (x=0; x < (ssize_t) image->columns; x++)
 
1888
      for (x=0; x < (long) image->columns; x++)
1899
1889
      {
1900
1890
        switch (channel)
1901
1891
        {
1918
1908
      Hull(-X[i],-Y[i],image->columns,image->rows,pixel,buffer,-1);
1919
1909
      Hull(X[i],Y[i],image->columns,image->rows,pixel,buffer,-1);
1920
1910
    }
1921
 
    j=(ssize_t) image->columns+2;
1922
 
    for (y=0; y < (ssize_t) image->rows; y++)
 
1911
    j=(long) image->columns+2;
 
1912
    for (y=0; y < (long) image->rows; y++)
1923
1913
    {
1924
1914
      MagickBooleanType
1925
1915
        sync;
1932
1922
      if (q == (PixelPacket *) NULL)
1933
1923
        break;
1934
1924
      j++;
1935
 
      for (x=0; x < (ssize_t) image->columns; x++)
 
1925
      for (x=0; x < (long) image->columns; x++)
1936
1926
      {
1937
1927
        switch (channel)
1938
1928
        {
1961
1951
#if defined(MAGICKCORE_OPENMP_SUPPORT)
1962
1952
  #pragma omp critical (MagickCore_DespeckleImage)
1963
1953
#endif
1964
 
        proceed=SetImageProgress(image,DespeckleImageTag,(MagickOffsetType)
1965
 
          channel,3);
 
1954
        proceed=SetImageProgress(image,DespeckleImageTag,channel,3);
1966
1955
        if (proceed == MagickFalse)
1967
1956
          status=MagickFalse;
1968
1957
      }
2015
2004
  double
2016
2005
    *kernel;
2017
2006
 
2018
 
  register ssize_t
 
2007
  register long
2019
2008
    i;
2020
2009
 
2021
 
  size_t
 
2010
  unsigned long
2022
2011
    width;
2023
2012
 
2024
2013
  assert(image != (const Image *) NULL);
2031
2020
  kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
2032
2021
  if (kernel == (double *) NULL)
2033
2022
    ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
2034
 
  for (i=0; i < (ssize_t) (width*width); i++)
 
2023
  for (i=0; i < (long) (width*width); i++)
2035
2024
    kernel[i]=(-1.0);
2036
2025
  kernel[i/2]=(double) (width*width-1.0);
2037
2026
  edge_image=ConvolveImage(image,width,kernel,exception);
2081
2070
  Image
2082
2071
    *emboss_image;
2083
2072
 
2084
 
  ssize_t
 
2073
  long
2085
2074
    j,
2086
2075
    k,
2087
2076
    u,
2088
2077
    v;
2089
2078
 
2090
 
  register ssize_t
 
2079
  register long
2091
2080
    i;
2092
2081
 
2093
 
  size_t
 
2082
  unsigned long
2094
2083
    width;
2095
2084
 
2096
2085
  assert(image != (Image *) NULL);
2103
2092
  kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
2104
2093
  if (kernel == (double *) NULL)
2105
2094
    ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
2106
 
  j=(ssize_t) width/2;
 
2095
  j=(long) width/2;
2107
2096
  k=j;
2108
2097
  i=0;
2109
2098
  for (v=(-j); v <= j; v++)
2180
2169
  Image
2181
2170
    *filter_image;
2182
2171
 
 
2172
  long
 
2173
    progress,
 
2174
    y;
 
2175
 
2183
2176
  MagickBooleanType
2184
2177
    status;
2185
2178
 
2186
 
  MagickOffsetType
2187
 
    progress;
2188
 
 
2189
2179
  MagickPixelPacket
2190
2180
    bias;
2191
2181
 
2192
 
  ssize_t
2193
 
    y;
2194
 
 
2195
2182
  /*
2196
2183
    Initialize filter image attributes.
2197
2184
  */
2218
2205
        format[MaxTextExtent],
2219
2206
        *message;
2220
2207
 
2221
 
      ssize_t
 
2208
      long
2222
2209
        u,
2223
2210
        v;
2224
2211
 
2226
2213
        *k;
2227
2214
 
2228
2215
      (void) LogMagickEvent(TransformEvent,GetMagickModule(),
2229
 
        "  FilterImage with %.20gx%.20g kernel:",(double) kernel->width,(double)
2230
 
        kernel->height);
 
2216
        "  FilterImage with %ldx%ld kernel:",kernel->width,kernel->height);
2231
2217
      message=AcquireString("");
2232
2218
      k=kernel->values;
2233
 
      for (v=0; v < (ssize_t) kernel->height; v++)
 
2219
      for (v=0; v < (long) kernel->height; v++)
2234
2220
      {
2235
2221
        *message='\0';
2236
 
        (void) FormatMagickString(format,MaxTextExtent,"%.20g: ",(double) v);
 
2222
        (void) FormatMagickString(format,MaxTextExtent,"%ld: ",v);
2237
2223
        (void) ConcatenateString(&message,format);
2238
 
        for (u=0; u < (ssize_t) kernel->width; u++)
 
2224
        for (u=0; u < (long) kernel->width; u++)
2239
2225
        {
2240
2226
          (void) FormatMagickString(format,MaxTextExtent,"%g ",*k++);
2241
2227
          (void) ConcatenateString(&message,format);
2259
2245
#if defined(MAGICKCORE_OPENMP_SUPPORT)
2260
2246
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
2261
2247
#endif
2262
 
  for (y=0; y < (ssize_t) image->rows; y++)
 
2248
  for (y=0; y < (long) image->rows; y++)
2263
2249
  {
2264
2250
    MagickBooleanType
2265
2251
      sync;
2273
2259
    register IndexPacket
2274
2260
      *restrict filter_indexes;
2275
2261
 
2276
 
    register ssize_t
 
2262
    register long
2277
2263
      x;
2278
2264
 
2279
2265
    register PixelPacket
2281
2267
 
2282
2268
    if (status == MagickFalse)
2283
2269
      continue;
2284
 
    p=GetCacheViewVirtualPixels(image_view,-((ssize_t) kernel->width/2L),
2285
 
      y-(ssize_t) (kernel->height/2L),image->columns+kernel->width,kernel->height,
 
2270
    p=GetCacheViewVirtualPixels(image_view,-((long) kernel->width/2L),
 
2271
      y-(long) (kernel->height/2L),image->columns+kernel->width,kernel->height,
2286
2272
      exception);
2287
2273
    q=GetCacheViewAuthenticPixels(filter_view,0,y,filter_image->columns,1,
2288
2274
      exception);
2293
2279
      }
2294
2280
    indexes=GetCacheViewVirtualIndexQueue(image_view);
2295
2281
    filter_indexes=GetCacheViewAuthenticIndexQueue(filter_view);
2296
 
    for (x=0; x < (ssize_t) image->columns; x++)
 
2282
    for (x=0; x < (long) image->columns; x++)
2297
2283
    {
2298
 
      ssize_t
 
2284
      long
2299
2285
        v;
2300
2286
 
2301
2287
      MagickPixelPacket
2307
2293
      register const PixelPacket
2308
2294
        *restrict kernel_pixels;
2309
2295
 
2310
 
      register ssize_t
 
2296
      register long
2311
2297
        u;
2312
2298
 
2313
2299
      pixel=bias;
2315
2301
      kernel_pixels=p;
2316
2302
      if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
2317
2303
        {
2318
 
          for (v=0; v < (ssize_t) kernel->width; v++)
 
2304
          for (v=0; v < (long) kernel->width; v++)
2319
2305
          {
2320
 
            for (u=0; u < (ssize_t) kernel->height; u++)
 
2306
            for (u=0; u < (long) kernel->height; u++)
2321
2307
            {
2322
2308
              pixel.red+=(*k)*kernel_pixels[u].red;
2323
2309
              pixel.green+=(*k)*kernel_pixels[u].green;
2336
2322
            {
2337
2323
              k=kernel->values;
2338
2324
              kernel_pixels=p;
2339
 
              for (v=0; v < (ssize_t) kernel->width; v++)
 
2325
              for (v=0; v < (long) kernel->width; v++)
2340
2326
              {
2341
 
                for (u=0; u < (ssize_t) kernel->height; u++)
 
2327
                for (u=0; u < (long) kernel->height; u++)
2342
2328
                {
2343
2329
                  pixel.opacity+=(*k)*kernel_pixels[u].opacity;
2344
2330
                  k++;
2355
2341
 
2356
2342
              k=kernel->values;
2357
2343
              kernel_indexes=indexes;
2358
 
              for (v=0; v < (ssize_t) kernel->width; v++)
 
2344
              for (v=0; v < (long) kernel->width; v++)
2359
2345
              {
2360
 
                for (u=0; u < (ssize_t) kernel->height; u++)
 
2346
                for (u=0; u < (long) kernel->height; u++)
2361
2347
                {
2362
2348
                  pixel.index+=(*k)*kernel_indexes[u];
2363
2349
                  k++;
2374
2360
            gamma;
2375
2361
 
2376
2362
          gamma=0.0;
2377
 
          for (v=0; v < (ssize_t) kernel->width; v++)
 
2363
          for (v=0; v < (long) kernel->width; v++)
2378
2364
          {
2379
 
            for (u=0; u < (ssize_t) kernel->height; u++)
 
2365
            for (u=0; u < (long) kernel->height; u++)
2380
2366
            {
2381
2367
              alpha=(MagickRealType) (QuantumScale*(QuantumRange-
2382
2368
                kernel_pixels[u].opacity));
2399
2385
            {
2400
2386
              k=kernel->values;
2401
2387
              kernel_pixels=p;
2402
 
              for (v=0; v < (ssize_t) kernel->width; v++)
 
2388
              for (v=0; v < (long) kernel->width; v++)
2403
2389
              {
2404
 
                for (u=0; u < (ssize_t) kernel->height; u++)
 
2390
                for (u=0; u < (long) kernel->height; u++)
2405
2391
                {
2406
2392
                  pixel.opacity+=(*k)*kernel_pixels[u].opacity;
2407
2393
                  k++;
2419
2405
              k=kernel->values;
2420
2406
              kernel_pixels=p;
2421
2407
              kernel_indexes=indexes;
2422
 
              for (v=0; v < (ssize_t) kernel->width; v++)
 
2408
              for (v=0; v < (long) kernel->width; v++)
2423
2409
              {
2424
 
                for (u=0; u < (ssize_t) kernel->height; u++)
 
2410
                for (u=0; u < (long) kernel->height; u++)
2425
2411
                {
2426
2412
                  alpha=(MagickRealType) (QuantumScale*(QuantumRange-
2427
2413
                    kernel_pixels[u].opacity));
2522
2508
  Image
2523
2509
    *blur_image;
2524
2510
 
2525
 
  ssize_t
 
2511
  long
2526
2512
    j,
2527
2513
    u,
2528
2514
    v;
2529
2515
 
2530
 
  register ssize_t
 
2516
  register long
2531
2517
    i;
2532
2518
 
2533
 
  size_t
 
2519
  unsigned long
2534
2520
    width;
2535
2521
 
2536
2522
  assert(image != (const Image *) NULL);
2543
2529
  kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
2544
2530
  if (kernel == (double *) NULL)
2545
2531
    ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
2546
 
  j=(ssize_t) width/2;
 
2532
  j=(long) width/2;
2547
2533
  i=0;
2548
2534
  for (v=(-j); v <= j; v++)
2549
2535
  {
2595
2581
 
2596
2582
typedef struct _MedianListNode
2597
2583
{
2598
 
  size_t
 
2584
  unsigned long
2599
2585
    next[9],
2600
2586
    count,
2601
2587
    signature;
2603
2589
 
2604
2590
typedef struct _MedianSkipList
2605
2591
{
2606
 
  ssize_t
 
2592
  long
2607
2593
    level;
2608
2594
 
2609
2595
  MedianListNode
2612
2598
 
2613
2599
typedef struct _MedianPixelList
2614
2600
{
2615
 
  size_t
 
2601
  unsigned long
2616
2602
    center,
2617
2603
    seed,
2618
2604
    signature;
2623
2609
 
2624
2610
static MedianPixelList *DestroyMedianPixelList(MedianPixelList *pixel_list)
2625
2611
{
2626
 
  register ssize_t
 
2612
  register long
2627
2613
    i;
2628
2614
 
2629
2615
  if (pixel_list == (MedianPixelList *) NULL)
2639
2625
static MedianPixelList **DestroyMedianPixelListThreadSet(
2640
2626
  MedianPixelList **pixel_list)
2641
2627
{
2642
 
  register ssize_t
 
2628
  register long
2643
2629
    i;
2644
2630
 
2645
2631
  assert(pixel_list != (MedianPixelList **) NULL);
2646
 
  for (i=0; i < (ssize_t) GetOpenMPMaximumThreads(); i++)
 
2632
  for (i=0; i < (long) GetOpenMPMaximumThreads(); i++)
2647
2633
    if (pixel_list[i] != (MedianPixelList *) NULL)
2648
2634
      pixel_list[i]=DestroyMedianPixelList(pixel_list[i]);
2649
2635
  pixel_list=(MedianPixelList **) RelinquishAlignedMemory(pixel_list);
2650
2636
  return(pixel_list);
2651
2637
}
2652
2638
 
2653
 
static MedianPixelList *AcquireMedianPixelList(const size_t width)
 
2639
static MedianPixelList *AcquireMedianPixelList(const unsigned long width)
2654
2640
{
2655
2641
  MedianPixelList
2656
2642
    *pixel_list;
2657
2643
 
2658
 
  register ssize_t
 
2644
  register long
2659
2645
    i;
2660
2646
 
2661
2647
  pixel_list=(MedianPixelList *) AcquireAlignedMemory(1,sizeof(*pixel_list));
2677
2663
}
2678
2664
 
2679
2665
static MedianPixelList **AcquireMedianPixelListThreadSet(
2680
 
  const size_t width)
 
2666
  const unsigned long width)
2681
2667
{
2682
 
  register ssize_t
 
2668
  register long
2683
2669
    i;
2684
2670
 
2685
2671
  MedianPixelList
2686
2672
    **pixel_list;
2687
2673
 
2688
 
  size_t
 
2674
  unsigned long
2689
2675
    number_threads;
2690
2676
 
2691
2677
  number_threads=GetOpenMPMaximumThreads();
2694
2680
  if (pixel_list == (MedianPixelList **) NULL)
2695
2681
    return((MedianPixelList **) NULL);
2696
2682
  (void) ResetMagickMemory(pixel_list,0,number_threads*sizeof(*pixel_list));
2697
 
  for (i=0; i < (ssize_t) number_threads; i++)
 
2683
  for (i=0; i < (long) number_threads; i++)
2698
2684
  {
2699
2685
    pixel_list[i]=AcquireMedianPixelList(width);
2700
2686
    if (pixel_list[i] == (MedianPixelList *) NULL)
2704
2690
}
2705
2691
 
2706
2692
static void AddNodeMedianPixelList(MedianPixelList *pixel_list,
2707
 
  const ssize_t channel,const size_t color)
 
2693
  const long channel,const unsigned long color)
2708
2694
{
2709
 
  register ssize_t
 
2695
  register long
2710
2696
    level;
2711
2697
 
2712
2698
  register MedianSkipList
2713
2699
    *list;
2714
2700
 
2715
 
  size_t
 
2701
  unsigned long
2716
2702
    search,
2717
2703
    update[9];
2718
2704
 
2723
2709
  list->nodes[color].signature=pixel_list->signature;
2724
2710
  list->nodes[color].count=1;
2725
2711
  /*
2726
 
    Determine where it bessize_ts in the list.
 
2712
    Determine where it belongs in the list.
2727
2713
  */
2728
2714
  search=65536UL;
2729
2715
  for (level=list->level; level >= 0; level--)
2769
2755
  MagickPixelPacket
2770
2756
    pixel;
2771
2757
 
2772
 
  register ssize_t
 
2758
  register long
2773
2759
    channel;
2774
2760
 
2775
2761
  register MedianSkipList
2776
2762
    *list;
2777
2763
 
2778
 
  size_t
 
2764
  unsigned long
2779
2765
    center,
2780
2766
    color,
2781
2767
    count;
2813
2799
  const PixelPacket *pixel,const IndexPacket *indexes,
2814
2800
  MedianPixelList *pixel_list)
2815
2801
{
2816
 
  size_t
 
2802
  unsigned long
2817
2803
    signature;
2818
2804
 
2819
2805
  unsigned short
2857
2843
  int
2858
2844
    level;
2859
2845
 
2860
 
  register ssize_t
 
2846
  register long
2861
2847
    channel;
2862
2848
 
2863
2849
  register MedianListNode
2892
2878
  Image
2893
2879
    *median_image;
2894
2880
 
 
2881
  long
 
2882
    progress,
 
2883
    y;
 
2884
 
2895
2885
  MagickBooleanType
2896
2886
    status;
2897
2887
 
2898
 
  MagickOffsetType
2899
 
    progress;
2900
 
 
2901
2888
  MedianPixelList
2902
2889
    **restrict pixel_list;
2903
2890
 
2904
 
  size_t
 
2891
  unsigned long
2905
2892
    width;
2906
2893
 
2907
 
  ssize_t
2908
 
    y;
2909
 
 
2910
2894
  /*
2911
2895
    Initialize median image attributes.
2912
2896
  */
2945
2929
#if defined(MAGICKCORE_OPENMP_SUPPORT)
2946
2930
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
2947
2931
#endif
2948
 
  for (y=0; y < (ssize_t) median_image->rows; y++)
 
2932
  for (y=0; y < (long) median_image->rows; y++)
2949
2933
  {
2950
2934
    register const IndexPacket
2951
2935
      *restrict indexes;
2956
2940
    register IndexPacket
2957
2941
      *restrict median_indexes;
2958
2942
 
2959
 
    register ssize_t
 
2943
    register long
2960
2944
      id,
2961
2945
      x;
2962
2946
 
2965
2949
 
2966
2950
    if (status == MagickFalse)
2967
2951
      continue;
2968
 
    p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y-(ssize_t) (width/
 
2952
    p=GetCacheViewVirtualPixels(image_view,-((long) width/2L),y-(long) (width/
2969
2953
      2L),image->columns+width,width,exception);
2970
2954
    q=QueueCacheViewAuthenticPixels(median_view,0,y,median_image->columns,1,
2971
2955
      exception);
2977
2961
    indexes=GetCacheViewVirtualIndexQueue(image_view);
2978
2962
    median_indexes=GetCacheViewAuthenticIndexQueue(median_view);
2979
2963
    id=GetOpenMPThreadId();
2980
 
    for (x=0; x < (ssize_t) median_image->columns; x++)
 
2964
    for (x=0; x < (long) median_image->columns; x++)
2981
2965
    {
2982
2966
      MagickPixelPacket
2983
2967
        pixel;
2988
2972
      register const IndexPacket
2989
2973
        *restrict s;
2990
2974
 
2991
 
      register ssize_t
 
2975
      register long
2992
2976
        u,
2993
2977
        v;
2994
2978
 
2995
2979
      r=p;
2996
2980
      s=indexes+x;
2997
2981
      ResetMedianPixelList(pixel_list[id]);
2998
 
      for (v=0; v < (ssize_t) width; v++)
 
2982
      for (v=0; v < (long) width; v++)
2999
2983
      {
3000
 
        for (u=0; u < (ssize_t) width; u++)
 
2984
        for (u=0; u < (long) width; u++)
3001
2985
          InsertMedianPixelList(image,r+u,s+u,pixel_list[id]);
3002
2986
        r+=image->columns+width;
3003
2987
        s+=image->columns+width;
3074
3058
%
3075
3059
*/
3076
3060
 
3077
 
static double *GetMotionBlurKernel(const size_t width,const double sigma)
 
3061
static double *GetMotionBlurKernel(const unsigned long width,const double sigma)
3078
3062
{
3079
3063
  double
3080
3064
    *kernel,
3081
3065
    normalize;
3082
3066
 
3083
 
  register ssize_t
 
3067
  register long
3084
3068
    i;
3085
3069
 
3086
3070
  /*
3091
3075
  if (kernel == (double *) NULL)
3092
3076
    return(kernel);
3093
3077
  normalize=0.0;
3094
 
  for (i=0; i < (ssize_t) width; i++)
 
3078
  for (i=0; i < (long) width; i++)
3095
3079
  {
3096
3080
    kernel[i]=exp((-((double) i*i)/(double) (2.0*MagickSigma*MagickSigma)))/
3097
3081
      (MagickSQ2PI*MagickSigma);
3098
3082
    normalize+=kernel[i];
3099
3083
  }
3100
 
  for (i=0; i < (ssize_t) width; i++)
 
3084
  for (i=0; i < (long) width; i++)
3101
3085
    kernel[i]/=normalize;
3102
3086
  return(kernel);
3103
3087
}
3127
3111
  Image
3128
3112
    *blur_image;
3129
3113
 
 
3114
  long
 
3115
    progress,
 
3116
    y;
 
3117
 
3130
3118
  MagickBooleanType
3131
3119
    status;
3132
3120
 
3133
 
  MagickOffsetType
3134
 
    progress;
3135
 
 
3136
3121
  MagickPixelPacket
3137
3122
    bias;
3138
3123
 
3142
3127
  PointInfo
3143
3128
    point;
3144
3129
 
3145
 
  register ssize_t
 
3130
  register long
3146
3131
    i;
3147
3132
 
3148
 
  size_t
 
3133
  unsigned long
3149
3134
    width;
3150
3135
 
3151
 
  ssize_t
3152
 
    y;
3153
 
 
3154
3136
  assert(image != (Image *) NULL);
3155
3137
  assert(image->signature == MagickSignature);
3156
3138
  if (image->debug != MagickFalse)
3183
3165
    }
3184
3166
  point.x=(double) width*sin(DegreesToRadians(angle));
3185
3167
  point.y=(double) width*cos(DegreesToRadians(angle));
3186
 
  for (i=0; i < (ssize_t) width; i++)
 
3168
  for (i=0; i < (long) width; i++)
3187
3169
  {
3188
 
    offset[i].x=(ssize_t) ceil((double) (i*point.y)/hypot(point.x,point.y)-0.5);
3189
 
    offset[i].y=(ssize_t) ceil((double) (i*point.x)/hypot(point.x,point.y)-0.5);
 
3170
    offset[i].x=(long) ((i*point.y)/hypot(point.x,point.y)+0.5);
 
3171
    offset[i].y=(long) ((i*point.x)/hypot(point.x,point.y)+0.5);
3190
3172
  }
3191
3173
  /*
3192
3174
    Motion blur image.
3196
3178
  GetMagickPixelPacket(image,&bias);
3197
3179
  image_view=AcquireCacheView(image);
3198
3180
  blur_view=AcquireCacheView(blur_image);
3199
 
#if defined(MAGICKCORE_OPENMP_SUPPORT) 
3200
 
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
 
3181
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
3182
  #pragma omp parallel for schedule(static) shared(progress,status)
3201
3183
#endif
3202
 
  for (y=0; y < (ssize_t) image->rows; y++)
 
3184
  for (y=0; y < (long) image->rows; y++)
3203
3185
  {
3204
3186
    register IndexPacket
3205
3187
      *restrict blur_indexes;
3206
3188
 
3207
 
    register ssize_t
 
3189
    register long
3208
3190
      x;
3209
3191
 
3210
3192
    register PixelPacket
3220
3202
        continue;
3221
3203
      }
3222
3204
    blur_indexes=GetCacheViewAuthenticIndexQueue(blur_view);
3223
 
    for (x=0; x < (ssize_t) image->columns; x++)
 
3205
    for (x=0; x < (long) image->columns; x++)
3224
3206
    {
3225
3207
      MagickPixelPacket
3226
3208
        qixel;
3231
3213
      register double
3232
3214
        *restrict k;
3233
3215
 
3234
 
      register ssize_t
 
3216
      register long
3235
3217
        i;
3236
3218
 
3237
3219
      register const IndexPacket
3241
3223
      qixel=bias;
3242
3224
      if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
3243
3225
        {
3244
 
          for (i=0; i < (ssize_t) width; i++)
 
3226
          for (i=0; i < (long) width; i++)
3245
3227
          {
3246
3228
            (void) GetOneCacheViewVirtualPixel(image_view,x+offset[i].x,y+
3247
3229
              offset[i].y,&pixel,exception);
3276
3258
 
3277
3259
          alpha=0.0;
3278
3260
          gamma=0.0;
3279
 
          for (i=0; i < (ssize_t) width; i++)
 
3261
          for (i=0; i < (long) width; i++)
3280
3262
          {
3281
3263
            (void) GetOneCacheViewVirtualPixel(image_view,x+offset[i].x,y+
3282
3264
              offset[i].y,&pixel,exception);
3283
 
            alpha=(MagickRealType) (QuantumScale*
3284
 
              GetAlphaPixelComponent(&pixel));
 
3265
            alpha=(MagickRealType) (QuantumScale*GetAlphaPixelComponent(&pixel));
3285
3266
            qixel.red+=(*k)*alpha*pixel.red;
3286
3267
            qixel.green+=(*k)*alpha*pixel.green;
3287
3268
            qixel.blue+=(*k)*alpha*pixel.blue;
3316
3297
        MagickBooleanType
3317
3298
          proceed;
3318
3299
 
3319
 
#if defined(MAGICKCORE_OPENMP_SUPPORT) 
 
3300
#if defined(MAGICKCORE_OPENMP_SUPPORT)
3320
3301
  #pragma omp critical (MagickCore_MotionBlurImageChannel)
3321
3302
#endif
3322
3303
        proceed=SetImageProgress(image,BlurImageTag,progress++,image->rows);
3391
3372
  ImageInfo
3392
3373
    *preview_info;
3393
3374
 
3394
 
  ssize_t
 
3375
  long
3395
3376
    y;
3396
3377
 
3397
3378
  MagickBooleanType
3406
3387
  RectangleInfo
3407
3388
    geometry;
3408
3389
 
3409
 
  register ssize_t
 
3390
  register long
3410
3391
    i,
3411
3392
    x;
3412
3393
 
3413
 
  size_t
 
3394
  unsigned long
3414
3395
    colors;
3415
3396
 
3416
3397
  /*
3468
3449
      }
3469
3450
      case RollPreview:
3470
3451
      {
3471
 
        x=(ssize_t) ((i+1)*thumbnail->columns)/NumberTiles;
3472
 
        y=(ssize_t) ((i+1)*thumbnail->rows)/NumberTiles;
 
3452
        x=(long) ((i+1)*thumbnail->columns)/NumberTiles;
 
3453
        y=(long) ((i+1)*thumbnail->rows)/NumberTiles;
3473
3454
        preview_image=RollImage(thumbnail,x,y,exception);
3474
 
        (void) FormatMagickString(label,MaxTextExtent,"roll %+.20gx%+.20g",
3475
 
          (double) x,(double) y);
 
3455
        (void) FormatMagickString(label,MaxTextExtent,"roll %ldx%ld",x,y);
3476
3456
        break;
3477
3457
      }
3478
3458
      case HuePreview:
3524
3504
        if (preview_image != (Image *) NULL)
3525
3505
          for (x=0; x < i; x++)
3526
3506
            (void) ContrastImage(preview_image,MagickTrue);
3527
 
        (void) FormatMagickString(label,MaxTextExtent,"contrast (%.20g)",
3528
 
          (double) i+1);
 
3507
        (void) FormatMagickString(label,MaxTextExtent,"contrast (%ld)",i+1);
3529
3508
        break;
3530
3509
      }
3531
3510
      case DullPreview:
3535
3514
          break;
3536
3515
        for (x=0; x < i; x++)
3537
3516
          (void) ContrastImage(preview_image,MagickFalse);
3538
 
        (void) FormatMagickString(label,MaxTextExtent,"+contrast (%.20g)",
3539
 
          (double) i+1);
 
3517
        (void) FormatMagickString(label,MaxTextExtent,"+contrast (%ld)",i+1);
3540
3518
        break;
3541
3519
      }
3542
3520
      case GrayscalePreview:
3549
3527
        quantize_info.colorspace=GRAYColorspace;
3550
3528
        (void) QuantizeImage(&quantize_info,preview_image);
3551
3529
        (void) FormatMagickString(label,MaxTextExtent,
3552
 
          "-colorspace gray -colors %.20g",(double) colors);
 
3530
          "-colorspace gray -colors %ld",colors);
3553
3531
        break;
3554
3532
      }
3555
3533
      case QuantizePreview:
3560
3538
        colors<<=1;
3561
3539
        quantize_info.number_colors=colors;
3562
3540
        (void) QuantizeImage(&quantize_info,preview_image);
3563
 
        (void) FormatMagickString(label,MaxTextExtent,"colors %.20g",(double)
3564
 
          colors);
 
3541
        (void) FormatMagickString(label,MaxTextExtent,"colors %ld",colors);
3565
3542
        break;
3566
3543
      }
3567
3544
      case DespecklePreview:
3577
3554
        preview_image=DespeckleImage(thumbnail,exception);
3578
3555
        if (preview_image == (Image *) NULL)
3579
3556
          break;
3580
 
        (void) FormatMagickString(label,MaxTextExtent,"despeckle (%.20g)",
3581
 
          (double) i+1);
 
3557
        (void) FormatMagickString(label,MaxTextExtent,"despeckle (%ld)",i+1);
3582
3558
        break;
3583
3559
      }
3584
3560
      case ReduceNoisePreview:
3694
3670
        preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
3695
3671
        if (preview_image == (Image *) NULL)
3696
3672
          break;
3697
 
        geometry.width=(size_t) (2*i+2);
3698
 
        geometry.height=(size_t) (2*i+2);
 
3673
        geometry.width=(unsigned long) (2*i+2);
 
3674
        geometry.height=(unsigned long) (2*i+2);
3699
3675
        geometry.x=i/2;
3700
3676
        geometry.y=i/2;
3701
3677
        (void) RaiseImage(preview_image,&geometry,MagickTrue);
3702
 
        (void) FormatMagickString(label,MaxTextExtent,
3703
 
          "raise %.20gx%.20g%+.20g%+.20g",(double) geometry.width,(double)
3704
 
          geometry.height,(double) geometry.x,(double) geometry.y);
 
3678
        (void) FormatMagickString(label,MaxTextExtent,"raise %lux%lu%+ld%+ld",
 
3679
          geometry.width,geometry.height,geometry.x,geometry.y);
3705
3680
        break;
3706
3681
      }
3707
3682
      case SegmentPreview:
3766
3741
        preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
3767
3742
        if (preview_image == (Image *) NULL)
3768
3743
          break;
3769
 
        preview_info->quality=(size_t) percentage;
3770
 
        (void) FormatMagickString(factor,MaxTextExtent,"%.20g",(double)
 
3744
        preview_info->quality=(unsigned long) percentage;
 
3745
        (void) FormatMagickString(factor,MaxTextExtent,"%lu",
3771
3746
          preview_info->quality);
3772
3747
        file=AcquireUniqueFileResource(filename);
3773
3748
        if (file != -1)
3800
3775
              "quality %s\n%gkb ",factor,(double) ((MagickOffsetType)
3801
3776
              GetBlobSize(preview_image))/1024.0);
3802
3777
          else
3803
 
            (void) FormatMagickString(label,MaxTextExtent,"quality %s\n%.20gb ",
3804
 
              factor,(double) GetBlobSize(thumbnail));
 
3778
            (void) FormatMagickString(label,MaxTextExtent,"quality %s\n%lub ",
 
3779
              factor,(unsigned long) GetBlobSize(thumbnail));
3805
3780
        break;
3806
3781
      }
3807
3782
    }
3814
3789
    (void) DeleteImageProperty(preview_image,"label");
3815
3790
    (void) SetImageProperty(preview_image,"label",label);
3816
3791
    AppendImageToList(&images,preview_image);
3817
 
    proceed=SetImageProgress(image,PreviewImageTag,(MagickOffsetType) i,
3818
 
      NumberTiles);
 
3792
    proceed=SetImageProgress(image,PreviewImageTag,i,NumberTiles);
3819
3793
    if (proceed == MagickFalse)
3820
3794
      break;
3821
3795
  }
3907
3881
  Image
3908
3882
    *blur_image;
3909
3883
 
 
3884
  long
 
3885
    progress,
 
3886
    y;
 
3887
 
3910
3888
  MagickBooleanType
3911
3889
    status;
3912
3890
 
3913
 
  MagickOffsetType
3914
 
    progress;
3915
 
 
3916
3891
  MagickPixelPacket
3917
3892
    bias;
3918
3893
 
3926
3901
  PointInfo
3927
3902
    blur_center;
3928
3903
 
3929
 
  register ssize_t
 
3904
  register long
3930
3905
    i;
3931
3906
 
3932
 
  size_t
 
3907
  unsigned long
3933
3908
    n;
3934
3909
 
3935
 
  ssize_t
3936
 
    y;
3937
 
 
3938
3910
  /*
3939
3911
    Allocate blur image.
3940
3912
  */
3956
3928
  blur_center.x=(double) image->columns/2.0;
3957
3929
  blur_center.y=(double) image->rows/2.0;
3958
3930
  blur_radius=hypot(blur_center.x,blur_center.y);
3959
 
  n=(size_t) fabs(4.0*DegreesToRadians(angle)*sqrt((double) blur_radius)+
 
3931
  n=(unsigned long) fabs(4.0*DegreesToRadians(angle)*sqrt((double) blur_radius)+
3960
3932
    2UL);
3961
3933
  theta=DegreesToRadians(angle)/(MagickRealType) (n-1);
3962
3934
  cos_theta=(MagickRealType *) AcquireQuantumMemory((size_t) n,
3970
3942
      ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
3971
3943
    }
3972
3944
  offset=theta*(MagickRealType) (n-1)/2.0;
3973
 
  for (i=0; i < (ssize_t) n; i++)
 
3945
  for (i=0; i < (long) n; i++)
3974
3946
  {
3975
3947
    cos_theta[i]=cos((double) (theta*i-offset));
3976
3948
    sin_theta[i]=sin((double) (theta*i-offset));
3986
3958
#if defined(MAGICKCORE_OPENMP_SUPPORT)
3987
3959
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
3988
3960
#endif
3989
 
  for (y=0; y < (ssize_t) blur_image->rows; y++)
 
3961
  for (y=0; y < (long) blur_image->rows; y++)
3990
3962
  {
3991
3963
    register const IndexPacket
3992
3964
      *restrict indexes;
3994
3966
    register IndexPacket
3995
3967
      *restrict blur_indexes;
3996
3968
 
3997
 
    register ssize_t
 
3969
    register long
3998
3970
      x;
3999
3971
 
4000
3972
    register PixelPacket
4010
3982
        continue;
4011
3983
      }
4012
3984
    blur_indexes=GetCacheViewAuthenticIndexQueue(blur_view);
4013
 
    for (x=0; x < (ssize_t) blur_image->columns; x++)
 
3985
    for (x=0; x < (long) blur_image->columns; x++)
4014
3986
    {
4015
3987
      MagickPixelPacket
4016
3988
        qixel;
4025
3997
      PointInfo
4026
3998
        center;
4027
3999
 
4028
 
      register ssize_t
 
4000
      register long
4029
4001
        i;
4030
4002
 
4031
 
      size_t
 
4003
      unsigned long
4032
4004
        step;
4033
4005
 
4034
4006
      center.x=(double) x-blur_center.x;
4038
4010
        step=1;
4039
4011
      else
4040
4012
        {
4041
 
          step=(size_t) (blur_radius/radius);
 
4013
          step=(unsigned long) (blur_radius/radius);
4042
4014
          if (step == 0)
4043
4015
            step=1;
4044
4016
          else
4049
4021
      qixel=bias;
4050
4022
      if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
4051
4023
        {
4052
 
          for (i=0; i < (ssize_t) n; i+=(ssize_t) step)
 
4024
          for (i=0; i < (long) n; i+=step)
4053
4025
          {
4054
 
            (void) GetOneCacheViewVirtualPixel(image_view,(ssize_t)
4055
 
              (blur_center.x+center.x*cos_theta[i]-center.y*sin_theta[i]+0.5),
4056
 
              (ssize_t) (blur_center.y+center.x*sin_theta[i]+center.y*
4057
 
              cos_theta[i]+0.5),&pixel,exception);
 
4026
            (void) GetOneCacheViewVirtualPixel(image_view,(long) (blur_center.x+
 
4027
              center.x*cos_theta[i]-center.y*sin_theta[i]+0.5),(long) (
 
4028
              blur_center.y+center.x*sin_theta[i]+center.y*cos_theta[i]+0.5),
 
4029
              &pixel,exception);
4058
4030
            qixel.red+=pixel.red;
4059
4031
            qixel.green+=pixel.green;
4060
4032
            qixel.blue+=pixel.blue;
4088
4060
 
4089
4061
          alpha=1.0;
4090
4062
          gamma=0.0;
4091
 
          for (i=0; i < (ssize_t) n; i+=(ssize_t) step)
 
4063
          for (i=0; i < (long) n; i+=step)
4092
4064
          {
4093
 
            (void) GetOneCacheViewVirtualPixel(image_view,(ssize_t)
4094
 
              (blur_center.x+center.x*cos_theta[i]-center.y*sin_theta[i]+0.5),
4095
 
              (ssize_t) (blur_center.y+center.x*sin_theta[i]+center.y*
4096
 
              cos_theta[i]+0.5),&pixel,exception);
 
4065
            (void) GetOneCacheViewVirtualPixel(image_view,(long) (blur_center.x+
 
4066
              center.x*cos_theta[i]-center.y*sin_theta[i]+0.5),(long) (
 
4067
              blur_center.y+center.x*sin_theta[i]+center.y*cos_theta[i]+0.5),
 
4068
              &pixel,exception);
4097
4069
            alpha=(MagickRealType) (QuantumScale*
4098
4070
              GetAlphaPixelComponent(&pixel));
4099
4071
            qixel.red+=alpha*pixel.red;
4185
4157
  MagickPixelPacket
4186
4158
    pixel;
4187
4159
 
4188
 
  register ssize_t
 
4160
  register long
4189
4161
    channel;
4190
4162
 
4191
4163
  register MedianSkipList
4192
4164
    *list;
4193
4165
 
4194
 
  size_t
 
4166
  unsigned long
4195
4167
    center,
4196
4168
    color,
4197
4169
    count,
4247
4219
  Image
4248
4220
    *noise_image;
4249
4221
 
 
4222
  long
 
4223
    progress,
 
4224
    y;
 
4225
 
4250
4226
  MagickBooleanType
4251
4227
    status;
4252
4228
 
4253
 
  MagickOffsetType
4254
 
    progress;
4255
 
 
4256
4229
  MedianPixelList
4257
4230
    **restrict pixel_list;
4258
4231
 
4259
 
  size_t
 
4232
  unsigned long
4260
4233
    width;
4261
4234
 
4262
 
  ssize_t
4263
 
    y;
4264
 
 
4265
4235
  /*
4266
4236
    Initialize noise image attributes.
4267
4237
  */
4300
4270
#if defined(MAGICKCORE_OPENMP_SUPPORT)
4301
4271
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
4302
4272
#endif
4303
 
  for (y=0; y < (ssize_t) noise_image->rows; y++)
 
4273
  for (y=0; y < (long) noise_image->rows; y++)
4304
4274
  {
4305
4275
    register const IndexPacket
4306
4276
      *restrict indexes;
4311
4281
    register IndexPacket
4312
4282
      *restrict noise_indexes;
4313
4283
 
4314
 
    register ssize_t
 
4284
    register long
4315
4285
      id,
4316
4286
      x;
4317
4287
 
4320
4290
 
4321
4291
    if (status == MagickFalse)
4322
4292
      continue;
4323
 
    p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y-(ssize_t) (width/
 
4293
    p=GetCacheViewVirtualPixels(image_view,-((long) width/2L),y-(long) (width/
4324
4294
      2L),image->columns+width,width,exception);
4325
4295
    q=QueueCacheViewAuthenticPixels(noise_view,0,y,noise_image->columns,1,
4326
4296
      exception);
4332
4302
    indexes=GetCacheViewVirtualIndexQueue(image_view);
4333
4303
    noise_indexes=GetCacheViewAuthenticIndexQueue(noise_view);
4334
4304
    id=GetOpenMPThreadId();
4335
 
    for (x=0; x < (ssize_t) noise_image->columns; x++)
 
4305
    for (x=0; x < (long) noise_image->columns; x++)
4336
4306
    {
4337
4307
      MagickPixelPacket
4338
4308
        pixel;
4343
4313
      register const IndexPacket
4344
4314
        *restrict s;
4345
4315
 
4346
 
      register ssize_t
 
4316
      register long
4347
4317
        u,
4348
4318
        v;
4349
4319
 
4350
4320
      r=p;
4351
4321
      s=indexes+x;
4352
4322
      ResetMedianPixelList(pixel_list[id]);
4353
 
      for (v=0; v < (ssize_t) width; v++)
 
4323
      for (v=0; v < (long) width; v++)
4354
4324
      {
4355
 
        for (u=0; u < (ssize_t) width; u++)
 
4325
        for (u=0; u < (long) width; u++)
4356
4326
          InsertMedianPixelList(image,r+u,s+u,pixel_list[id]);
4357
4327
        r+=image->columns+width;
4358
4328
        s+=image->columns+width;
4460
4430
  Image
4461
4431
    *blur_image;
4462
4432
 
 
4433
  long
 
4434
    j,
 
4435
    progress,
 
4436
    u,
 
4437
    v,
 
4438
    y;
 
4439
 
4463
4440
  MagickBooleanType
4464
4441
    status;
4465
4442
 
4466
 
  MagickOffsetType
4467
 
    progress;
4468
 
 
4469
4443
  MagickPixelPacket
4470
4444
    bias;
4471
4445
 
4472
 
  register ssize_t
 
4446
  register long
4473
4447
    i;
4474
4448
 
4475
 
  size_t
 
4449
  unsigned long
4476
4450
    width;
4477
4451
 
4478
 
  ssize_t
4479
 
    j,
4480
 
    u,
4481
 
    v,
4482
 
    y;
4483
 
 
4484
4452
  /*
4485
4453
    Initialize blur image attributes.
4486
4454
  */
4494
4462
  kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
4495
4463
  if (kernel == (double *) NULL)
4496
4464
    ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
4497
 
  j=(ssize_t) width/2;
 
4465
  j=(long) width/2;
4498
4466
  i=0;
4499
4467
  for (v=(-j); v <= j; v++)
4500
4468
  {
4508
4476
        format[MaxTextExtent],
4509
4477
        *message;
4510
4478
 
4511
 
      ssize_t
 
4479
      long
4512
4480
        u,
4513
4481
        v;
4514
4482
 
4516
4484
        *k;
4517
4485
 
4518
4486
      (void) LogMagickEvent(TransformEvent,GetMagickModule(),
4519
 
        "  SelectiveBlurImage with %.20gx%.20g kernel:",(double) width,(double)
4520
 
        width);
 
4487
        "  SelectiveBlurImage with %ldx%ld kernel:",width,width);
4521
4488
      message=AcquireString("");
4522
4489
      k=kernel;
4523
 
      for (v=0; v < (ssize_t) width; v++)
 
4490
      for (v=0; v < (long) width; v++)
4524
4491
      {
4525
4492
        *message='\0';
4526
 
        (void) FormatMagickString(format,MaxTextExtent,"%.20g: ",(double) v);
 
4493
        (void) FormatMagickString(format,MaxTextExtent,"%ld: ",v);
4527
4494
        (void) ConcatenateString(&message,format);
4528
 
        for (u=0; u < (ssize_t) width; u++)
 
4495
        for (u=0; u < (long) width; u++)
4529
4496
        {
4530
4497
          (void) FormatMagickString(format,MaxTextExtent,"%+f ",*k++);
4531
4498
          (void) ConcatenateString(&message,format);
4555
4522
#if defined(MAGICKCORE_OPENMP_SUPPORT)
4556
4523
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
4557
4524
#endif
4558
 
  for (y=0; y < (ssize_t) image->rows; y++)
 
4525
  for (y=0; y < (long) image->rows; y++)
4559
4526
  {
4560
4527
    MagickBooleanType
4561
4528
      sync;
4572
4539
    register IndexPacket
4573
4540
      *restrict blur_indexes;
4574
4541
 
4575
 
    register ssize_t
 
4542
    register long
4576
4543
      x;
4577
4544
 
4578
4545
    register PixelPacket
4580
4547
 
4581
4548
    if (status == MagickFalse)
4582
4549
      continue;
4583
 
    p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y-(ssize_t) (width/
 
4550
    p=GetCacheViewVirtualPixels(image_view,-((long) width/2L),y-(long) (width/
4584
4551
      2L),image->columns+width,width,exception);
4585
4552
    q=GetCacheViewAuthenticPixels(blur_view,0,y,blur_image->columns,1,
4586
4553
      exception);
4591
4558
      }
4592
4559
    indexes=GetCacheViewVirtualIndexQueue(image_view);
4593
4560
    blur_indexes=GetCacheViewAuthenticIndexQueue(blur_view);
4594
 
    for (x=0; x < (ssize_t) image->columns; x++)
 
4561
    for (x=0; x < (long) image->columns; x++)
4595
4562
    {
4596
 
      ssize_t
 
4563
      long
4597
4564
        j,
4598
4565
        v;
4599
4566
 
4603
4570
      register const double
4604
4571
        *restrict k;
4605
4572
 
4606
 
      register ssize_t
 
4573
      register long
4607
4574
        u;
4608
4575
 
4609
4576
      pixel=bias;
4612
4579
      j=0;
4613
4580
      if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
4614
4581
        {
4615
 
          for (v=0; v < (ssize_t) width; v++)
 
4582
          for (v=0; v < (long) width; v++)
4616
4583
          {
4617
 
            for (u=0; u < (ssize_t) width; u++)
 
4584
            for (u=0; u < (long) width; u++)
4618
4585
            {
4619
4586
              if (SelectiveContrast(p+u+j,q,threshold) != MagickFalse)
4620
4587
                {
4625
4592
                  k++;
4626
4593
                }
4627
4594
            }
4628
 
            j+=(ssize_t) (image->columns+width);
 
4595
            j+=image->columns+width;
4629
4596
          }
4630
4597
          if (gamma != 0.0)
4631
4598
            {
4641
4608
            {
4642
4609
              gamma=0.0;
4643
4610
              j=0;
4644
 
              for (v=0; v < (ssize_t) width; v++)
 
4611
              for (v=0; v < (long) width; v++)
4645
4612
              {
4646
 
                for (u=0; u < (ssize_t) width; u++)
 
4613
                for (u=0; u < (long) width; u++)
4647
4614
                {
4648
4615
                  if (SelectiveContrast(p+u+j,q,threshold) != MagickFalse)
4649
4616
                    {
4652
4619
                      k++;
4653
4620
                    }
4654
4621
                }
4655
 
                j+=(ssize_t) (image->columns+width);
 
4622
                j+=image->columns+width;
4656
4623
              }
4657
4624
              if (gamma != 0.0)
4658
4625
                {
4667
4634
            {
4668
4635
              gamma=0.0;
4669
4636
              j=0;
4670
 
              for (v=0; v < (ssize_t) width; v++)
 
4637
              for (v=0; v < (long) width; v++)
4671
4638
              {
4672
 
                for (u=0; u < (ssize_t) width; u++)
 
4639
                for (u=0; u < (long) width; u++)
4673
4640
                {
4674
4641
                  if (SelectiveContrast(p+u+j,q,threshold) != MagickFalse)
4675
4642
                    {
4678
4645
                      k++;
4679
4646
                    }
4680
4647
                }
4681
 
                j+=(ssize_t) (image->columns+width);
 
4648
                j+=image->columns+width;
4682
4649
              }
4683
4650
              if (gamma != 0.0)
4684
4651
                {
4694
4661
          MagickRealType
4695
4662
            alpha;
4696
4663
 
4697
 
          for (v=0; v < (ssize_t) width; v++)
 
4664
          for (v=0; v < (long) width; v++)
4698
4665
          {
4699
 
            for (u=0; u < (ssize_t) width; u++)
 
4666
            for (u=0; u < (long) width; u++)
4700
4667
            {
4701
4668
              if (SelectiveContrast(p+u+j,q,threshold) != MagickFalse)
4702
4669
                {
4710
4677
                  k++;
4711
4678
                }
4712
4679
            }
4713
 
            j+=(ssize_t) (image->columns+width);
 
4680
            j+=image->columns+width;
4714
4681
          }
4715
4682
          if (gamma != 0.0)
4716
4683
            {
4726
4693
            {
4727
4694
              gamma=0.0;
4728
4695
              j=0;
4729
 
              for (v=0; v < (ssize_t) width; v++)
 
4696
              for (v=0; v < (long) width; v++)
4730
4697
              {
4731
 
                for (u=0; u < (ssize_t) width; u++)
 
4698
                for (u=0; u < (long) width; u++)
4732
4699
                {
4733
4700
                  if (SelectiveContrast(p+u+j,q,threshold) != MagickFalse)
4734
4701
                    {
4737
4704
                      k++;
4738
4705
                    }
4739
4706
                }
4740
 
                j+=(ssize_t) (image->columns+width);
 
4707
                j+=image->columns+width;
4741
4708
              }
4742
4709
              if (gamma != 0.0)
4743
4710
                {
4752
4719
            {
4753
4720
              gamma=0.0;
4754
4721
              j=0;
4755
 
              for (v=0; v < (ssize_t) width; v++)
 
4722
              for (v=0; v < (long) width; v++)
4756
4723
              {
4757
 
                for (u=0; u < (ssize_t) width; u++)
 
4724
                for (u=0; u < (long) width; u++)
4758
4725
                {
4759
4726
                  if (SelectiveContrast(p+u+j,q,threshold) != MagickFalse)
4760
4727
                    {
4765
4732
                      k++;
4766
4733
                    }
4767
4734
                }
4768
 
                j+=(ssize_t) (image->columns+width);
 
4735
                j+=image->columns+width;
4769
4736
              }
4770
4737
              if (gamma != 0.0)
4771
4738
                {
4849
4816
  Image
4850
4817
    *shade_image;
4851
4818
 
 
4819
  long
 
4820
    progress,
 
4821
    y;
 
4822
 
4852
4823
  MagickBooleanType
4853
4824
    status;
4854
4825
 
4855
 
  MagickOffsetType
4856
 
    progress;
4857
 
 
4858
4826
  PrimaryInfo
4859
4827
    light;
4860
4828
 
4861
 
  ssize_t
4862
 
    y;
4863
 
 
4864
4829
  /*
4865
4830
    Initialize shaded image attributes.
4866
4831
  */
4897
4862
#if defined(MAGICKCORE_OPENMP_SUPPORT)
4898
4863
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
4899
4864
#endif
4900
 
  for (y=0; y < (ssize_t) image->rows; y++)
 
4865
  for (y=0; y < (long) image->rows; y++)
4901
4866
  {
4902
4867
    MagickRealType
4903
4868
      distance,
4913
4878
      *restrict s1,
4914
4879
      *restrict s2;
4915
4880
 
4916
 
    register ssize_t
 
4881
    register long
4917
4882
      x;
4918
4883
 
4919
4884
    register PixelPacket
4936
4901
    s0=p+1;
4937
4902
    s1=s0+image->columns+2;
4938
4903
    s2=s1+image->columns+2;
4939
 
    for (x=0; x < (ssize_t) image->columns; x++)
 
4904
    for (x=0; x < (long) image->columns; x++)
4940
4905
    {
4941
4906
      /*
4942
4907
        Determine the surface normal and compute shading.
5065
5030
  Image
5066
5031
    *sharp_image;
5067
5032
 
5068
 
  ssize_t
 
5033
  long
5069
5034
    j,
5070
5035
    u,
5071
5036
    v;
5072
5037
 
5073
 
  register ssize_t
 
5038
  register long
5074
5039
    i;
5075
5040
 
5076
 
  size_t
 
5041
  unsigned long
5077
5042
    width;
5078
5043
 
5079
5044
  assert(image != (const Image *) NULL);
5087
5052
  if (kernel == (double *) NULL)
5088
5053
    ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
5089
5054
  normalize=0.0;
5090
 
  j=(ssize_t) width/2;
 
5055
  j=(long) width/2;
5091
5056
  i=0;
5092
5057
  for (v=(-j); v <= j; v++)
5093
5058
  {
5144
5109
  Image
5145
5110
    *spread_image;
5146
5111
 
 
5112
  long
 
5113
    progress,
 
5114
    y;
 
5115
 
5147
5116
  MagickBooleanType
5148
5117
    status;
5149
5118
 
5150
 
  MagickOffsetType
5151
 
    progress;
5152
 
 
5153
5119
  MagickPixelPacket
5154
5120
    bias;
5155
5121
 
5159
5125
  ResampleFilter
5160
5126
    **restrict resample_filter;
5161
5127
 
5162
 
  size_t
 
5128
  unsigned long
5163
5129
    width;
5164
5130
 
5165
 
  ssize_t
5166
 
    y;
5167
 
 
5168
5131
  /*
5169
5132
    Initialize spread image attributes.
5170
5133
  */
5195
5158
    UndefinedVirtualPixelMethod,MagickTrue,exception);
5196
5159
  random_info=AcquireRandomInfoThreadSet();
5197
5160
  image_view=AcquireCacheView(spread_image);
5198
 
#if defined(MAGICKCORE_OPENMP_SUPPORT) 
5199
 
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
 
5161
#if defined(MAGICKCORE_OPENMP_SUPPORT)
 
5162
  #pragma omp parallel for schedule(static) shared(progress,status)
5200
5163
#endif
5201
 
  for (y=0; y < (ssize_t) spread_image->rows; y++)
 
5164
  for (y=0; y < (long) spread_image->rows; y++)
5202
5165
  {
5203
5166
    MagickPixelPacket
5204
5167
      pixel;
5206
5169
    register IndexPacket
5207
5170
      *restrict indexes;
5208
5171
 
5209
 
    register ssize_t
 
5172
    register long
5210
5173
      id,
5211
5174
      x;
5212
5175
 
5225
5188
    indexes=GetCacheViewAuthenticIndexQueue(image_view);
5226
5189
    pixel=bias;
5227
5190
    id=GetOpenMPThreadId();
5228
 
    for (x=0; x < (ssize_t) spread_image->columns; x++)
 
5191
    for (x=0; x < (long) spread_image->columns; x++)
5229
5192
    {
5230
5193
      (void) ResamplePixelColor(resample_filter[id],(double) x+width*
5231
5194
        (GetPseudoRandomValue(random_info[id])-0.5),(double) y+width*
5240
5203
        MagickBooleanType
5241
5204
          proceed;
5242
5205
 
5243
 
#if defined(MAGICKCORE_OPENMP_SUPPORT) 
 
5206
#if defined(MAGICKCORE_OPENMP_SUPPORT)
5244
5207
  #pragma omp critical (MagickCore_SpreadImage)
5245
5208
#endif
5246
5209
        proceed=SetImageProgress(image,SpreadImageTag,progress++,image->rows);
5324
5287
  Image
5325
5288
    *unsharp_image;
5326
5289
 
 
5290
  long
 
5291
    progress,
 
5292
    y;
 
5293
 
5327
5294
  MagickBooleanType
5328
5295
    status;
5329
5296
 
5330
 
  MagickOffsetType
5331
 
    progress;
5332
 
 
5333
5297
  MagickPixelPacket
5334
5298
    bias;
5335
5299
 
5336
5300
  MagickRealType
5337
5301
    quantum_threshold;
5338
5302
 
5339
 
  ssize_t
5340
 
    y;
5341
 
 
5342
5303
  assert(image != (const Image *) NULL);
5343
5304
  assert(image->signature == MagickSignature);
5344
5305
  if (image->debug != MagickFalse)
5359
5320
#if defined(MAGICKCORE_OPENMP_SUPPORT)
5360
5321
  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
5361
5322
#endif
5362
 
  for (y=0; y < (ssize_t) image->rows; y++)
 
5323
  for (y=0; y < (long) image->rows; y++)
5363
5324
  {
5364
5325
    MagickPixelPacket
5365
5326
      pixel;
5373
5334
    register IndexPacket
5374
5335
      *restrict unsharp_indexes;
5375
5336
 
5376
 
    register ssize_t
 
5337
    register long
5377
5338
      x;
5378
5339
 
5379
5340
    register PixelPacket
5392
5353
    indexes=GetCacheViewVirtualIndexQueue(image_view);
5393
5354
    unsharp_indexes=GetCacheViewAuthenticIndexQueue(unsharp_view);
5394
5355
    pixel=bias;
5395
 
    for (x=0; x < (ssize_t) image->columns; x++)
 
5356
    for (x=0; x < (long) image->columns; x++)
5396
5357
    {
5397
5358
      if ((channel & RedChannel) != 0)
5398
5359
        {