view release on metacpan or  search on metacpan

RectanglesContainingDot_XS.xs  view on Meta::CPAN

            }
        }
        else {
            if (besty < bestreq) {
                // fprintf(stderr, "besty: %f, bestreq: %f\n", besty, bestreq);
                part_division(aTHX_ rects, size, bestyy, 'y', &(div->left), sizely, &(div->right), sizery);
                div->cut = bestyy;
                Safefry(div->rects);
                div->rects = NULL;
                return div->dir = 'y';
            }
        }
    }
    return div->dir = 'n';
}

struct division *
division_containing_dot(pTHX_ struct division *div, double x, double y) {
    while(1) {
        int dir = div->dir;
        if (!dir)
            dir = subdivide_division(aTHX_ div);

        switch(dir) {
        case 'x':
            div = (x <= div->cut) ? div->left : div->right;
            break;
        case 'y':
            div = (y <= div->cut) ? div->left : div->right;
            break;
        default:
            my_assert(div->rects);
            return div;
        }
    }
}



MODULE = Algorithm::RectanglesContainingDot_XS		PACKAGE = Algorithm::RectanglesContainingDot_XS		

void
add_rectangle(self, name, x0, y0, x1, y1)
    struct algorithm *self
    SV *name
    double x0
    double y0
    double x1
    double y1
C_ARGS:
    aTHX_ self, name, x0, y0, x1, y1
    
void
rectangles_containing_dot(self, x, y)
    struct algorithm *self
    double x
    double y
PREINIT:
    struct division *div;
    int n = 0;
PPCODE:
    div = init_division(aTHX_ self);
    if (div) {
        struct rectangle **rects;
        int i, size;
        
        div = division_containing_dot(aTHX_ div, x, y);
        rects = div->rects;
        size = div->size;

        for (n = i = 0; i < size; i++) {
            struct rectangle *rect = rects[i];
            if (rect->x0 <= x &&
                rect->y0 <= y &&
                rect->x1 >= x &&
                rect->y1 >= y) {
                XPUSHs(sv_2mortal(newSVsv(rect->name)));
                n++;
            }
        }
    }
    XSRETURN(n);
    
struct algorithm *
new(klass)
    SV *klass
CODE:
    RETVAL = allocate_algorithm(aTHX);
OUTPUT:
    RETVAL

void
DESTROY(self)
    struct algorithm *self
CODE:
    release_algorithm(aTHX_ self);
sv_unmagic(SvRV(ST(0)), '~');