/**
* Calculate the combined advisory minimum size of all components
*
* @return Advisory minimum size for the container
*/
static size2_t minimum_size(__this__)
{
itk_component** children = CONTAINER(this)->children;
long i, n = CONTAINER(this)->children_count;
size2_t rc;
rc.width = rc.height = 0;
rc.defined = true;
for (i = 0; i < n; i++)
if ((*(children + i))->visible)
{
if (rc.width < (*(children + i))->minimum_size.width)
rc.width = (*(children + i))->minimum_size.width;
if (rc.height < (*(children + i))->minimum_size.height)
rc.height = (*(children + i))->minimum_size.height;
}
rc.width += LEFT(this) + RIGHT(this);
rc.height += TOP(this) + BOTTOM(this);
return rc;
}
/**
* Constructor
*
* @param container The container which uses the layout manager
* @param left The size of the left margin
* @param top The size of the top margin
* @param right The size of the right margin
* @param bottom The size of the bottom margin
*/
itk_layout_manager* itk_new_margin_layout(itk_component* container, dimension_t left, dimension_t top, dimension_t right, dimension_t bottom)
{
itk_layout_manager* rc = malloc(sizeof(itk_layout_manager));
dimension_t* margins = malloc(4 * sizeof(dimension_t));
rc->data = malloc(2 * sizeof(void*));
rc->prepare = prepare;
rc->done = done;
rc->locate = locate;
rc->minimum_size = minimum_size;
rc->preferred_size = preferred_size;
rc->maximum_size = maximum_size;
rc->free = free_margin_layout;
CONTAINER_(rc) = container;
MARGINS_(rc) = margins;
LEFT(rc) = left;
TOP(rc) = top;
RIGHT(rc) = right;
BOTTOM(rc) = bottom;
return rc;
}
uint16_t * edges(uint16_t *strip) {
static unsigned int t;
unsigned int i = 0;
for(; LEFT(i); ++i) {
strip[i] = LED_RED;
}
for(; TOP(i); ++i) {
strip[i] = LED_GREEN;
}
for(; RIGHT(i); ++i) {
strip[i] = LED_BLUE;
}
for(; BOTTOM(i); ++i) {
strip[i] = LED_YELLOW;
}
++t;
return strip;
}
/**
* Calculate the combined advisory maximum size of all components
*
* @return Advisory maximum size for the container
*/
static size2_t maximum_size(__this__)
{
itk_component** children = CONTAINER(this)->children;
long i, n = CONTAINER(this)->children_count;
size2_t rc, t;
rc.width = rc.height = UNBOUNDED;
rc.defined = true;
for (i = 0; i < n; i++)
if ((*(children + i))->visible)
{
t = (*(children + i))->maximum_size;
if (((rc.width < 0) || (rc.width > t.width)) && (t.width >= 0))
rc.width = t.width;
if (((rc.height < 0) || (rc.height > t.height)) && (t.height >= 0))
rc.height = t.height;
}
if (rc.width >= 0)
rc.width += LEFT(this) + RIGHT(this);
if (rc.height >= 0)
rc.height += TOP(this) + BOTTOM(this);
return rc;
}
/**
* Locates the positions of the corners of a component
*
* @param child The child, to the component using the layout manager, of interest
* @return The rectangle the child is confound in
*/
static rectangle_t locate(__this__, itk_component* child)
{
if (child->visible)
{
size2_t c = CONTAINER(this)->size;
position_t x = LEFT(this), y = TOP(this);
dimension_t w = c.width - RIGHT(this);
dimension_t h = c.height - BOTTOM(this);
if ((w | h) < 0)
{
w = c.width;
h = c.height;
x = y = 0;
}
return new_rectangle(x, y, w, h);
}
else
{
rectangle_t rc;
rc.defined = false;
return rc;
}
}
static void
mean_curvature_flow (gfloat *src_buf,
gint src_stride,
gfloat *dst_buf,
gint dst_width,
gint dst_height,
gint dst_stride)
{
gint c;
gint x, y;
gfloat *center_pix;
#define O(u,v) (((u)+((v) * src_stride)) * 4)
gint offsets[8] = { O( -1, -1), O(0, -1), O(1, -1),
O( -1, 0), O(1, 0),
O( -1, 1), O(0, 1), O(1, 1)};
#undef O
#define LEFT(c) ((center_pix + offsets[3])[c])
#define RIGHT(c) ((center_pix + offsets[4])[c])
#define TOP(c) ((center_pix + offsets[1])[c])
#define BOTTOM(c) ((center_pix + offsets[6])[c])
#define TOPLEFT(c) ((center_pix + offsets[0])[c])
#define TOPRIGHT(c) ((center_pix + offsets[2])[c])
#define BOTTOMLEFT(c) ((center_pix + offsets[5])[c])
#define BOTTOMRIGHT(c) ((center_pix + offsets[7])[c])
for (y = 0; y < dst_height; y++)
{
gint dst_offset = dst_stride * y;
center_pix = src_buf + ((y+1) * src_stride + 1) * 4;
for (x = 0; x < dst_width; x++)
{
for (c = 0; c < 3; c++) /* do each color component individually */
{
gdouble dx = RIGHT(c) - LEFT(c);
gdouble dy = BOTTOM(c) - TOP(c);
gdouble magnitude = sqrt (POW2(dx) + POW2(dy));
dst_buf[dst_offset * 4 + c] = center_pix[c];
if (magnitude)
{
gdouble dx2 = POW2(dx);
gdouble dy2 = POW2(dy);
gdouble dxx = RIGHT(c) + LEFT(c) - 2. * center_pix[c];
gdouble dyy = BOTTOM(c) + TOP(c) - 2. * center_pix[c];
gdouble dxy = 0.25 * (BOTTOMRIGHT(c) - TOPRIGHT(c) - BOTTOMLEFT(c) + TOPLEFT(c));
gdouble n = dx2 * dyy + dy2 * dxx - 2. * dx * dy * dxy;
gdouble d = sqrt (pow (dx2 + dy2, 3.));
gdouble mean_curvature = n / d;
dst_buf[dst_offset * 4 + c] += (0.25 * magnitude * mean_curvature);
}
}
dst_buf[dst_offset * 4 + 3] = center_pix[3];
dst_offset++;
center_pix += 4;
}
}
#undef LEFT
#undef RIGHT
#undef TOP
#undef BOTTOM
#undef TOPLEFT
#undef TOPRIGHT
#undef BOTTOMLEFT
#undef BOTTOMRIGHT
}
static void *
_malloc_unlocked(size_t size)
{
size_t n;
TREE *tp, *sp;
size_t o_bit1;
COUNT(nmalloc);
ASSERT(WORDSIZE == ALIGN);
/* check for size that could overflow calculations */
if (size > MAX_MALLOC) {
errno = ENOMEM;
return (NULL);
}
/* make sure that size is 0 mod ALIGN */
ROUND(size);
/* see if the last free block can be used */
if (Lfree) {
sp = BLOCK(Lfree);
n = SIZE(sp);
CLRBITS01(n);
if (n == size) {
/*
* exact match, use it as is
*/
freeidx = (freeidx + FREESIZE - 1) &
FREEMASK; /* 1 back */
flist[freeidx] = Lfree = NULL;
return (DATA(sp));
} else if (size >= MINSIZE && n > size) {
/*
* got a big enough piece
*/
freeidx = (freeidx + FREESIZE - 1) &
FREEMASK; /* 1 back */
flist[freeidx] = Lfree = NULL;
o_bit1 = SIZE(sp) & BIT1;
SIZE(sp) = n;
goto leftover;
}
}
o_bit1 = 0;
/* perform free's of space since last malloc */
cleanfree(NULL);
/* small blocks */
if (size < MINSIZE)
return (_smalloc(size));
/* search for an elt of the right size */
sp = NULL;
n = 0;
if (Root) {
tp = Root;
for (;;) {
/* branch left */
if (SIZE(tp) >= size) {
if (n == 0 || n >= SIZE(tp)) {
sp = tp;
n = SIZE(tp);
}
if (LEFT(tp))
tp = LEFT(tp);
else
break;
} else { /* branch right */
if (RIGHT(tp))
tp = RIGHT(tp);
else
break;
}
}
if (sp) {
t_delete(sp);
} else if (tp != Root) {
/* make the searched-to element the root */
t_splay(tp);
Root = tp;
}
}
/* if found none fitted in the tree */
if (!sp) {
if (Bottom && size <= SIZE(Bottom)) {
sp = Bottom;
CLRBITS01(SIZE(sp));
} else if ((sp = _morecore(size)) == NULL) /* no more memory */
return (NULL);
}
/* tell the forward neighbor that we're busy */
CLRBIT1(SIZE(NEXT(sp)));
ASSERT(ISBIT0(SIZE(NEXT(sp))));
leftover:
/* if the leftover is enough for a new free piece */
if ((n = (SIZE(sp) - size)) >= MINSIZE + WORDSIZE) {
n -= WORDSIZE;
SIZE(sp) = size;
tp = NEXT(sp);
SIZE(tp) = n|BIT0;
realfree(DATA(tp));
} else if (BOTTOM(sp))
Bottom = NULL;
/* return the allocated space */
SIZE(sp) |= BIT0 | o_bit1;
return (DATA(sp));
}