ami_event_set.c

Go to the documentation of this file.

//---------------------------------------------------------------------------

#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <math.h>

#define AMI_EVENT_LIST_LOAD_XML 1

#include "ami_event_set.h"

#define EVENT_BUFF_SIZE 1000
#define FRAMES_BUFF_SIZE 50000


float amiEventsIntersection(amiEvent * E1, amiEvent * E2)
{
    int minX, minY, maxX, maxY;

    assert(E1);
    assert(E2);

    minX = max(E1->pMin.x, E2->pMin.x);
    maxX = min(E1->pMax.x, E2->pMax.x);
    minY = max(E1->pMin.y, E2->pMin.y);
    maxY = min(E1->pMax.y, E2->pMax.y);

    // the rectangles have no intersection
    if (minX > maxX || minY > maxY) return 0.0;

    return fabs((maxX-minX)*(maxY-minY));
}
//---------------------------------------------------------------------------

float amiEventArea(amiEvent * E)
{
    assert(E);
    return fabs((E->pMax.x-E->pMin.x)*(E->pMax.y-E->pMin.y));
}
//---------------------------------------------------------------------------

unsigned char amiEventsOcclusion(amiEvent * E, amiEventsSubSet * ES, float Threshold)
{
    unsigned long i;
    assert(E);
    assert(ES);
    for (i = 0; i < ES->n; i++) {
        if (E->ObjectID == ES->Event[i]->ObjectID) continue;
        if (2*amiEventsIntersection(E, ES->Event[i])/(amiEventArea(E)+amiEventArea(ES->Event[i])) > Threshold)
            return 1;
    }
    return 0;
}
//---------------------------------------------------------------------------



//---------------------------------------------------------------------------
amiEventList * amiEventListNew(void)
{
    amiEventList * E = (amiEventList *)malloc(sizeof(amiEventList));
    assert(E);
    E->Event = NULL;
    E->nEvents = 0;
    E->Frames = NULL;
    E->nFrames = 0;
    E->Types = NULL;
    E->nTypes = 0;
    E->defaultType = EVENT_TYPE_HEAD;
    return E;
}
//---------------------------------------------------------------------------

int amiEventListFree(amiEventList * E)
{
    if (!E) return 1;
    free(E->Event); E->Event = NULL;
    E->nEvents = 0;
    free(E->Frames); E->Frames = NULL;
    E->nFrames = 0;
    free(E->Types); E->Types = NULL;
    E->nTypes = 0;
    free(E); E = NULL;
    return 1;
}
//---------------------------------------------------------------------------

int amiEventListInit(amiEventList * E, unsigned long Size)
{
    assert(E);
    if (E->Event) E->Event = (amiEvent *)realloc(E->Event, Size*sizeof(amiEvent));
    else E->Event = (amiEvent *)calloc(Size, sizeof(amiEvent));
    E->nEvents = Size;
    if (E->Frames) free(E->Frames);
    E->Frames = NULL;
    E->nFrames = 0;
    free(E->Types); E->Types = NULL;
    E->nTypes = 0;
    return 1;
}
//---------------------------------------------------------------------------

int _amiEventListLoadTXT(amiEventList * E, const char * Filename)
{
    char buff[1024];
    int frame, id;
    float p1, p2, p3, p4, occ;
    long last;
    long size;
    long FramesBuff[FRAMES_BUFF_SIZE];
    long nFB;
    amiEvent *itr;
    FILE *fin;

    assert(E);

    if ((fin = fopen(Filename, "rt")) == NULL) return -1;

    size = 0;
    while(fgets(buff, 1024, fin)) size++;
    fseek(fin, 0L, SEEK_SET);

    amiEventListInit(E, size);

    last = -1;
    nFB = 0;
    itr = E->Event;
    while(fgets(buff, 1024, fin)) {
        if (sscanf(buff, "%d %d %f %f %f %f %f\n", &frame, &id, &occ, &p1, &p2, &p3, &p4)) {
            (*itr).Time = frame;
            (*itr).ObjectID = id;
            (*itr).Type = E->defaultType;
            amiPoint2iSet((*itr).pMin, (int)p1, (int)p2);
            amiPoint2iSet((*itr).pMax, (int)p3, (int)p4);
            if (last != frame) {
                // the frame does not exist yet
                for (size = 0 ; size < nFB; size++) if (frame == FramesBuff[size]) break;
                // add frame
                if (size >= nFB) {
                    FramesBuff[nFB++] = frame;
                    last = frame;
                }
            }
        }
        itr++;
    }

    E->nFrames = nFB;
    E->Frames = (long *)malloc(E->nFrames*sizeof(long));
    memcpy(E->Frames, FramesBuff, E->nFrames*sizeof(long));

    _amiEventListSortFrames(E);

    E->nTypes = 1;
    E->Types = (int *)malloc(E->nTypes*sizeof(int));
    E->Types[0] = E->defaultType;

    fclose(fin);

    return 1;
}
//---------------------------------------------------------------------------

