VuoRectangle.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
#include "type.h"
 
#ifdef VUO_COMPILER
VuoModuleMetadata({
    "title" : "Rectangle",
    "description" : "A 2-dimensional axis-aligned box.",
    "keywords" : [
        "coordinate",
        "point", "size",
        "box", "square",
    ],
    "version" : "1.0.0",
    "dependencies" : [
        "VuoPoint2d",
        "VuoReal",
        "VuoText"
    ]
});
#endif
 
VuoRectangle VuoRectangle_makeFromJson(json_object *js)
{
    return (VuoRectangle){
        VuoJson_getObjectValue(VuoPoint2d, js, "center", {0,0}),
        VuoJson_getObjectValue(VuoPoint2d, js, "size",   {0,0})
    };
}
 
json_object *VuoRectangle_getJson(const VuoRectangle r)
{
    json_object *js = json_object_new_object();
    json_object_object_add(js, "center", VuoPoint2d_getJson(r.center));
    json_object_object_add(js, "size",   VuoPoint2d_getJson(r.size));
    return js;
}
 
char *VuoRectangle_getSummary(const VuoRectangle r)
{
    return VuoText_format("%g×%g @ %g,%g", r.size.x, r.size.y, r.center.x, r.center.y);
}
 
bool VuoRectangle_areEqual(const VuoRectangle a, const VuoRectangle b)
{
    return VuoPoint2d_areEqual(a.center, b.center)
        && VuoPoint2d_areEqual(a.size,   b.size);
}
 
bool VuoRectangle_isLessThan(const VuoRectangle a, const VuoRectangle b)
{
    VuoType_returnInequality(VuoPoint2d, a.center, b.center);
    VuoType_returnInequality(VuoPoint2d, a.size, b.size);
    return false;
}
 
bool VuoRectangle_isPointInside(VuoRectangle r, VuoPoint2d p)
{
    return p.x >= r.center.x - r.size.x/2
        && p.x <= r.center.x + r.size.x/2
        && p.y >= r.center.y - r.size.y/2
        && p.y <= r.center.y + r.size.y/2;
}
 
VuoRectangle VuoRectangle_intersection(VuoRectangle rectangleA, VuoRectangle rectangleB)
{
    float rectangleALeft   = rectangleA.center.x - rectangleA.size.x/2.;
    float rectangleARight  = rectangleA.center.x + rectangleA.size.x/2.;
    float rectangleABottom = rectangleA.center.y - rectangleA.size.y/2.;
    float rectangleATop    = rectangleA.center.y + rectangleA.size.y/2.;
 
    float rectangleBLeft   = rectangleB.center.x - rectangleB.size.x/2.;
    float rectangleBRight  = rectangleB.center.x + rectangleB.size.x/2.;
    float rectangleBBottom = rectangleB.center.y - rectangleB.size.y/2.;
    float rectangleBTop    = rectangleB.center.y + rectangleB.size.y/2.;
 
    float tolerance = 0.00001;
 
    if (rectangleARight < rectangleBLeft   + tolerance
     || rectangleBRight < rectangleALeft   + tolerance
     || rectangleATop   < rectangleBBottom + tolerance
     || rectangleBTop   < rectangleABottom + tolerance)
        return (VuoRectangle){ { 0, 0 }, { 0, 0 } };
    else
    {
        float intersectionLeft   = MAX(rectangleALeft,   rectangleBLeft);
        float intersectionRight  = MIN(rectangleARight,  rectangleBRight);
        float intersectionBottom = MAX(rectangleABottom, rectangleBBottom);
        float intersectionTop    = MIN(rectangleATop,    rectangleBTop);
 
        return (VuoRectangle){
            { (intersectionLeft + intersectionRight) / 2.,
              (intersectionBottom + intersectionTop) / 2. },
            { intersectionRight - intersectionLeft,
              intersectionTop - intersectionBottom }
        };
    }
}
 
VuoRectangle VuoRectangle_union(VuoRectangle rectangleA, VuoRectangle rectangleB)
{
    VuoReal left   = MIN(rectangleA.center.x - rectangleA.size.x / 2., rectangleB.center.x - rectangleB.size.x / 2.);
    VuoReal right  = MAX(rectangleA.center.x + rectangleA.size.x / 2., rectangleB.center.x + rectangleB.size.x / 2.);
    VuoReal bottom = MIN(rectangleA.center.y - rectangleA.size.y / 2., rectangleB.center.y - rectangleB.size.y / 2.);
    VuoReal top    = MAX(rectangleA.center.y + rectangleA.size.y / 2., rectangleB.center.y + rectangleB.size.y / 2.);
 
    return (VuoRectangle){
        { (left + right) / 2.,
          (bottom + top) / 2. },
        { right - left,
          top - bottom }
    };
}