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; }