void UArray_setEncoding_(UArray *self, CENCODING encoding)
{
// ensure that size matches new encoding
switch(encoding)
{
case CENCODING_ASCII:
case CENCODING_UTF8:
UArray_setItemType_(self, CTYPE_uint8_t);
break;
case CENCODING_UCS2:
UArray_setItemType_(self, CTYPE_uint16_t);
break;
case CENCODING_UCS4:
UArray_setItemType_(self, CTYPE_uint32_t);
break;
case CENCODING_NUMBER:
// Don't change itemType when setting raw encoding. Raw encoding
// used for vectors and numbers and the item type may have been set
// before this call.
break;
}
self->encoding = encoding;
}
IoObject *IoODEMass_parameters(IoODEMass *self, IoObject *locals, IoMessage *m)
{
// vector(theMass, cgx, cgy, cgz, I11, I22, I33, I12, I13, I23)
UArray *u = UArray_new();
int i, j = 0;
UArray_setItemType_(u, CTYPE_float32_t);
UArray_setSize_(u, 10);
UArray_at_putDouble_(u, j++, DATA(self)->mass);
for(i=0; i < 3; i++)
{
UArray_at_putDouble_(u, j++, DATA(self)->c[i]);
}
// 0 1 2 3 4 5 6 7 8 9 10 11
// I == vector(I11, I12, I13, _, I12, I22, I23, _, I13, I23, I33, _)
UArray_at_putDouble_(u, j++, DATA(self)->I[0 ]); // I11
UArray_at_putDouble_(u, j++, DATA(self)->I[5 ]); // I22
UArray_at_putDouble_(u, j++, DATA(self)->I[10]); // I33
UArray_at_putDouble_(u, j++, DATA(self)->I[1 ]); // I12
UArray_at_putDouble_(u, j++, DATA(self)->I[2 ]); // I13
UArray_at_putDouble_(u, j++, DATA(self)->I[6 ]); // I23
return IoSeq_newWithUArray_copy_(IOSTATE, u, 1);
}
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;
}
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;
}
IoRegexMatches *IoRegexMatches_proto(void *state)
{
IoObject *self = IoObject_new(state);
IoObject_tag_(self, IoRegexMatches_newTag(state));
IoObject_setDataPointer_(self, calloc(1, sizeof(IoRegexMatchesData)));
DATA(self)->regex = IONIL(self);
DATA(self)->string = IOSYMBOL("");
DATA(self)->captureArray = UArray_new();
UArray_setItemType_(DATA(self)->captureArray, CTYPE_uint32_t);
IoState_registerProtoWithId_(state, self, protoId);
{
IoMethodTable methodTable[] = {
{"setRegex", IoRegexMatches_setRegex},
{"regex", IoRegexMatches_regex},
{"setString", IoRegexMatches_setString},
{"string", IoRegexMatches_string},
{"setPosition", IoRegexMatches_setPosition},
{"position", IoRegexMatches_position},
{"setEndPosition", IoRegexMatches_setEndPosition},
{"endPosition", IoRegexMatches_endPosition},
{"next", IoRegexMatches_next},
{"anchored", IoRegexMatches_anchored},
{"allowEmptyMatches", IoRegexMatches_allowEmptyMatches},
{"disallowEmptyMatches", IoRegexMatches_disallowEmptyMatches},
{"allowsEmptyMatches", IoRegexMatches_allowsEmptyMatches},
{0, 0},
};
IoObject_addMethodTable_(self, methodTable);
}
return self;
}
IoObject *IoODEMass_inertiaTensor(IoODEMass *self, IoObject *locals, IoMessage *m)
{
UArray *u = UArray_new();
int i, j;
UArray_setItemType_(u, CTYPE_float32_t);
UArray_setSize_(u, 9);
// I == vector(I11, I12, I13, _, I12, I22, I23, _, I13, I23, I33, _)
for(i = 0, j = 0; i < 12; i++)
{
if ((i + 1) % 4)
{
UArray_at_putDouble_(u, j++, DATA(self)->I[i]);
}
}
return IoSeq_newWithUArray_copy_(IOSTATE, u, 1);
}
IoDate *IoDate_fromSerialization(IoDate *self, IoObject *locals, IoMessage *m)
{
/*doc Date fromSerialization
Sets the date based on the serialization sequence. Return self.
*/
IoSeq *serializationSeq = IoMessage_locals_seqArgAt_(m, locals, 0);
UArray *serialization = UArray_clone(IoSeq_rawUArray(serializationSeq));
UArray_setItemType_(serialization, CTYPE_int32_t);
if(UArray_size(serialization) != 4)
{
IoState_error_(IOSTATE, self, "Expected a serialization sequence comprising 4 int32 items.");
}
Date_fromSerialization(DATA(self), serialization);
UArray_free(serialization);
return self;
}
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 *IoBox_rawResizeBy(IoBox *self,
UArray *d,
int resizeWidth, int resizeHeight,
UArray *minSize, UArray *maxSize)
{
double x, w, y, h;
UArray *position = IoSeq_rawUArray(IoBox_rawOrigin(self));
UArray *size = IoSeq_rawUArray(IoBox_rawSize(self));
UArray *outd = UArray_new();
UArray_setItemType_(outd, CTYPE_float32_t);
UArray_setSize_(outd, 2);
x = resizeXFunc(resizeWidth, UArray_x(d), UArray_x(position));
w = resizeWFunc(resizeWidth, UArray_x(d), UArray_x(size));
y = resizeXFunc(resizeHeight, UArray_y(d), UArray_y(position));
h = resizeWFunc(resizeHeight, UArray_y(d), UArray_y(size));
if (minSize)
{
w = max(w, UArray_x(minSize));
h = max(h, UArray_y(minSize));
}
if (maxSize)
{
w = min(w, UArray_x(maxSize));
h = min(h, UArray_y(maxSize));
}
UArray_setXY(outd, w - UArray_x(size), h - UArray_y(size));
UArray_setXY(position, x, y);
UArray_setXY(size, w, h);
UArray_round(position);
UArray_round(size);
return outd;
}
void UArray_convertToEncoding_(UArray *self, CENCODING encoding)
{
switch(encoding)
{
case CENCODING_ASCII:
case CENCODING_UTF8:
UArray_convertToUTF8(self);
break;
case CENCODING_UCS2:
UArray_convertToUCS2(self);
break;
case CENCODING_UCS4:
UArray_convertToUCS4(self);
break;
case CENCODING_NUMBER:
UArray_setItemType_(self, CTYPE_uint8_t);
break;
}
self->encoding = encoding;
UArray_changed(self);
}
IO_METHOD(IoSeq, setItemType)
{
/*doc Sequence setItemType(aTypeName)
Sets the underlying machine type for the elements.
Valid names are uint8, uint16, uint32, uint64, int8, int16, int32,
int64, float32, and float64. Note that 64 bit types are only available
on platforms that support such types. Returns self.
*/
CTYPE itemType;
IoSeq *typeName;
IO_ASSERT_NOT_SYMBOL(self);
typeName = IoMessage_locals_symbolArgAt_(m, locals, 0);
itemType = CTYPE_forName(CSTRING(typeName));
IOASSERT(itemType != -1, "invalid item type name");
UArray_setItemType_(DATA(self), itemType);
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;
}
