Changeset 530 for ImageMagick/trunk

Show
Ignore:
Timestamp:
11/03/09 12:14:50 (3 weeks ago)
Author:
cristy
Message:
 
Location:
ImageMagick/trunk/magick
Files:
3 modified

Legend:

Unmodified
Added
Removed

  • ImageMagick/trunk/magick/effect.c

    r404 r530  
    159159 
    160160  MagickPixelPacket 
    161     zero; 
     161    bias; 
    162162 
    163163  MagickRealType 
    164164    alpha, 
    165     bias, 
    166165    normalize; 
    167166 
    … …  
    264263  status=MagickTrue; 
    265264  progress=0; 
    266   bias=image->bias; 
    267   GetMagickPixelPacket(image,&zero); 
     265  GetMagickPixelPacket(image,&bias); 
     266  SetMagickPixelPacketBias(image,&bias); 
    268267  image_view=AcquireCacheView(image); 
    269268  edge_view=AcquireCacheView(edge_image); 
    … …  
    332331        break; 
    333332      indexes=GetCacheViewVirtualIndexQueue(image_view); 
    334       pixel=zero; 
     333      pixel=bias; 
    335334      k=kernel[i]; 
    336335      for (v=0; v < (long) (width-i); v++) 
    … …  
    360359      gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma); 
    361360      if ((channel & RedChannel) != 0) 
    362         q->red=RoundToQuantum(gamma*pixel.red+bias); 
     361        q->red=RoundToQuantum(gamma*pixel.red); 
    363362      if ((channel & GreenChannel) != 0) 
    364         q->green=RoundToQuantum(gamma*pixel.green+bias); 
     363        q->green=RoundToQuantum(gamma*pixel.green); 
    365364      if ((channel & BlueChannel) != 0) 
    366         q->blue=RoundToQuantum(gamma*pixel.blue+bias); 
     365        q->blue=RoundToQuantum(gamma*pixel.blue); 
    367366      if ((channel & OpacityChannel) != 0) 
    368         q->opacity=RoundToQuantum(pixel.opacity+bias); 
     367        q->opacity=RoundToQuantum(pixel.opacity); 
    369368      if (((channel & IndexChannel) != 0) && 
    370369          (image->colorspace == CMYKColorspace)) 
    371         blur_indexes[x]=RoundToQuantum(gamma*pixel.index+bias); 
     370        blur_indexes[x]=RoundToQuantum(gamma*pixel.index); 
    372371      q++; 
    373372      r++; 
    … …  
    477476 
    478477  MagickPixelPacket 
    479     zero; 
     478    bias; 
    480479 
    481480  MagickRealType 
    482481    alpha, 
    483     bias, 
    484482    normalize; 
    485483 
    … …  
    582580  status=MagickTrue; 
    583581  progress=0; 
    584   bias=image->bias; 
    585   GetMagickPixelPacket(image,&zero); 
     582  GetMagickPixelPacket(image,&bias); 
     583  SetMagickPixelPacketBias(image,&bias); 
    586584  image_view=AcquireCacheView(image); 
    587585  edge_view=AcquireCacheView(edge_image); 
    … …  
    651649      indexes=GetCacheViewVirtualIndexQueue(image_view); 
    652650      k=kernel[i]; 
    653       pixel=zero; 
     651      pixel=bias; 
    654652      for (v=0; v < (long) (width-i); v++) 
    655653      { 
    … …  
    678676      gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma); 
    679677      if ((channel & RedChannel) != 0) 
    680         q->red=RoundToQuantum(gamma*pixel.red+bias); 
     678        q->red=RoundToQuantum(gamma*pixel.red); 
    681679      if ((channel & GreenChannel) != 0) 
    682         q->green=RoundToQuantum(gamma*pixel.green+bias); 
     680        q->green=RoundToQuantum(gamma*pixel.green); 
    683681      if ((channel & BlueChannel) != 0) 
    684         q->blue=RoundToQuantum(gamma*pixel.blue+bias); 
     682        q->blue=RoundToQuantum(gamma*pixel.blue); 
    685683      if ((channel & OpacityChannel) != 0) 
    686         q->opacity=RoundToQuantum(pixel.opacity+bias); 
     684        q->opacity=RoundToQuantum(pixel.opacity); 
    687685      if (((channel & IndexChannel) != 0) && 
    688686          (image->colorspace == CMYKColorspace)) 
    689         sharp_indexes[x]=RoundToQuantum(gamma*pixel.index+bias); 
     687        sharp_indexes[x]=RoundToQuantum(gamma*pixel.index); 
    690688      q++; 
    691689      r++; 
    … …  
    802800    alpha=exp((-((double) (i*i))/(double) (2.0*KernelRank*KernelRank* 
    803801      MagickSigma*MagickSigma))); 
    804     kernel[(i+bias)/KernelRank]+=(double) (alpha/(MagickSQ2PI*sigma)); 
     802    kernel[(i)/KernelRank]+=(double) (alpha/(MagickSQ2PI*sigma)); 
    805803  } 
    806804  normalize=0.0; 
    … …  
    833831 
    834832  MagickPixelPacket 
    835     zero; 
    836  
    837   MagickRealType 
    838833    bias; 
    839834 
    … …  
    904899  status=MagickTrue; 
    905900  progress=0; 
    906   GetMagickPixelPacket(image,&zero); 
    907   bias=image->bias; 
     901  GetMagickPixelPacket(image,&bias); 
     902  SetMagickPixelPacketBias(image,&bias); 
    908903  image_view=AcquireCacheView(image); 
    909904  blur_view=AcquireCacheView(blur_image); 
    … …  
    955950        i; 
    956951 
    957       pixel=zero; 
     952      pixel=bias; 
    958953      k=kernel; 
    959954      kernel_pixels=p; 
    … …  
    969964          } 
    970965          if ((channel & RedChannel) != 0) 
    971             q->red=RoundToQuantum(pixel.red+bias); 
     966            q->red=RoundToQuantum(pixel.red); 
    972967          if ((channel & GreenChannel) != 0) 
    973             q->green=RoundToQuantum(pixel.green+bias); 
     968            q->green=RoundToQuantum(pixel.green); 
    974969          if ((channel & BlueChannel) != 0) 
    975             q->blue=RoundToQuantum(pixel.blue+bias); 
     970            q->blue=RoundToQuantum(pixel.blue); 
    976971          if ((channel & OpacityChannel) != 0) 
    977972            { 
    … …  
    984979                kernel_pixels++; 
    985980              } 
    986               q->opacity=RoundToQuantum(pixel.opacity+bias); 
     981              q->opacity=RoundToQuantum(pixel.opacity); 
    987982            } 
    988983          if (((channel & IndexChannel) != 0) && 
    … …  
    1000995                kernel_indexes++; 
    1001996              } 
    1002               blur_indexes[x]=RoundToQuantum(pixel.index+bias); 
     997              blur_indexes[x]=RoundToQuantum(pixel.index); 
    1003998            } 
    1004999        } 
    … …  
    10231018          gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma); 
    10241019          if ((channel & RedChannel) != 0) 
    1025             q->red=RoundToQuantum(gamma*pixel.red+bias); 
     1020            q->red=RoundToQuantum(gamma*pixel.red); 
    10261021          if ((channel & GreenChannel) != 0) 
    1027             q->green=RoundToQuantum(gamma*pixel.green+bias); 
     1022            q->green=RoundToQuantum(gamma*pixel.green); 
    10281023          if ((channel & BlueChannel) != 0) 
    1029             q->blue=RoundToQuantum(gamma*pixel.blue+bias); 
     1024            q->blue=RoundToQuantum(gamma*pixel.blue); 
    10301025          if ((channel & OpacityChannel) != 0) 
    10311026            { 
    … …  
    10381033                kernel_pixels++; 
    10391034              } 
    1040               q->opacity=RoundToQuantum(pixel.opacity+bias); 
     1035              q->opacity=RoundToQuantum(pixel.opacity); 
    10411036            } 
    10421037          if (((channel & IndexChannel) != 0) && 
    … …  
    10581053                kernel_indexes++; 
    10591054              } 
    1060               blur_indexes[x]=RoundToQuantum(gamma*pixel.index+bias); 
     1055              blur_indexes[x]=RoundToQuantum(gamma*pixel.index); 
    10611056            } 
    10621057        } 
    … …  
    11331128        i; 
    11341129 
    1135       pixel=zero; 
     1130      pixel=bias; 
    11361131      k=kernel; 
    11371132      kernel_pixels=p; 
    … …  
    11471142          } 
    11481143          if ((channel & RedChannel) != 0) 
    1149             q->red=RoundToQuantum(pixel.red+bias); 
     1144            q->red=RoundToQuantum(pixel.red); 
    11501145          if ((channel & GreenChannel) != 0) 
    1151             q->green=RoundToQuantum(pixel.green+bias); 
     1146            q->green=RoundToQuantum(pixel.green); 
    11521147          if ((channel & BlueChannel) != 0) 
    1153             q->blue=RoundToQuantum(pixel.blue+bias); 
     1148            q->blue=RoundToQuantum(pixel.blue); 
    11541149          if ((channel & OpacityChannel) != 0) 
    11551150            { 
    … …  
    11621157                kernel_pixels++; 
    11631158              } 
    1164               q->opacity=RoundToQuantum(pixel.opacity+bias); 
     1159              q->opacity=RoundToQuantum(pixel.opacity); 
    11651160            } 
    11661161          if (((channel & IndexChannel) != 0) && 
    … …  
    11781173                kernel_indexes++; 
    11791174              } 
    1180               blur_indexes[y]=RoundToQuantum(pixel.index+bias); 
     1175              blur_indexes[y]=RoundToQuantum(pixel.index); 
    11811176            } 
    11821177        } 
    … …  
    12011196          gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma); 
    12021197          if ((channel & RedChannel) != 0) 
    1203             q->red=RoundToQuantum(gamma*pixel.red+bias); 
     1198            q->red=RoundToQuantum(gamma*pixel.red); 
    12041199          if ((channel & GreenChannel) != 0) 
    1205             q->green=RoundToQuantum(gamma*pixel.green+bias); 
     1200            q->green=RoundToQuantum(gamma*pixel.green); 
    12061201          if ((channel & BlueChannel) != 0) 
    1207             q->blue=RoundToQuantum(gamma*pixel.blue+bias); 
     1202            q->blue=RoundToQuantum(gamma*pixel.blue); 
    12081203          if ((channel & OpacityChannel) != 0) 
    12091204            { 
    … …  
    12161211                kernel_pixels++; 
    12171212              } 
    1218               q->opacity=RoundToQuantum(pixel.opacity+bias); 
     1213              q->opacity=RoundToQuantum(pixel.opacity); 
    12191214            } 
    12201215          if (((channel & IndexChannel) != 0) && 
    … …  
    12361231                kernel_indexes++; 
    12371232              } 
    1238               blur_indexes[y]=RoundToQuantum(gamma*pixel.index+bias); 
     1233              blur_indexes[y]=RoundToQuantum(gamma*pixel.index); 
    12391234            } 
    12401235        } 
    … …  
    24532448 
    24542449  MagickPixelPacket 
    2455     zero; 
     2450    bias; 
    24562451 
    24572452  OffsetInfo 
    … …  
    25132508  status=MagickTrue; 
    25142509  progress=0; 
    2515   GetMagickPixelPacket(image,&zero); 
     2510  GetMagickPixelPacket(image,&bias); 
    25162511  image_view=AcquireCacheView(image); 
    25172512  blur_view=AcquireCacheView(blur_image); 
    … …  
    25582553 
    25592554      k=kernel; 
    2560       qixel=zero; 
     2555      qixel=bias; 
    25612556      if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse)) 
    25622557        { 
    … …  
    32213216 
    32223217  MagickPixelPacket 
    3223     zero; 
     3218    bias; 
    32243219 
    32253220  MagickRealType 
    … …  
    32883283  status=MagickTrue; 
    32893284  progress=0; 
    3290   GetMagickPixelPacket(image,&zero); 
     3285  GetMagickPixelPacket(image,&bias); 
    32913286  image_view=AcquireCacheView(image); 
    32923287  blur_view=AcquireCacheView(blur_image); 
    … …  
    33543349        } 
    33553350      normalize=0.0; 
    3356       qixel=zero; 
     3351      qixel=bias; 
    33573352      if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse)) 
    33583353        { 
    … …  
    37713766 
    37723767  MagickPixelPacket 
    3773     zero; 
    3774  
    3775   MagickRealType 
    37763768    bias; 
    37773769 
    … …  
    38553847  status=MagickTrue; 
    38563848  progress=0; 
    3857   GetMagickPixelPacket(image,&zero); 
    3858   bias=image->bias; 
     3849  GetMagickPixelPacket(image,&bias); 
     3850  SetMagickPixelPacketBias(image,&bias); 
    38593851  image_view=AcquireCacheView(image); 
    38603852  blur_view=AcquireCacheView(blur_image); 
    … …  
    39133905        u; 
    39143906 
    3915       pixel=zero; 
     3907      pixel=bias; 
    39163908      k=kernel; 
    39173909      gamma=0.0; 
    … …  
    39383930              gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma); 
    39393931              if ((channel & RedChannel) != 0) 
    3940                 q->red=RoundToQuantum(gamma*pixel.red+bias); 
     3932                q->red=RoundToQuantum(gamma*pixel.red); 
    39413933              if ((channel & GreenChannel) != 0) 
    3942                 q->green=RoundToQuantum(gamma*pixel.green+bias); 
     3934                q->green=RoundToQuantum(gamma*pixel.green); 
    39433935              if ((channel & BlueChannel) != 0) 
    3944                 q->blue=RoundToQuantum(gamma*pixel.blue+bias); 
     3936                q->blue=RoundToQuantum(gamma*pixel.blue); 
    39453937            } 
    39463938          if ((channel & OpacityChannel) != 0) 
    … …  
    39653957                  gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : 
    39663958                    gamma); 
    3967                   q->opacity=RoundToQuantum(gamma*pixel.opacity+bias); 
     3959                  q->opacity=RoundToQuantum(gamma*pixel.opacity); 
    39683960                } 
    39693961            } 
    … …  
    39903982                  gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : 
    39913983                    gamma); 
    3992                   blur_indexes[x]=RoundToQuantum(gamma*pixel.index+bias); 
     3984                  blur_indexes[x]=RoundToQuantum(gamma*pixel.index); 
    39933985                } 
    39943986            } 
    … …  
    40214013              gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma); 
    40224014              if ((channel & RedChannel) != 0) 
    4023                 q->red=RoundToQuantum(gamma*pixel.red+bias); 
     4015                q->red=RoundToQuantum(gamma*pixel.red); 
    40244016              if ((channel & GreenChannel) != 0) 
    4025                 q->green=RoundToQuantum(gamma*pixel.green+bias); 
     4017                q->green=RoundToQuantum(gamma*pixel.green); 
    40264018              if ((channel & BlueChannel) != 0) 
    4027                 q->blue=RoundToQuantum(gamma*pixel.blue+bias); 
     4019                q->blue=RoundToQuantum(gamma*pixel.blue); 
    40284020            } 
    40294021          if ((channel & OpacityChannel) != 0) 
    … …  
    40484040                  gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : 
    40494041                    gamma); 
    4050                   q->opacity=RoundToQuantum(pixel.opacity+bias); 
     4042                  q->opacity=RoundToQuantum(pixel.opacity); 
    40514043                } 
    40524044            } 
    … …  
    40754067                  gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : 
    40764068                    gamma); 
    4077                   blur_indexes[x]=RoundToQuantum(gamma*pixel.index+bias); 
     4069                  blur_indexes[x]=RoundToQuantum(gamma*pixel.index); 
    40784070                } 
    40794071            } 
    … …  
    44494441 
    44504442  MagickPixelPacket 
    4451     zero; 
     4443    bias; 
    44524444 
    44534445  RandomInfo 
    … …  
    44874479  status=MagickTrue; 
    44884480  progress=0; 
    4489   GetMagickPixelPacket(spread_image,&zero); 
     4481  GetMagickPixelPacket(spread_image,&bias); 
    44904482  width=GetOptimalKernelWidth1D(radius,0.5); 
    44914483  resample_filter=AcquireResampleFilterThreadSet(image,MagickTrue,exception); 
    … …  
    45204512      } 
    45214513    indexes=GetCacheViewAuthenticIndexQueue(image_view); 
    4522     pixel=zero; 
     4514    pixel=bias; 
    45234515    id=GetOpenMPThreadId(); 
    45244516    for (x=0; x < (long) spread_image->columns; x++) 
    … …  
    46254617 
    46264618  MagickPixelPacket 
    4627     zero; 
     4619    bias; 
    46284620 
    46294621  MagickRealType 
    … …  
    46484640  status=MagickTrue; 
    46494641  progress=0; 
    4650   GetMagickPixelPacket(image,&zero); 
     4642  GetMagickPixelPacket(image,&bias); 
    46514643  image_view=AcquireCacheView(image); 
    46524644  unsharp_view=AcquireCacheView(unsharp_image); 
    … …  
    46864678    indexes=GetCacheViewVirtualIndexQueue(image_view); 
    46874679    unsharp_indexes=GetCacheViewAuthenticIndexQueue(unsharp_view); 
    4688     pixel=zero; 
     4680    pixel=bias; 
    46894681    for (x=0; x < (long) image->columns; x++) 
    46904682    { 

  • ImageMagick/trunk/magick/fx.c

    r404 r530  
    866866 
    867867  MagickPixelPacket 
    868     zero; 
     868    bias; 
    869869 
    870870  MagickRealType 
    871     bias, 
    872871    gamma; 
    873872 
    … …  
    955954  status=MagickTrue; 
    956955  progress=0; 
    957   GetMagickPixelPacket(image,&zero); 
    958   bias=image->bias; 
     956  GetMagickPixelPacket(image,&bias); 
     957  SetMagickPixelPacketBias(image,&bias); 
    959958  image_view=AcquireCacheView(image); 
    960959  convolve_view=AcquireCacheView(convolve_image); 
    … …  
    10121011        u; 
    10131012 
    1014       pixel=zero; 
     1013      pixel=bias; 
    10151014      k=normal_kernel; 
    10161015      kernel_pixels=p; 
    … …  
    10291028          } 
    10301029          if ((channel & RedChannel) != 0) 
    1031             q->red=RoundToQuantum(pixel.red+bias); 
     1030            q->red=RoundToQuantum(pixel.red); 
    10321031          if ((channel & GreenChannel) != 0) 
    1033             q->green=RoundToQuantum(pixel.green+bias); 
     1032            q->green=RoundToQuantum(pixel.green); 
    10341033          if ((channel & BlueChannel) != 0) 
    1035             q->blue=RoundToQuantum(pixel.blue+bias); 
     1034            q->blue=RoundToQuantum(pixel.blue); 
    10361035          if ((channel & OpacityChannel) != 0) 
    10371036            { 
    … …  
    10471046                kernel_pixels+=image->columns+width; 
    10481047              } 
    1049               q->opacity=RoundToQuantum(pixel.opacity+bias); 
     1048              q->opacity=RoundToQuantum(pixel.opacity); 
    10501049            } 
    10511050          if (((channel & IndexChannel) != 0) && 
    … …  
    10661065                kernel_indexes+=image->columns+width; 
    10671066              } 
    1068               convolve_indexes[x]=RoundToQuantum(pixel.index+bias); 
     1067              convolve_indexes[x]=RoundToQuantum(pixel.index); 
    10691068            } 
    10701069        } 
    … …  
    10931092          gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma); 
    10941093          if ((channel & RedChannel) != 0) 
    1095             q->red=RoundToQuantum(gamma*pixel.red+bias); 
     1094            q->red=RoundToQuantum(gamma*pixel.red); 
    10961095          if ((channel & GreenChannel) != 0) 
    1097             q->green=RoundToQuantum(gamma*pixel.green+bias); 
     1096            q->green=RoundToQuantum(gamma*pixel.green); 
    10981097          if ((channel & BlueChannel) != 0) 
    1099             q->blue=RoundToQuantum(gamma*pixel.blue+bias); 
     1098            q->blue=RoundToQuantum(gamma*pixel.blue); 
    11001099          if ((channel & OpacityChannel) != 0) 
    11011100            { 
    … …  
    11111110                kernel_pixels+=image->columns+width; 
    11121111              } 
    1113               q->opacity=RoundToQuantum(pixel.opacity+bias); 
     1112              q->opacity=RoundToQuantum(pixel.opacity); 
    11141113            } 
    11151114          if (((channel & IndexChannel) != 0) && 
    … …  
    11341133                kernel_indexes+=image->columns+width; 
    11351134              } 
    1136               convolve_indexes[x]=RoundToQuantum(gamma*pixel.index+bias); 
     1135              convolve_indexes[x]=RoundToQuantum(gamma*pixel.index); 
    11371136            } 
    11381137        } 

  • ImageMagick/trunk/magick/pixel-private.h

    r1 r530  
    8484} 
    8585 
     86static inline void SetMagickPixelPacketBias(const Image *image, 
     87  MagickPixelPacket *pixel) 
     88{ 
     89  pixel->red=image->bias; 
     90  pixel->green=image->bias; 
     91  pixel->blue=image->bias; 
     92  pixel->opacity=image->bias; 
     93  pixel->index=image->bias; 
     94} 
     95 
    8696static inline void SetPixelPacket(const Image *image, 
    8797  const MagickPixelPacket *pixel,PixelPacket *color,IndexPacket *index)