summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/im_process.def3
-rw-r--r--src/lua5/im_process.lua3
-rw-r--r--src/lua5/imlua_process.c56
-rw-r--r--src/process/im_arithmetic_bin.cpp98
-rw-r--r--src/process/im_arithmetic_un.cpp64
-rw-r--r--src/process/im_convolve.cpp190
6 files changed, 342 insertions, 72 deletions
diff --git a/src/im_process.def b/src/im_process.def
index fd3d5dd..07bba47 100644
--- a/src/im_process.def
+++ b/src/im_process.def
@@ -160,3 +160,6 @@ EXPORTS
imProcessRotateRef
imProcessInterlaceSplit
imProcessBarlettConvolve
+ imProcessUnsharp
+ imProcessSharp
+ imProcessSharpKernel
diff --git a/src/lua5/im_process.lua b/src/lua5/im_process.lua
index eb9cae6..d74c6b1 100644
--- a/src/lua5/im_process.lua
+++ b/src/lua5/im_process.lua
@@ -243,6 +243,9 @@ OneSourceOneDest("ProcessZeroCrossing")
OneSourceOneDest("ProcessCanny")
OneSourceOneDest("ProcessUnArithmeticOp")
TwoSourcesOneDest("ProcessArithmeticOp")
+OneSourceOneDest("ProcessUnsharp")
+OneSourceOneDest("ProcessSharp")
+TwoSourcesOneDest("ProcessSharpKernel")
function im.ProcessArithmeticConstOpNew (src_image, src_const, op)
local dst_image = im.ImageCreateBased(src_image)
diff --git a/src/lua5/imlua_process.c b/src/lua5/imlua_process.c
index fa6dc89..863c1d6 100644
--- a/src/lua5/imlua_process.c
+++ b/src/lua5/imlua_process.c
@@ -2,7 +2,7 @@
* \brief IM Lua 5 Binding
*
* See Copyright Notice in im_lib.h
- * $Id: imlua_process.c,v 1.7 2009/09/28 20:19:09 scuri Exp $
+ * $Id: imlua_process.c,v 1.8 2009/10/01 02:56:58 scuri Exp $
*/
#include <memory.h>
@@ -1475,6 +1475,56 @@ static int imluaProcessCanny (lua_State *L)
}
/*****************************************************************************\
+ im.ProcessUnsharp
+\*****************************************************************************/
+static int imluaProcessUnsharp(lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float p1 = (float)luaL_checknumber(L, 3);
+ float p2 = (float)luaL_checknumber(L, 4);
+ float p3 = (float)luaL_checknumber(L, 5);
+
+ imlua_match(L, src_image, dst_image);
+
+ imProcessUnsharp(src_image, dst_image, p1, p2, p3);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessSharp
+\*****************************************************************************/
+static int imluaProcessSharp(lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float p1 = (float)luaL_checknumber(L, 3);
+ float p2 = (float)luaL_checknumber(L, 4);
+
+ imlua_match(L, src_image, dst_image);
+
+ imProcessSharp(src_image, dst_image, p1, p2);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessSharpKernel
+\*****************************************************************************/
+static int imluaProcessSharpKernel(lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *kernel = imlua_checkimage(L, 2);
+ imImage *dst_image = imlua_checkimage(L, 3);
+ float p1 = (float)luaL_checknumber(L, 4);
+ float p2 = (float)luaL_checknumber(L, 5);
+
+ imlua_match(L, src_image, dst_image);
+
+ imProcessSharpKernel(src_image, kernel, dst_image, p1, p2);
+ return 0;
+}
+
+/*****************************************************************************\
im.GaussianStdDev2Repetitions
\*****************************************************************************/
static int imluaGaussianKernelSize2StdDev(lua_State *L)
@@ -2927,6 +2977,9 @@ static const luaL_reg improcess_lib[] = {
{"ProcessSplineEdgeConvolve", imluaProcessSplineEdgeConvolve},
{"ProcessZeroCrossing", imluaProcessZeroCrossing},
{"ProcessCanny", imluaProcessCanny},
+ {"ProcessUnsharp", imluaProcessUnsharp},
+ {"ProcessSharp", imluaProcessSharp},
+ {"ProcessSharpKernel", imluaProcessSharpKernel},
{"GaussianKernelSize2StdDev", imluaGaussianKernelSize2StdDev},
{"GaussianStdDev2KernelSize", imluaGaussianStdDev2KernelSize},
@@ -3013,7 +3066,6 @@ static const imlua_constant im_process_constants[] = {
{ "UN_EQL", IM_UN_EQL, NULL },
{ "UN_ABS", IM_UN_ABS, NULL },
{ "UN_LESS", IM_UN_LESS, NULL },
- { "UN_INC", IM_UN_INC, NULL },
{ "UN_INV", IM_UN_INV, NULL },
{ "UN_SQR", IM_UN_SQR, NULL },
{ "UN_SQRT", IM_UN_SQRT, NULL },
diff --git a/src/process/im_arithmetic_bin.cpp b/src/process/im_arithmetic_bin.cpp
index 74fe010..494b6c0 100644
--- a/src/process/im_arithmetic_bin.cpp
+++ b/src/process/im_arithmetic_bin.cpp
@@ -2,7 +2,7 @@
* \brief Binary Arithmetic Operations
*
* See Copyright Notice in im_lib.h
- * $Id: im_arithmetic_bin.cpp,v 1.1 2008/10/17 06:16:33 scuri Exp $
+ * $Id: im_arithmetic_bin.cpp,v 1.2 2009/10/01 02:56:58 scuri Exp $
*/
@@ -61,6 +61,47 @@ static void DoBinaryOp(T1 *map1, T2 *map2, T3 *map, int count, int op)
}
}
+static void DoBinaryOpByte(imbyte *map1, imbyte *map2, imbyte *map, int count, int op)
+{
+ int i;
+
+ switch(op)
+ {
+ case IM_BIN_ADD:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(add_op((int)map1[i], (int)map2[i]));
+ break;
+ case IM_BIN_SUB:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(sub_op((int)map1[i], (int)map2[i]));
+ break;
+ case IM_BIN_MUL:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(mul_op((int)map1[i], (int)map2[i]));
+ break;
+ case IM_BIN_DIV:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(div_op((int)map1[i], (int)map2[i]));
+ break;
+ case IM_BIN_DIFF:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(diff_op((int)map1[i], (int)map2[i]));
+ break;
+ case IM_BIN_MIN:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(min_op((int)map1[i], (int)map2[i]));
+ break;
+ case IM_BIN_MAX:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(max_op((int)map1[i], (int)map2[i]));
+ break;
+ case IM_BIN_POW:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(pow_op((int)map1[i], (int)map2[i]));
+ break;
+ }
+}
+
static void DoBinaryOpCpxReal(imcfloat *map1, float *map2, imcfloat *map, int count, int op)
{
int i;
@@ -118,7 +159,7 @@ void imProcessArithmeticOp(const imImage* src_image1, const imImage* src_image2,
else if (dst_image->data_type == IM_INT)
DoBinaryOp((imbyte*)src_image1->data[i], (imbyte*)src_image2->data[i], (int*)dst_image->data[i], count, op);
else
- DoBinaryOp((imbyte*)src_image1->data[i], (imbyte*)src_image2->data[i], (imbyte*)dst_image->data[i], count, op);
+ DoBinaryOpByte((imbyte*)src_image1->data[i], (imbyte*)src_image2->data[i], (imbyte*)dst_image->data[i], count, op);
break;
case IM_USHORT:
if (dst_image->data_type == IM_FLOAT)
@@ -304,6 +345,48 @@ static void DoBinaryConstOp(T1 *map1, T2 value, T3 *map, int count, int op)
}
}
+template <class T1>
+static void DoBinaryConstOpByte(T1 *map1, int value, imbyte *map, int count, int op)
+{
+ int i;
+
+ switch(op)
+ {
+ case IM_BIN_ADD:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(add_op((int)map1[i], value));
+ break;
+ case IM_BIN_SUB:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(sub_op((int)map1[i], value));
+ break;
+ case IM_BIN_MUL:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(mul_op((int)map1[i], value));
+ break;
+ case IM_BIN_DIV:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(div_op((int)map1[i], value));
+ break;
+ case IM_BIN_DIFF:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(diff_op((int)map1[i], value));
+ break;
+ case IM_BIN_MIN:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(min_op((int)map1[i], value));
+ break;
+ case IM_BIN_MAX:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(max_op((int)map1[i], value));
+ break;
+ case IM_BIN_POW:
+ for (i = 0; i < count; i++)
+ map[i] = (imbyte)crop_byte(pow_op((int)map1[i], value));
+ break;
+ }
+}
+
void imProcessArithmeticConstOp(const imImage* src_image1, float value, imImage* dst_image, int op)
{
int count = src_image1->count;
@@ -320,7 +403,7 @@ void imProcessArithmeticConstOp(const imImage* src_image1, float value, imImage*
else if (dst_image->data_type == IM_INT)
DoBinaryConstOp((imbyte*)src_image1->data[i], (int)value, (int*)dst_image->data[i], count, op);
else
- DoBinaryConstOp((imbyte*)src_image1->data[i], (imushort)value, (imbyte*)dst_image->data[i], count, op);
+ DoBinaryConstOpByte((imbyte*)src_image1->data[i], (int)value, (imbyte*)dst_image->data[i], count, op);
break;
case IM_USHORT:
if (dst_image->data_type == IM_FLOAT)
@@ -328,7 +411,7 @@ void imProcessArithmeticConstOp(const imImage* src_image1, float value, imImage*
else if (dst_image->data_type == IM_INT)
DoBinaryConstOp((imushort*)src_image1->data[i], (int)value, (int*)dst_image->data[i], count, op);
else if (dst_image->data_type == IM_BYTE)
- DoBinaryConstOp((imushort*)src_image1->data[i], (imushort)value, (imbyte*)dst_image->data[i], count, op);
+ DoBinaryConstOpByte((imushort*)src_image1->data[i], (int)value, (imbyte*)dst_image->data[i], count, op);
else
DoBinaryConstOp((imushort*)src_image1->data[i], (imushort)value, (imushort*)dst_image->data[i], count, op);
break;
@@ -338,7 +421,7 @@ void imProcessArithmeticConstOp(const imImage* src_image1, float value, imImage*
else if (dst_image->data_type == IM_USHORT)
DoBinaryConstOp((int*)src_image1->data[i], (int)value, (imushort*)dst_image->data[i], count, op);
else if (dst_image->data_type == IM_BYTE)
- DoBinaryConstOp((int*)src_image1->data[i], (int)value, (imbyte*)dst_image->data[i], count, op);
+ DoBinaryConstOpByte((int*)src_image1->data[i], (int)value, (imbyte*)dst_image->data[i], count, op);
else
DoBinaryConstOp((int*)src_image1->data[i], (int)value, (int*)dst_image->data[i], count, op);
break;
@@ -367,7 +450,8 @@ void imProcessMultipleMean(const imImage** src_image_list, int src_image_count,
for(int i = 0; i < src_image_count; i++)
{
const imImage *image = src_image_list[i];
- imProcessUnArithmeticOp(image, acum_image, IM_UN_INC);
+ imProcessArithmeticOp(image, acum_image, acum_image, IM_BIN_ADD); /* acum_image += image */
+
}
imProcessArithmeticConstOp(acum_image, float(src_image_count), dst_image, IM_BIN_DIV);
@@ -393,7 +477,7 @@ void imProcessMultipleStdDev(const imImage** src_image_list, int src_image_count
imProcessUnArithmeticOp(aux_image, aux_image, IM_UN_SQR);
// dst_image += aux_image
- imProcessUnArithmeticOp(aux_image, dst_image, IM_UN_INC);
+ imProcessArithmeticOp(aux_image, dst_image, dst_image, IM_BIN_ADD);
}
// dst_image = dst_image / src_image_count;
diff --git a/src/process/im_arithmetic_un.cpp b/src/process/im_arithmetic_un.cpp
index 59e384c..e4dba8a 100644
--- a/src/process/im_arithmetic_un.cpp
+++ b/src/process/im_arithmetic_un.cpp
@@ -2,7 +2,7 @@
* \brief Unary Arithmetic Operations
*
* See Copyright Notice in im_lib.h
- * $Id: im_arithmetic_un.cpp,v 1.1 2008/10/17 06:16:33 scuri Exp $
+ * $Id: im_arithmetic_un.cpp,v 1.2 2009/10/01 02:56:58 scuri Exp $
*/
@@ -71,10 +71,6 @@ static void DoUnaryOp(T1 *map, T2 *new_map, int count, int op)
for (i = 0; i < count; i++)
new_map[i] = (T2)map[i];
break;
- case IM_UN_INC:
- for (i = 0; i < count; i++)
- new_map[i] = (T2)(new_map[i] + map[i]);
- break;
case IM_UN_LESS:
for (i = 0; i < count; i++)
new_map[i] = less_op((T2)map[i]);
@@ -85,7 +81,7 @@ static void DoUnaryOp(T1 *map, T2 *new_map, int count, int op)
break;
case IM_UN_SQRT:
for (i = 0; i < count; i++)
- new_map[i] = (T2)sqrt_op(map[i]);
+ new_map[i] = sqrt_op((T2)map[i]);
break;
case IM_UN_LOG:
for (i = 0; i < count; i++)
@@ -114,6 +110,56 @@ static void DoUnaryOp(T1 *map, T2 *new_map, int count, int op)
}
}
+template <class T1>
+static void DoUnaryOpByte(T1 *map, imbyte *new_map, int count, int op)
+{
+ int i;
+
+ switch(op)
+ {
+ case IM_UN_ABS:
+ for (i = 0; i < count; i++)
+ new_map[i] = (imbyte)crop_byte(abs_op((int)map[i]));
+ break;
+ case IM_UN_INV:
+ for (i = 0; i < count; i++)
+ new_map[i] = (imbyte)crop_byte(inv_op((int)map[i])); /* will always be 0 */
+ break;
+ case IM_UN_EQL:
+ for (i = 0; i < count; i++)
+ new_map[i] = (imbyte)crop_byte((int)map[i]);
+ break;
+ case IM_UN_LESS:
+ for (i = 0; i < count; i++)
+ new_map[i] = (imbyte)crop_byte(less_op((int)map[i]));
+ break;
+ case IM_UN_SQR:
+ for (i = 0; i < count; i++)
+ new_map[i] = (imbyte)crop_byte(sqr_op((int)map[i]));
+ break;
+ case IM_UN_SQRT:
+ for (i = 0; i < count; i++)
+ new_map[i] = (imbyte)crop_byte(sqrt_op((int)map[i]));
+ break;
+ case IM_UN_LOG:
+ for (i = 0; i < count; i++)
+ new_map[i] = (imbyte)crop_byte(log_op((int)map[i]));
+ break;
+ case IM_UN_SIN:
+ for (i = 0; i < count; i++)
+ new_map[i] = (imbyte)crop_byte(sin_op((int)map[i]));
+ break;
+ case IM_UN_COS:
+ for (i = 0; i < count; i++)
+ new_map[i] = (imbyte)crop_byte(cos_op((int)map[i]));
+ break;
+ case IM_UN_EXP:
+ for (i = 0; i < count; i++)
+ new_map[i] = (imbyte)crop_byte(exp_op((int)map[i]));
+ break;
+ }
+}
+
void imProcessUnArithmeticOp(const imImage* src_image, imImage* dst_image, int op)
{
int total_count = src_image->count * src_image->depth;
@@ -128,11 +174,11 @@ void imProcessUnArithmeticOp(const imImage* src_image, imImage* dst_image, int o
else if (dst_image->data_type == IM_USHORT)
DoUnaryOp((imbyte*)src_image->data[0], (imushort*)dst_image->data[0], total_count, op);
else
- DoUnaryOp((imbyte*)src_image->data[0], (imbyte*)dst_image->data[0], total_count, op);
+ DoUnaryOpByte((imbyte*)src_image->data[0], (imbyte*)dst_image->data[0], total_count, op);
break;
case IM_USHORT:
if (dst_image->data_type == IM_BYTE)
- DoUnaryOp((imushort*)src_image->data[0], (imbyte*)dst_image->data[0], total_count, op);
+ DoUnaryOpByte((imushort*)src_image->data[0], (imbyte*)dst_image->data[0], total_count, op);
else if (dst_image->data_type == IM_INT)
DoUnaryOp((imushort*)src_image->data[0], (int*)dst_image->data[0], total_count, op);
else if (dst_image->data_type == IM_FLOAT)
@@ -142,7 +188,7 @@ void imProcessUnArithmeticOp(const imImage* src_image, imImage* dst_image, int o
break;
case IM_INT:
if (dst_image->data_type == IM_BYTE)
- DoUnaryOp((int*)src_image->data[0], (imbyte*)dst_image->data[0], total_count, op);
+ DoUnaryOpByte((int*)src_image->data[0], (imbyte*)dst_image->data[0], total_count, op);
else if (dst_image->data_type == IM_USHORT)
DoUnaryOp((int*)src_image->data[0], (imushort*)dst_image->data[0], total_count, op);
else if (dst_image->data_type == IM_FLOAT)
diff --git a/src/process/im_convolve.cpp b/src/process/im_convolve.cpp
index bca2dcd..a88a25c 100644
--- a/src/process/im_convolve.cpp
+++ b/src/process/im_convolve.cpp
@@ -2,7 +2,7 @@
* \brief Convolution Operations
*
* See Copyright Notice in im_lib.h
- * $Id: im_convolve.cpp,v 1.1 2008/10/17 06:16:33 scuri Exp $
+ * $Id: im_convolve.cpp,v 1.2 2009/10/01 02:56:58 scuri Exp $
*/
@@ -1426,59 +1426,6 @@ int imProcessDiffOfGaussianConvolve(const imImage* src_image, imImage* dst_image
return 1;
}
-#ifdef _TEST_CODE_
-int imProcessDiffOfGaussianConvolveTEST(const imImage* src_image, imImage* dst_image, float stddev1, float stddev2)
-{
- int kernel_size1 = imGaussianStdDev2KernelSize(stddev1);
- int kernel_size2 = imGaussianStdDev2KernelSize(stddev2);
- int size = kernel_size1;
- if (kernel_size1 < kernel_size2) size = kernel_size2;
-
- imImage* kernel1 = imImageCreate(size, size, IM_GRAY, IM_FLOAT);
- imImage* kernel2 = imImageCreate(size, size, IM_GRAY, IM_FLOAT);
- if (!kernel1 || !kernel2)
- {
- if (kernel1) imImageDestroy(kernel1);
- if (kernel2) imImageDestroy(kernel2);
- return 0;
- }
-
- imImageSetAttribute(kernel1, "Description", IM_BYTE, -1, (void*)"Gaussian");
- imImageSetAttribute(kernel2, "Description", IM_BYTE, -1, (void*)"Gaussian");
-
- imProcessRenderGaussian(kernel1, stddev1);
- imProcessRenderGaussian(kernel2, stddev2);
-
- // ERROR: kernel 1 should be multiplied by a factor to improve the difference.
-
- imProcessArithmeticOp(kernel1, kernel2, kernel1, IM_BIN_SUB);
- imImageSetAttribute(kernel1, "Description", IM_BYTE, -1, (void*)"Difference of Gaussian");
-
- int ret = 0;
- if (src_image->data_type == IM_BYTE || src_image->data_type == IM_USHORT)
- {
- imImage* aux_image = imImageClone(dst_image);
- if (!aux_image)
- {
- imImageDestroy(kernel1);
- imImageDestroy(kernel2);
- return 0;
- }
-
- imProcessUnArithmeticOp(src_image, aux_image, IM_UN_EQL); // Convert to IM_INT
- ret = imProcessConvolve(aux_image, dst_image, kernel1);
- imImageDestroy(aux_image);
- }
- else
- ret = imProcessConvolve(src_image, dst_image, kernel1);
-
- imImageDestroy(kernel1);
- imImageDestroy(kernel2);
-
- return ret;
-}
-#endif
-
int imProcessMeanConvolve(const imImage* src_image, imImage* dst_image, int ks)
{
int counter = imCounterBegin("Mean Convolve");
@@ -1510,3 +1457,138 @@ int imProcessMeanConvolve(const imImage* src_image, imImage* dst_image, int ks)
return ret;
}
+
+template <class T1, class T2>
+static void DoSharpOp(T1 *src_map, T1 *dst_map, int count, float amount, T2 threshold, int gauss)
+{
+ int i;
+ T1 min, max;
+
+ int size_of = sizeof(imbyte);
+ if (sizeof(T1) == size_of)
+ {
+ min = 0;
+ max = 255;
+ }
+ else
+ {
+ imMinMax(src_map, count, min, max);
+
+ if (min == max)
+ {
+ max = min + 1;
+
+ if (min != 0)
+ min = min - 1;
+ }
+ }
+
+ for (i = 0; i < count; i++)
+ {
+ T2 diff;
+
+ if (gauss)
+ diff = 20*(src_map[i] - dst_map[i]); /* dst_map contains a gaussian filter of the source image, must compensate for small edge values */
+ else
+ diff = dst_map[i]; /* dst_map contains a laplacian filter of the source image */
+
+ if (threshold && abs_op(2*diff) < threshold)
+ diff = 0;
+
+ T2 value = (T2)(src_map[i] + amount*diff);
+ if (value < min)
+ value = min;
+ else if (value > max)
+ value = max;
+
+ dst_map[i] = (T1)value;
+ }
+}
+
+static void doSharp(const imImage* src_image, imImage* dst_image, float amount, float threshold, int gauss)
+{
+ int count = src_image->count;
+
+ for (int i = 0; i < src_image->depth; i++)
+ {
+ switch(src_image->data_type)
+ {
+ case IM_BYTE:
+ DoSharpOp((imbyte*)src_image->data[i], (imbyte*)dst_image->data[i], count, amount, (int)threshold, gauss);
+ break;
+ case IM_USHORT:
+ DoSharpOp((imushort*)src_image->data[i], (imushort*)dst_image->data[i], count, amount, (int)threshold, gauss);
+ break;
+ case IM_INT:
+ DoSharpOp((int*)src_image->data[i], (int*)dst_image->data[i], count, amount, (int)threshold, gauss);
+ break;
+ case IM_FLOAT:
+ DoSharpOp((float*)src_image->data[i], (float*)dst_image->data[i], count, amount, (float)threshold, gauss);
+ break;
+ }
+ }
+}
+
+int imProcessUnsharp(const imImage* src_image, imImage* dst_image, float stddev, float amount, float threshold)
+{
+ int kernel_size = imGaussianStdDev2KernelSize(stddev);
+
+ imImage* kernel = imImageCreate(kernel_size, kernel_size, IM_GRAY, IM_FLOAT);
+ if (!kernel)
+ return 0;
+
+ imImageSetAttribute(kernel, "Description", IM_BYTE, -1, (void*)"Unsharp");
+ imProcessRenderGaussian(kernel, stddev);
+
+ int ret = imProcessConvolveSep(src_image, dst_image, kernel);
+ doSharp(src_image, dst_image, amount, threshold, 1);
+
+ imImageDestroy(kernel);
+
+ return ret;
+}
+
+int imProcessSharp(const imImage* src_image, imImage* dst_image, float amount, float threshold)
+{
+ imImage* kernel = imKernelLaplacian8();
+ if (!kernel)
+ return 0;
+
+ int ret = imProcessConvolve(src_image, dst_image, kernel);
+ doSharp(src_image, dst_image, amount, threshold, 0);
+
+ imImageDestroy(kernel);
+
+ return ret;
+}
+
+static int iProcessCheckKernelType(const imImage* kernel)
+{
+ if (kernel->data_type == IM_INT)
+ {
+ int* kernel_data = (int*)kernel->data[0];
+ for (int i = 0; i < kernel->count; i++)
+ {
+ if (kernel_data[i] < 0) /* if there are negative values, assume kernel is an edge detector */
+ return 0;
+ }
+ }
+ else if (kernel->data_type == IM_FLOAT)
+ {
+ float* kernel_data = (float*)kernel->data[0];
+ for (int i = 0; i < kernel->count; i++)
+ {
+ if (kernel_data[i] < 0) /* if there are negative values, assume kernel is an edge detector */
+ return 0;
+ }
+ }
+ return 1; /* default is kernel is a smooth filter */
+}
+
+int imProcessSharpKernel(const imImage* src_image, const imImage* kernel, imImage* dst_image, float amount, float threshold)
+{
+ int ret = imProcessConvolve(src_image, dst_image, kernel);
+ doSharp(src_image, dst_image, amount, threshold, iProcessCheckKernelType(kernel));
+ return ret;
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-22 11:31:08 +0000