int _amiEventListSortFrames(amiEventList * E)
{
    char change;
    long size, last;

    assert(E);

    // sort frames list
    change = 1;
    while (change) {
        change = 0;
        for (size = 0; size < E->nFrames-1; size++) {
            if (E->Frames[size] > E->Frames[size+1]) {
                last = E->Frames[size];
                E->Frames[size] = E->Frames[size+1];
                E->Frames[size+1] = last;
                change++;
            }
        }
        change = change;
    }

    return 1;
}
//---------------------------------------------------------------------------

int amiEventListMerge(amiEventList * EDst, amiEventList * ESrc)
{
    long FramesBuff[FRAMES_BUFF_SIZE];
    long nFB, i, idst;
    amiEvent *dst;
    long *dstFr;
    int *dstType;

    assert(EDst);
    assert(ESrc);

    // reallocate and copy Events together
    dst = (amiEvent *)malloc((EDst->nEvents+ESrc->nEvents)*sizeof(amiEvent));
    assert(dst);
    memcpy(dst, EDst->Event, EDst->nEvents*sizeof(amiEvent));
    memcpy(dst+EDst->nEvents, ESrc->Event, ESrc->nEvents*sizeof(amiEvent));
    EDst->nEvents += ESrc->nEvents;
    free(EDst->Event);
    EDst->Event = dst;

    // prepare FramesBuff for Frames
    nFB = 0;
    for (i = 0; i < ESrc->nFrames; i++) {
        // the frame does not exist yet in EDst->Frames
        for (idst = 0 ; idst < EDst->nFrames; idst++) if (ESrc->Frames[i] == EDst->Frames[idst]) break;

        if (idst >= EDst->nFrames) {

            // and the frame does not exist yet in EDst->Frames
            for (idst = 0 ; idst < nFB; idst++) if (ESrc->Frames[i] == FramesBuff[idst]) break;

            if (idst >= nFB) FramesBuff[nFB++] = ESrc->Frames[i];
        }
    }

    dstFr = (long *)malloc((EDst->nFrames+nFB)*sizeof(long));
    memcpy(dstFr, EDst->Frames, EDst->nFrames*sizeof(long));
    memcpy(dstFr+EDst->nFrames, FramesBuff, nFB*sizeof(long));

    free(EDst->Frames);
    EDst->Frames = dstFr;
    EDst->nFrames += nFB;

    _amiEventListSortFrames(EDst);

    // prepare FramesBuff for Types
    nFB = 0;
    for (i = 0; i < ESrc->nTypes; i++) {
        for (idst = 0 ; idst < EDst->nTypes; idst++) if (ESrc->Types[i] == EDst->Types[idst]) break;
        if (idst >= EDst->nTypes) {
            for (idst = 0 ; idst < nFB; idst++) if (ESrc->Types[i] == FramesBuff[idst]) break;
            if (idst >= nFB) FramesBuff[nFB++] = ESrc->Types[i];
        }
    }

    dstType = (int *)malloc((EDst->nTypes+nFB)*sizeof(int));
    memcpy(dstType, EDst->Types, EDst->nTypes*sizeof(long));
    memcpy(dstType+EDst->nTypes, FramesBuff, nFB*sizeof(long));
    free(EDst->Types);
    EDst->Types = dstType;
    EDst->nTypes += nFB;

    return 1;
}
//---------------------------------------------------------------------------
int amiEventListLoad(amiEventList * E, const char * Filename)
{
    int i;
    amiEventList * EventsTmp = amiEventListNew();

    EventsTmp->defaultType = E->defaultType;

    for (i = strlen(Filename)-1; i >= 0; i--) if (Filename[i] == '.') break;

    #ifdef AMI_EVENT_LIST_LOAD_XML
    if (strncmp(&(Filename[i+1]), "xml", 3) == 0) _amiEventListLoadXML(EventsTmp, Filename);
    else                                          _amiEventListLoadTXT(EventsTmp, Filename);
    #else
    if (strncmp(&(Filename[i+1]), "xml", 3) == 0) return -1;
    else                                          _amiEventListLoadTXT(EventsTmp, Filename);
    #endif

    amiEventListMerge(E, EventsTmp);
    amiEventListFree(EventsTmp);

    return 1;
}
//---------------------------------------------------------------------------

int amiEventListEmpty(amiEventList * E)
{
    return (E->nEvents == 0);
}
//---------------------------------------------------------------------------


#ifdef AMI_EVENT_LIST_LOAD_XML

#include <libxml\tree.h>

