IOIMAGE_API IoObject *IoImage_filterGauss(IoImage *self, IoObject *locals, IoMessage *m)
{
/*doc Image filterGauss(sigma)
Returns new image as a result of applying filter. Implements Gauss smoothing filtering with parameter sigma.
*/
double sigma = IoMessage_locals_doubleArgAt_(m, locals, 0);
int filterSize = round(sigma * 2.5) * 2 + 1;
UArray* filter = UArray_new();
UArray_setItemType_(filter, CTYPE_int8_t);
UArray_setEncoding_(filter, CENCODING_NUMBER);
UArray_setSize_(filter, filterSize * filterSize);
int8_t *filterBytes = UArray_mutableBytes(filter);
int x, y, x1, y1;
for(y = 0; y < filterSize; y++)
{
y1 = y - filterSize / 2;
for(x = 0; x < filterSize; x++)
{
x1 = x - filterSize / 2;
filterBytes[x + y * filterSize] = exp(-(x1*x1 + y1*y1)/2/sigma) * filterSize * filterSize * 2;
}
}
IoImage* toReturn = IoImage_newWithImage_(IOSTATE, Image_applyLinearFilter(DATA(self)->image, filterSize, filterSize, filter));
UArray_free(filter);
return toReturn;
}
IoSymbol *IoState_symbolWithCString_length_(IoState *self, const char *s, size_t length)
{
UArray *a = UArray_newWithData_type_size_copy_((char *)s, CTYPE_uint8_t, length, 1);
UArray_setEncoding_(a, CENCODING_UTF8);
UArray_convertToFixedSizeType(a);
return IoState_symbolWithUArray_copy_(self, a, 0);
}
IO_METHOD(IoNumber, asCharacter)
{
/*doc Number asCharacter
Returns a String containing a single character whose
value is the value of the first byte of the receiver.
Returns nil if the number has no valid UCS mapping.
*/
double d =DATA(self);
long ld = d;
if (d < 0 || d != ld)
{
return IONIL(self);
}
else
{
uint32_t i = io_uint32InBigEndian((uint32_t)d);
int bytes = countBytes(ld);
IoSeq *s;
if (bytes == 0)
{
bytes = 1;
}
if (bytes == 3)
{
bytes = 4;
}
if (bytes > 4)
{
// no valid UCS encoding for this value
return IONIL(self);
}
s = IoSeq_newWithData_length_(IOSTATE, (unsigned char *)&i, bytes);
{
UArray *u = IoSeq_rawUArray(s);
int e = CENCODING_ASCII;
switch (bytes)
{
case 1: e = CENCODING_ASCII; break;
case 2: e = CENCODING_UCS2; break;
case 4: e = CENCODING_UCS4; break;
}
UArray_setEncoding_(u, e);
}
return s;
}
}
IOIMAGE_API IoObject *IoImage_filterMedian(IoImage *self, IoObject *locals, IoMessage *m)
{
/*doc Image filterMedian(filterSizeX, filterSizeY)
Returns new image as a result of applying filter.
*/
int filterSizeX = IoMessage_locals_intArgAt_(m, locals, 0);
int filterSizeY = IoMessage_locals_intArgAt_(m, locals, 1);
UArray* filter = UArray_new();
UArray_setItemType_(filter, CTYPE_int8_t);
UArray_setEncoding_(filter, CENCODING_NUMBER);
UArray_setSize_(filter, filterSizeX * filterSizeY);
memset(UArray_mutableBytes(filter), 1, filterSizeX * filterSizeY);
IoImage* toReturn = IoImage_newWithImage_(IOSTATE, Image_applyWeightedMedianFilter(DATA(self)->image, filterSizeX, filterSizeY, filter));
UArray_free(filter);
return toReturn;
}
IoObject *IoRandom_bytes(IoObject *self, IoObject *locals, IoMessage *m)
{
/*doc Random bytes(count)
Returns a Sequence of size count containing random bytes.
*/
size_t i, count = IoMessage_locals_sizetArgAt_(m, locals, 0);
UArray *a;
uint8_t *d = malloc(count);
for(i = 0; i < count; i ++)
{
d[i] = (uint8_t)(RandomGen_randomInt(DATA(self)) & 255);
}
a = UArray_newWithData_type_size_copy_(d, CTYPE_uint8_t, count, 0);
UArray_setEncoding_(a, CENCODING_NUMBER);
return IoSeq_newWithUArray_copy_(IOSTATE, a, 0);
}
UArray *UArray_asNumberArrayString(const UArray *self)
{
UArray *out = UArray_new();
UArray_setEncoding_(out, CENCODING_ASCII);
UARRAY_INTFOREACH(self, i, v,
char s[128];
if(UArray_isFloatType(self))
{
sprintf(s, "%f", (double)v);
}
else
{
sprintf(s, "%i", (int)v);
}
if(i != UArray_size(self) -1 ) strcat(s, ", ");
UArray_appendBytes_size_(out, (unsigned char *)s, strlen(s));
);
IOIMAGE_API IoObject *IoImage_filterUnsharpMask(IoImage *self, IoObject *locals, IoMessage *m)
{
/*doc Image filterUnsharpMask(a)
Returns new image as a result of applying filter. Implements unsharp mask filtering.
The result is sharpened image.
The parameter value may by any but it makes sense if it is > 0.
*/
int a = IoMessage_locals_intArgAt_(m, locals, 0);
UArray* filter = UArray_new();
UArray_setItemType_(filter, CTYPE_int8_t);
UArray_setEncoding_(filter, CENCODING_NUMBER);
UArray_setSize_(filter, 9);
int8_t *filterBytes = UArray_mutableBytes(filter);
filterBytes[0] = -1; filterBytes[1] = -1; filterBytes[2] = -1;
filterBytes[3] = -1; filterBytes[4] = a + 8; filterBytes[5] = -1;
filterBytes[6] = -1; filterBytes[7] = -1; filterBytes[8] = -1;
IoImage* toReturn = IoImage_newWithImage_(IOSTATE, Image_applyLinearFilter(DATA(self)->image, 3, 3, filter));
UArray_free(filter);
return toReturn;
}
UArray *IoDirectory_CurrentWorkingDirectoryAsUArray(void)
{
#if defined(sparc) || defined(__sparc)
char *buf = getcwd(NULL, FILENAME_MAX + 1);
#else
char *buf = NULL;
buf = (char *)getcwd(buf, 1024);
#endif /* sparc || _sparc */
if (!buf)
{
return UArray_newWithCString_copy_(".", 1);
}
else
{
UArray *ba = UArray_newWithData_type_size_copy_((unsigned char *)buf, CTYPE_uint8_t, strlen(buf), 1);
UArray_setEncoding_(ba, CENCODING_UTF8);
UArray_convertToFixedSizeType(ba);
// io_free(buf); OSX get cwd man page says we should io_free this, but MallocDebug does not like it
return ba;
}
}
IO_METHOD(IoSeq, setEncoding)
{
/*doc Sequence setEncoding(encodingName)
Sets the encoding flag of the receiver (only the encoding flag,
itemSize and itemType will change, no conversion is done between UTF
encodings - you can use convertToUTF8, etc methods for conversions).
Valid encodings are number, utf8, utf16, and utf32. Returns self.
*/
CENCODING encoding;
IoSeq *encodingName;
IO_ASSERT_NOT_SYMBOL(self);
encodingName = IoMessage_locals_symbolArgAt_(m, locals, 0);
encoding = CENCODING_forName(CSTRING(encodingName));
IOASSERT(encoding != -1, "invalid encoding name");
UArray_setEncoding_(DATA(self), encoding);
IoObject_isDirty_(self, 1);
return self;
}
IOIMAGE_API IoObject *IoImage_filterKirsch(IoImage *self, IoObject *locals, IoMessage *m)
{
/*doc Image filterKirsch(a)
Returns new image as a result of applying Kirsch filter.
The argument denotes direction: 0, 1, 2, ... -> 0, pi / 4, pi / 2, ...
*/
int a = IoMessage_locals_intArgAt_(m, locals, 0);
a = ((a % 8) + 8) % 8;
static int mapOfPixels[8] = {0, 1, 2, 5, 8, 7, 6, 3};
static int contentsOfPixels[8] = {3, 3, 3, 3, -5, -5, -5, 3};
UArray* filter = UArray_new();
UArray_setItemType_(filter, CTYPE_int8_t);
UArray_setEncoding_(filter, CENCODING_NUMBER);
UArray_setSize_(filter, 9);
int8_t *filterBytes = UArray_mutableBytes(filter);
int i;
for(i = 0; i < 8; i++)
{
filterBytes[(i + a) % 8] = contentsOfPixels[i];
}
IoImage* toReturn = IoImage_newWithImage_(IOSTATE, Image_applyLinearFilter(DATA(self)->image, 3, 3, filter));
UArray_free(filter);
return toReturn;
}
