ObjectTrack.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/


#include "thirdparty/ObjectTrack.h"

namespace cmlabs {

ObjectObservation::ObjectObservation() {
        id = Object::createUniqueID("ObjectObservation");
        image = NULL;
}

ObjectObservation::ObjectObservation(const JString& xml) {
        id = Object::createUniqueID("ObjectObservation");
        image = NULL;
        tracks.noDelete();
        if (!fromXML(xml)) {
        }
}

ObjectObservation::ObjectObservation(XMLNode* node) {
        id = Object::createUniqueID("ObjectObservation");
        image = NULL;
        tracks.noDelete();
        if (!fromXML(node)) {
        }
}

ObjectObservation::~ObjectObservation() {
        delete(image);
        tracks.noDelete();
        image = NULL;
}

Object* ObjectObservation::clone() const {
        ObjectObservation* obs = new ObjectObservation();
        obs->frame = frame;
        obs->id = id;
        obs->scene = scene;
        obs->timestamp = timestamp;
        obs->box = box;
        if (image != NULL)
                obs->image = (Bitmap*) image->clone();
        obs->properties.copyAll(properties);
        obs->tracks.addAll(tracks);
        return obs;
}

JString ObjectObservation::print() {
        JString str = JString::format("\n");
        return str;
}

JString ObjectObservation::toXML() {
        return JString::format("<ObjectTrack>\n</ObjectTrack>");
}

bool ObjectObservation::fromXML(const JString& xml) {

        if (xml.length() == 0)
                return false;

        XMLParser* xmlParser = new XMLParser();
        xmlParser->parse(xml);
        bool ret = fromXML(xmlParser->getRootNode());
        delete(xmlParser);
        return ret;
}

bool ObjectObservation::fromXML(XMLNode* node) {
        if (node == NULL) {
                return false;
        }
        if (!node->getTag().equalsIgnoreCase("ObjectTrack"))
                return false;

        //XMLNode* xmlNode = node->getChildNode("collection");
        //if (xmlNode == NULL)
        //      return false;
        //if (!list.fromXML(xmlNode))
        //      return false;

        return true;
}

JString ObjectObservation::get(const JString& key) {
        Object* obj = properties.get(key);
        if (obj == NULL) return "";
        return obj->print();
}

bool ObjectObservation::set(const JString& key, const JString& value) {
        return properties.put(key, value.clone());
}

Object* ObjectObservation::getObject(const JString& key) {
        return properties.get(key);
}

bool ObjectObservation::setObject(const JString& key, Object* value) {
        return properties.put(key, value);
}

bool ObjectObservation::associateWithTrack(const JString& trackID) {
        if (tracks.contains(trackID))
                return true;
        return tracks.add(trackID);
}

bool ObjectObservation::disassociateWithTrack(const JString& trackID) {
        return tracks.remove(trackID);
}





















ObjectTrackEntry::ObjectTrackEntry() {
        observations.noDelete();
}

ObjectTrackEntry::ObjectTrackEntry(ObjectObservation* obs) {
        observations.noDelete();
        if (obs != NULL) {
                timestamp = obs->timestamp;
                frame = obs->frame;
                scene = obs->scene;
                associateObservation(obs);
        }
}

ObjectTrackEntry::ObjectTrackEntry(const JString& xml) {
        observations.noDelete();
        if (!fromXML(xml)) {
        }
}

ObjectTrackEntry::ObjectTrackEntry(XMLNode* node) {
        observations.noDelete();
        if (!fromXML(node)) {
        }
}

ObjectTrackEntry::~ObjectTrackEntry() {}

Object* ObjectTrackEntry::clone() const {
        ObjectTrackEntry* entry = new ObjectTrackEntry();
        entry->timestamp = timestamp;
        entry->frame = frame;
        entry->scene = scene;
        entry->observations.copyAll(observations);
        return entry;
}

JString ObjectTrackEntry::print() {
        JString str = JString::format("\n");
        return str;
}

JString ObjectTrackEntry::toXML() {
        return JString::format("<ObjectTrack>\n</ObjectTrack>");
}

bool ObjectTrackEntry::fromXML(const JString& xml) {

        if (xml.length() == 0)
                return false;

        XMLParser* xmlParser = new XMLParser();
        xmlParser->parse(xml);
        bool ret = fromXML(xmlParser->getRootNode());
        delete(xmlParser);
        return ret;
}

bool ObjectTrackEntry::fromXML(XMLNode* node) {
        if (node == NULL) {
                return false;
        }
        if (!node->getTag().equalsIgnoreCase("ObjectTrack"))
                return false;

        //XMLNode* xmlNode = node->getChildNode("collection");
        //if (xmlNode == NULL)
        //      return false;
        //if (!list.fromXML(xmlNode))
        //      return false;

        return true;
}

bool ObjectTrackEntry::associateObservation(ObjectObservation* obs) {
        if (obs == NULL) return false;
        if (frame != obs->frame) return false;
        return observations.put(obs->id, obs);
}

bool ObjectTrackEntry::disassociateObservation(ObjectObservation* obs) {
        if (obs == NULL) return false;
        if (frame != obs->frame) return false;
        return observations.remove(obs->id);
}

Box ObjectTrackEntry::getBoundingBox() {
        
        Box box;
        if (observations.getCount() == 0)
                return box;

        ObjectObservation* obs = (ObjectObservation*) observations.getFirst();
        if (obs == NULL)
                return box;

        box = obs->box;
        for (int n=1; n<observations.getCount(); n++) {
                if ( (obs = (ObjectObservation*) observations.get(n)) != NULL) {
                        box.growToBoundingBox(obs->box);
                }
        }
        return box;
}


















ObjectTrack::ObjectTrack() {
        id = Object::createUniqueID("ObjectTrack");
}

ObjectTrack::ObjectTrack(const JString& xml) {
        id = Object::createUniqueID("ObjectTrack");
        if (!fromXML(xml)) {
        }
}

ObjectTrack::ObjectTrack(XMLNode* node) {
        id = Object::createUniqueID("ObjectTrack");
        if (!fromXML(node)) {
        }
}

ObjectTrack::~ObjectTrack() {}

Object* ObjectTrack::clone() const {
        ObjectTrack* track = new ObjectTrack();
        track->id = id;
        track->entries.copyAll(entries);
        return track;
}

JString ObjectTrack::print() {
        JString str = JString::format("\n");
        return str;
}

JString ObjectTrack::toXML() {
        return JString::format("<ObjectTrack>\n</ObjectTrack>");
}

bool ObjectTrack::fromXML(const JString& xml) {

        if (xml.length() == 0)
                return false;

        XMLParser* xmlParser = new XMLParser();
        xmlParser->parse(xml);
        bool ret = fromXML(xmlParser->getRootNode());
        delete(xmlParser);
        return ret;
}

bool ObjectTrack::fromXML(XMLNode* node) {
        if (node == NULL) {
                return false;
        }
        if (!node->getTag().equalsIgnoreCase("ObjectTrack"))
                return false;

        //XMLNode* xmlNode = node->getChildNode("collection");
        //if (xmlNode == NULL)
        //      return false;
        //if (!list.fromXML(xmlNode))
        //      return false;

        return true;
}


ObjectTrackEntry* ObjectTrack::get(unsigned long long frame) {
        return (ObjectTrackEntry*) entries.get(JString(frame));
}

ObjectTrackEntry* ObjectTrack::getFirst() {
        return (ObjectTrackEntry*) entries.getFirst();
}

ObjectTrackEntry* ObjectTrack::getLast() {
        return (ObjectTrackEntry*) entries.getLast();
}

JTime ObjectTrack::getFirstActivityTime() {
        ObjectTrackEntry* entry = getFirst();
        if (entry == NULL) return JTime::createInvalid();
        return entry->timestamp;
}

unsigned long long ObjectTrack::getFirstActivityFrame() {
        ObjectTrackEntry* entry = getFirst();
        if (entry == NULL) return 0;
        return entry->frame;
}

JTime ObjectTrack::getLastActivityTime() {
        ObjectTrackEntry* entry = getLast();
        if (entry == NULL) return JTime::createInvalid();
        return entry->timestamp;
}

unsigned long long ObjectTrack::getLastActivityFrame() {
        ObjectTrackEntry* entry = getLast();
        if (entry == NULL) return 0;
        return entry->frame;
}

bool ObjectTrack::associateObservation(ObjectObservation* obs) {
        if (obs == NULL) return false;
        unsigned long long obsFrame = obs->frame;
        if (obsFrame < 0) return false;
        ObjectTrackEntry* entry = (ObjectTrackEntry*) entries.get(JString(obsFrame));
        if (entry == NULL) {
                entry = new ObjectTrackEntry(obs);
                entries.put(JString(obsFrame), entry);
        }
        return obs->associateWithTrack(this->id);
}

bool ObjectTrack::disassociateObservation(ObjectObservation* obs) {
        if (obs == NULL) return false;
        unsigned long long obsFrame = obs->frame;
        if (obsFrame < 0) return false;
        ObjectTrackEntry* entry = (ObjectTrackEntry*) entries.get(JString(obsFrame));
        if (entry != NULL)
                entry->disassociateObservation(obs);
        return obs->disassociateWithTrack(this);
}







} // namespace cmlabs

---