int _amiEventSetXML(amiEvent * Event, xmlNodePtr Node)
{
    xmlAttrPtr Param;
    float x1, x2, y1, y2;

    assert(Event);
    assert(Node);

    while (Node) {
        if (xmlStrcmp(Node->name, BAD_CAST "Time") == 0)
            Event->Time = atol(Node->children->content);
        else if (xmlStrcmp(Node->name, BAD_CAST "ID") == 0)
           Event->Type = (unsigned char)atoi(Node->children->content);
        else if (xmlStrcmp(Node->name, BAD_CAST "Parameters") == 0) {
            Param = Node->properties;
            while (Param) {
                if (xmlStrcmp(Param->name,"MinX")==0) x1 = atof(Param->children->content);
                else if (xmlStrcmp(Param->name,"MinY")==0) y1 = atof(Param->children->content);
                else if (xmlStrcmp(Param->name,"MaxX")==0) x2 = atof(Param->children->content);
                else if (xmlStrcmp(Param->name,"MaxY")==0) y2 = atof(Param->children->content);
                else if (xmlStrcmp(Param->name,"Object")==0)
                    Event->ObjectID = (unsigned int)atoi(Param->children->content);
                Param = Param->next;
            }
            amiPoint2iSet(Event->pMin, (int)x1, (int)y1);
            amiPoint2iSet(Event->pMax, (int)x2, (int)y2);

        }
        Node = Node->next;
    }
    return 1;
}
//---------------------------------------------------------------------------

int _amiEventListLoadXML(amiEventList * E, const char * Filename)
{
    amiEvent *  actE;
    xmlNodePtr  nodeE, backUp;
    long i;
    long FramesBuff[FRAMES_BUFF_SIZE];
    long nFB;
    int  TypesBuff[EVENT_BUFF_SIZE];
    long nTB;
    long size, last;
    xmlDocPtr docXML;

    assert(E);

    xmlInitParser();
    docXML = xmlParseFile(Filename);
    if (!docXML) return -1;
    nodeE = docXML->children->children;
    while (nodeE && (xmlStrcmp(nodeE->name, BAD_CAST "File") != 0)) nodeE = nodeE->next;
    nodeE = nodeE->children;
    backUp = nodeE;

    size = 0;
    while (nodeE) {
        if (xmlStrcmp(nodeE->name, BAD_CAST "Event") == 0) size++;
        nodeE = nodeE->next;
    }

    amiEventListInit(E, size);

    nodeE = backUp;
    actE  = E->Event;
    last  = -1;
    nFB = 0;
    nTB = 0;
    while(nodeE) {
        if (xmlStrcmp(nodeE->name, BAD_CAST "Event") == 0) {
            _amiEventSetXML(actE, nodeE->children);
            if (last != actE->Time) {
                 // the frame does not exist yet
                for (size = 0 ; size < nFB; size++) if (actE->Time == FramesBuff[size]) break;
                // add frame
                if (size >= nFB) {
                    FramesBuff[nFB++] = actE->Time;
                    last = actE->Time;
                }
            }
            for (size = 0; size < nTB; size++) if (actE->Type == TypesBuff[size]) break;
            if (size >= E->nTypes) TypesBuff[nTB++] = actE->Type;

            actE++;
        }
        nodeE = nodeE->next;
    }

    E->nFrames = nFB;
    E->Frames = (long *)malloc(E->nFrames*sizeof(long));
    memcpy(E->Frames, FramesBuff, E->nFrames*sizeof(long));

    _amiEventListSortFrames(E);

    E->nTypes = nTB;
    E->Types = (int *)malloc(E->nTypes*sizeof(int));
    memcpy(E->Types, TypesBuff, E->nTypes*sizeof(int));


    xmlFreeDoc(docXML); docXML = NULL;
    
    return 1;
}
//---------------------------------------------------------------------------


#endif



//---------------------------------------------------------------------------

amiEventsSubSet * amiEventsSubSetNew(void)
{
    amiEventsSubSet * ES = (amiEventsSubSet *)malloc(sizeof(amiEventsSubSet));
    assert(ES);
    ES->n = 0;
    ES->Event = NULL;
    return ES;
}
//---------------------------------------------------------------------------

int amiEventsSubSetFree(amiEventsSubSet * ES)
{
    assert(ES);
    free(ES->Event); ES->Event = NULL;
    ES->n = 0;
    free(ES);
    ES = NULL;
    return 1;
}
//---------------------------------------------------------------------------

int amiEventsSubSetInit(amiEventsSubSet * ES, amiEventList * E, long Frame, int *Types, int nTypes)
{
    amiEvent *   itr;
    amiEvent *   buff[EVENT_BUFF_SIZE];
    long nbuff, i, k;

    itr = E->Event;
    nbuff = 0;
    for (i = 0; i < E->nEvents; i++) {
        if (itr->Time == Frame) {
            k = -1;
            if (Types) for (k = 0; k < nTypes; k++) if (Types[k] == itr->Type) break;
            // E->Event[i]->Type is in Types set so put Event into SubSet or no Types set is set
            if (k < nTypes) buff[nbuff++] = itr;
        }
        itr++;
    }

    ES->n = nbuff;
    if (ES->Event || nbuff)
        ES->Event = (amiEvent **)realloc(ES->Event, nbuff*sizeof(amiEvent *));
    if (nbuff > 0)
        memcpy(ES->Event, buff, nbuff*sizeof(amiEvent *));

    return 1;
}
//---------------------------------------------------------------------------

---