GetPixelInfo(image,&zero);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
- IsConcurrentUno(image->colors,256)
+ dynamic_num_threads_uno(image->colors)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
{
range);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireVirtualCacheView(image,exception); /* must be virtual */
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
width=MagickMin(source_image->columns,destination_image->columns);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=0; y < (ssize_t) height; y++)
{
separate_view=AcquireAuthenticCacheView(separate_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentUno(image->colors,256)
+ dynamic_num_threads_uno(image->colors)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
image->colormap[i].alpha=(double) i;
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
0.002/film_gamma);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
logmap[i]=ScaleMapToQuantum((MagickRealType) (MaxMap*(reference_white+
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
primary_info.z=(double) (MaxMap+1.0)/2.0;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
primary_info.z=(double) (MaxMap+1.0)/2.0;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
primary_info.z=(double) (MaxMap+1.0)/2.0;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
primary_info.z=(double) (MaxMap+1.0)/2.0;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
primary_info.z=(double) (MaxMap+1.0)/2.0;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
primary_info.z=(double) (MaxMap+1.0)/2.0;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentUno(image->colors,256)
+ dynamic_num_threads_uno(image->colors)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
{
highlight_view=AcquireAuthenticCacheView(highlight_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
reconstruct_view=AcquireVirtualCacheView(reconstruct_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
similarity_view=AcquireAuthenticCacheView(similarity_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) (image->rows-reference->rows+1); y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) composite_image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y+=(ssize_t) texture_image->rows)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) raise_info->height; y++)
{
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=(ssize_t) raise_info->height; y < (ssize_t) (image->rows-raise_info->height); y++)
{
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=(ssize_t) (image->rows-raise_info->height); y < (ssize_t) image->rows; y++)
{
distort_view=AcquireAuthenticCacheView(distort_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (j=0; j < (ssize_t) distort_image->rows; j++)
{
sparse_view=AcquireAuthenticCacheView(sparse_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (j=0; j < (ssize_t) sparse_image->rows; j++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=start; y <= stop; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=bounding_box.y; y < (ssize_t) bounding_box.height; y++)
{
stop=(ssize_t) floor(bounds.y2+0.5);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=start; y <= stop; y++)
{
stop=(ssize_t) floor(bounds.y2+0.5);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=start; y <= stop; y++)
{
blur_view=AcquireAuthenticCacheView(blur_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) blur_image->rows; y++)
{
sharp_view=AcquireAuthenticCacheView(sharp_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) sharp_image->rows; y++)
{
blur_view=AcquireAuthenticCacheView(blur_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
blur_view=AcquireAuthenticCacheView(blur_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (x=0; x < (ssize_t) blur_image->columns; x++)
{
r=p+(y_offset*(columns+2)+x_offset);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentDos(columns,rows,64)
+ dynamic_num_threads_dos(columns,rows)
#endif
for (y=0; y < (ssize_t) rows; y++)
{
s=q-(y_offset*(columns+2)+x_offset);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) \
- IsConcurrentDos(columns,rows,64)
+ dynamic_num_threads_dos(columns,rows)
#endif
for (y=0; y < (ssize_t) rows; y++)
{
blur_view=AcquireAuthenticCacheView(blur_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
blur_view=AcquireAuthenticCacheView(blur_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
blur_view=AcquireAuthenticCacheView(blur_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
shade_view=AcquireAuthenticCacheView(shade_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
spread_view=AcquireAuthenticCacheView(spread_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status) \
- IsConcurrentTres(image->columns,image->rows,key == ~0UL,64)
+ dynamic_num_threads_tres(image->columns,image->rows,key == ~0UL)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
unsharp_view=AcquireAuthenticCacheView(unsharp_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
clut_view=AcquireVirtualCacheView(clut_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image->filename);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentUno(image->colors,256)
+ dynamic_num_threads_uno(image->colors)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
number_channels=GetPixelChannels(image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i < (ssize_t) number_channels; i++)
{
number_channels=GetPixelChannels(image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i < (ssize_t) number_channels; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentUno(image->colors,256)
+ dynamic_num_threads_uno(image->colors)
#endif
for (j=0; j < (ssize_t) image->colors; j++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
enhance_view=AcquireAuthenticCacheView(enhance_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
number_channels=GetPixelChannels(image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i < (ssize_t) number_channels; i++)
{
number_channels=GetPixelChannels(image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i < (ssize_t) number_channels; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentUno(image->colors,256)
+ dynamic_num_threads_uno(image->colors)
#endif
for (j=0; j < (ssize_t) image->colors; j++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
if (gamma != 0.0)
#if defined(MAGICKCORE_OPENMP_SUPPORT) && (MaxMap > 256)
#pragma omp parallel for \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
gamma_map[i]=ScaleMapToQuantum((MagickRealType) (MaxMap*pow((double) i/
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentUno(image->colors,256)
+ dynamic_num_threads_uno(image->colors)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
if (image->storage_class == PseudoClass)
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentUno(image->colors,256)
+ dynamic_num_threads_uno(image->colors)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
if (image->storage_class == PseudoClass)
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentUno(image->colors,256)
+ dynamic_num_threads_uno(image->colors)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentUno(image->colors,256)
+ dynamic_num_threads_uno(image->colors)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
switch (colorspace)
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentUno(image->colors,256)
+ dynamic_num_threads_uno(image->colors)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
{
{
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
(void) ResetMagickMemory(sigmoidal_map,0,(MaxMap+1)*sizeof(*sigmoidal_map));
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentUno(MaxMap,256)
+ dynamic_num_threads_uno(MaxMap)
#endif
for (i=0; i <= (ssize_t) MaxMap; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentUno(image->colors,256)
+ dynamic_num_threads_uno(image->colors)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(number_grays,number_grays,64)
+ dynamic_num_threads_dos(number_grays,number_grays)
#endif
for (i=0; i < 4; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(number_grays,number_grays,64)
+ dynamic_num_threads_dos(number_grays,number_grays)
#endif
for (i=0; i < 4; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(number_grays,number_grays,64)
+ dynamic_num_threads_dos(number_grays,number_grays)
#endif
for (i=0; i < 4; i++)
{
(void) ResetMagickMemory(&sum_squares,0,sizeof(sum_squares));
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(number_grays,number_grays,64)
+ dynamic_num_threads_dos(number_grays,number_grays)
#endif
for (i=0; i < 4; i++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(number_grays,number_grays,64)
+ dynamic_num_threads_dos(number_grays,number_grays)
#endif
for (i=0; i < 4; i++)
{
key=GetRandomSecretKey(random_info[0]);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentTres(image->columns,image->rows,key == ~0UL,64)
+ dynamic_num_threads_tres(image->columns,image->rows,key == ~0UL)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
shift_view=AcquireAuthenticCacheView(shift_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
colorize_view=AcquireAuthenticCacheView(colorize_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
color_view=AcquireAuthenticCacheView(color_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
fx_view=AcquireAuthenticCacheView(fx_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) fx_image->rows; y++)
{
implode_view=AcquireAuthenticCacheView(implode_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
morph_view=AcquireAuthenticCacheView(morph_images,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) morph_images->rows; y++)
{
sepia_view=AcquireAuthenticCacheView(sepia_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
random_view=AcquireAuthenticCacheView(random_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentTres(image->columns,image->rows,key == ~0UL,64)
+ dynamic_num_threads_tres(image->columns,image->rows,key == ~0UL)
#endif
for (y=0; y < (ssize_t) random_image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
swirl_view=AcquireAuthenticCacheView(swirl_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
tint_view=AcquireAuthenticCacheView(tint_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
BackgroundVirtualPixelMethod);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) wave_image->rows; y++)
{
width=source->extent.width-source->extent.x;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
{
width=source->extent.width-source->extent.x;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
{
width=destination->extent.width-destination->extent.x;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=destination->extent.y; y < (ssize_t) destination->extent.height; y++)
{
width=source->extent.width-source->extent.x;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
{
width=source->extent.width-source->extent.x;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
{
image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(range_exception,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (x=0; x < (ssize_t) image->columns; x++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
paint_view=AcquireAuthenticCacheView(paint_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
if (image->storage_class == PseudoClass)
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentUno(image->colors,256)
+ dynamic_num_threads_uno(image->colors)
#endif
for (i=0; i < (ssize_t) image->colors; i++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
scale.y=(double) image->rows/resize_image->rows;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) resize_image->rows; y++)
{
resize_view=AcquireAuthenticCacheView(resize_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (x=0; x < (ssize_t) resize_image->columns; x++)
{
resize_view=AcquireAuthenticCacheView(resize_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) resize_image->rows; y++)
{
sample_view=AcquireAuthenticCacheView(sample_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) sample_image->rows; y++)
{
if (files < 0)
files=64;
(void) SetMagickResourceLimit(FileResource,MagickMax((size_t)
- (3*files/4),64));
+ (3*files/4)));
limit=GetEnvironmentValue("MAGICK_FILE_LIMIT");
if (limit == (char *) NULL)
limit=GetPolicyValue("file");
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) \
- IsConcurrentDos(p->width,p->height,64)
+ dynamic_num_threads_dos(p->width,p->height)
#endif
for (x=0; x < (ssize_t) p->width; x++)
{
image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
(void) ResetRadonCells(source_cells);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
GetPixelCacheTileSize(image,&tile_width,&tile_height);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (tile_y=0; tile_y < (ssize_t) image->rows; tile_y+=(ssize_t) tile_height)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
GetPixelCacheTileSize(image,&tile_width,&tile_height);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (tile_y=0; tile_y < (ssize_t) image->rows; tile_y+=(ssize_t) tile_height)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=0; y < (ssize_t) height; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (x=0; x < (ssize_t) width; x++)
{
{
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentTres(images->columns,images->rows,key == ~0UL,64)
+ dynamic_num_threads_tres(images->columns,images->rows,key == ~0UL)
#endif
for (y=0; y < (ssize_t) evaluate_image->rows; y++)
{
{
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentTres(images->columns,images->rows,key == ~0UL,64)
+ dynamic_num_threads_tres(images->columns,images->rows,key == ~0UL)
#endif
for (y=0; y < (ssize_t) evaluate_image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentTres(image->columns,image->rows,key == ~0UL,64)
+ dynamic_num_threads_tres(image->columns,image->rows,key == ~0UL)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
statistic_view=AcquireAuthenticCacheView(statistic_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) statistic_image->rows; y++)
{
#include <MagickCore/thread_.h>
/*
- Can loop benefit from multi-threads?
+ Single threaded unless workload justifies the threading overhead.
*/
-#define IsConcurrentUno(colors,threshold) \
- if ((colors) > threshold) \
+#define MinimumWorkLoad() (32*GetMagickResourceLimit(ThreadResource))
+#define dynamic_num_threads_uno(colors) \
+ if ((colors) > MinimumWorkLoad()) \
num_threads(GetMagickResourceLimit(ThreadResource))
-#define IsConcurrentDos(columns,rows,threshold) \
- if (((((columns) > threshold) || ((rows) > threshold))) && \
- ((MagickSizeType) (columns*rows) > (threshold*threshold))) \
+#define dynamic_num_threads_dos(columns,rows) \
+ if (((((columns) > MinimumWorkLoad()) || \
+ ((rows) > MinimumWorkLoad()))) && ((MagickSizeType) \
+ ((columns)*(rows)) > (MinimumWorkLoad()*MinimumWorkLoad()))) \
num_threads(GetMagickResourceLimit(ThreadResource))
-#define IsConcurrentTres(columns,rows,expression,threshold) \
- if (((((columns) > threshold) || ((rows) > threshold))) && ((MagickSizeType) \
- (columns*rows) > (threshold*threshold)) && (expression)) \
+#define dynamic_num_threads_tres(columns,rows,expression) \
+ if (((((columns) > MinimumWorkLoad()) || \
+ ((rows) > MinimumWorkLoad()))) && ((MagickSizeType) \
+ ((columns)*(rows)) > (MinimumWorkLoad()*MinimumWorkLoad())) && \
+ (expression)) \
num_threads(GetMagickResourceLimit(ThreadResource))
#if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR > 10))
threshold_view=AcquireAuthenticCacheView(threshold_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status) \
- IsConcurrentTres(image->columns,image->rows,key == ~0UL,64)
+ dynamic_num_threads_tres(image->columns,image->rows,key == ~0UL)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
chop_view=AcquireAuthenticCacheView(chop_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) extent.y; y++)
{
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) (image->rows-(extent.y+extent.height)); y++)
{
crop_view=AcquireAuthenticCacheView(crop_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) crop_image->rows; y++)
{
excerpt_view=AcquireAuthenticCacheView(excerpt_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) excerpt_image->rows; y++)
{
flip_view=AcquireAuthenticCacheView(flip_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) flip_image->rows; y++)
{
flop_view=AcquireAuthenticCacheView(flop_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) flop_image->rows; y++)
{
destination_view=AcquireAuthenticCacheView(destination,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(status) \
- IsConcurrentDos(columns,rows,64)
+ dynamic_num_threads_dos(columns,rows)
#endif
for (y=0; y < (ssize_t) rows; y++)
{
splice_view=AcquireAuthenticCacheView(splice_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) splice_geometry.y; y++)
{
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=(ssize_t) (splice_geometry.y+splice_geometry.height);
y < (ssize_t) splice_image->rows; y++)
transpose_view=AcquireAuthenticCacheView(transpose_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
transverse_view=AcquireAuthenticCacheView(transverse_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
#define MagickLibAddendum "-0"
#define MagickLibInterface 7
#define MagickLibMinInterface 7
-#define MagickReleaseDate "2012-05-06"
+#define MagickReleaseDate "2012-05-07"
#define MagickChangeDate "20110801"
#define MagickAuthoritativeURL "http://www.imagemagick.org"
#if defined(MAGICKCORE_OPENMP_SUPPORT)
width=source->extent.width-source->extent.x;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
{
width=source->extent.width-source->extent.x;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
{
width=destination->extent.width-destination->extent.x;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=destination->extent.y; y < (ssize_t) destination->extent.height; y++)
{
width=source->extent.width-source->extent.x;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
{
width=source->extent.width-source->extent.x;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static) shared(progress,status) \
- IsConcurrentDos(width,height,64)
+ dynamic_num_threads_dos(width,height)
#endif
for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
{
image->rows=(size_t) (level*cube_size);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,8) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y+=(ssize_t) level)
{
if (CellType==miUINT8 && z!=3)
{
- if(image->colors>256) image->colors = 256;
+ if(image->colors > 256) image->colors = 256;
if (AcquireImageColormap(image, image->colors,exception) == MagickFalse)
{
<name>ImageMagick</name>
<shortdesc xml:lang="en">ImageMagick: convert, edit, and compose images.</shortdesc>
<homepage rdf:resource="http://www.imagemagick.org/"/>
- <created>2012-05-06</created>
+ <created>2012-05-07</created>
<description xml:lang="en">
ImageMagick® is a software suite to create, edit, compose, or convert bitmap images. It can read and write images in a variety of formats (over 100) including DPX, EXR, GIF, JPEG, JPEG-2000, PDF, PhotoCD, PNG, Postscript, SVG, and TIFF. Use ImageMagick to resize, flip, mirror, rotate, distort, shear and transform images, adjust image colors, apply various special effects, or draw text, lines, polygons, ellipses and Bézier curves.
<release>
<Version>
<name>stable</name>
- <created>2012-05-06</created>
+ <created>2012-05-07</created>
<revision>7.0.0</revision>
<patch-level>-0</patch-level>
</Version>
<configure name="LIB_VERSION" value="0x700"/>
<configure name="LIB_VERSION_NUMBER" value="7,0,0,0"/>
<configure name="SVN_REVISION" value="7561" />
- <configure name="RELEASE_DATE" value="2012-05-06"/>
+ <configure name="RELEASE_DATE" value="2012-05-07"/>
<configure name="CONFIGURE" value="./configure "/>
<configure name="PREFIX" value="/usr/local"/>
<configure name="EXEC-PREFIX" value="/usr/local"/>
image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- IsConcurrentDos(image->columns,image->rows,64)
+ dynamic_num_threads_dos(image->columns,image->rows)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{