CVML.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/CVML.h"

namespace cmlabs {

/******************************************************************************************
// CVMLHypothesis
******************************************************************************************/


CVMLHypothesis::CVMLHypothesis() {
}

CVMLHypothesis::CVMLHypothesis(JString xml) {
        evaluation = 0;
        if (!Object::fromXML(xml)) {
        }
}

CVMLHypothesis::CVMLHypothesis(XMLNode* node) {
        evaluation = 0;
        if (!fromXML(node)) {
        }
}

CVMLHypothesis::~CVMLHypothesis() {}

Object* CVMLHypothesis::clone() const {
        CVMLHypothesis* fv = new CVMLHypothesis();
        fv->id = id;
        fv->previous = previous;
        fv->evaluation = evaluation;
        fv->parameters.copyAll(parameters);
        fv->evaluations.copyAll(evaluations);
        return fv;
}

bool CVMLHypothesis::setLabel(JString label, JString value, double eval) {
        if (label.length() == 0)
                return false;
        parameters.put(label, value);
        evaluations.put(label, JString(eval));
        return true;
}

bool CVMLHypothesis::setPrevious(JString prev) {
        previous = prev;
        return true;
}

bool CVMLHypothesis::setEvaluation(double eval) {
        evaluation = eval;
        return true;
}

Collection CVMLHypothesis::getLabels() {
        return parameters.getAllKeys();
}


JString CVMLHypothesis::getLabelValue(JString label) {
        return parameters.get(label);
}

double CVMLHypothesis::getLabelEval(JString label) {
        return evaluations.get(label).toDouble();
}

bool CVMLHypothesis::setID(JString newID) {
        id = newID;
        return true;
}

JString CVMLHypothesis::getID() {
        return id;
}

JString CVMLHypothesis::getPrevious() {
        return previous;
}

double CVMLHypothesis::getEvaluation() {
        return evaluation;
}

JString CVMLHypothesis::print() {
        return toXML();
}

JString CVMLHypothesis::toXML() {
        JString xml, key, value;
        double eval;
        for (int n=0; n<parameters.getCount(); n++) {
                key = parameters.getKey(n);
                if (key.length() > 0) {
                        value = parameters.get(n);
                        eval = evaluations.get(key).toDouble();
                        xml += JString::format("<%s evaluation=\"%f\">%s</%s>\n",
                                (char*) key.xmlStringEncode(), eval, (char*) value.xmlStringEncode(), (char*) key.xmlStringEncode());
                }
        }
        if (xml.length() > 0)
                return JString::format("<hypothesis id=\"%s\" prev=\"%s\" evaluation=\"%f\">\n%s</hypothesis>\n", (char*) id, (char*) previous, evaluation, (char*) xml.indentXML());
        else
                return JString::format("<hypothesis id=\"%s\" prev=\"%s\" evaluation=\"%f\">\n</hypothesis>\n", (char*) id, (char*) previous, evaluation);
}

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

        id = node->getAttribute("id");
        previous = node->getAttribute("prev");
        evaluation = node->getAttribute("evaluation").toDouble();
        
        ObjectCollection* nodes = node->getChildTags();
        JString key, value;
        double eval;
        XMLNode* xmlNode;
        if (nodes != NULL) {
                for (int n=0; n<nodes->getCount(); n++) {
                        if ( (xmlNode = (XMLNode*) nodes->get(n)) != NULL) {
                                key = xmlNode->getTag().toLowerCase();
                                value = xmlNode->getText().toLowerCase();
                                eval = xmlNode->getAttribute("evaluation").toDouble();
                                parameters.put(key, value);
                                evaluations.put(key, JString(eval));
                        }
                }
        }

        return true;
}

















/******************************************************************************************
// CVMLObjectBase
******************************************************************************************/


CVMLObjectBase::CVMLObjectBase() {
        type = "objectbase";
}

CVMLObjectBase::CVMLObjectBase(JString xml) {
        if (!Object::fromXML(xml)) {
        }
        type = "objectbase";
}

CVMLObjectBase::CVMLObjectBase(XMLNode* node) {
        if (!fromXML(node)) {
        }
        type = "objectbase";
}

CVMLObjectBase::~CVMLObjectBase() {}

Object* CVMLObjectBase::clone() const {
        CVMLObjectBase* fv = new CVMLObjectBase();
        fv->id = id;
        fv->type = type;
        fv->appearance = appearance;
        fv->box = box;
        fv->hypotheses.copyAll(hypotheses);
        fv->features.copyAll(features);
        fv->members.copyAll(members);
        return fv;
}

bool CVMLObjectBase::setBox(double x, double y, double w, double h, double orientation) {
        box.set(x, y, w, h);
        box.orientation = orientation;
        return true;
}

bool CVMLObjectBase::setID(JString newID) {
        id = newID;
        return true;
}

JString CVMLObjectBase::getID() {
        return id;
}

bool CVMLObjectBase::setBox(Box b) {
        box = b;
        return true;
}

Box CVMLObjectBase::getBox() {
        return box;
}

bool CVMLObjectBase::setAppearance(JString appear) {
        appearance = appear;
        return true;
}

bool CVMLObjectBase::addHypothesis(CVMLHypothesis* hyp) {
        if (hyp == NULL)
                return false;
        return hypotheses.put(hyp->id, hyp);
}

bool CVMLObjectBase::addFeature(JString featurename, JString content) {
        return features.put(featurename, content);
}

Dictionary CVMLObjectBase::getFeatureList() {
        return features;
}

JString CVMLObjectBase::getAppearance() {
        return appearance;
}

CVMLHypothesis* CVMLObjectBase::getHypothesis(JString hypID) {
        return (CVMLHypothesis*) hypotheses.get(hypID);
}

Collection CVMLObjectBase::getHypothesesIDs() {
        return hypotheses.getAllKeys();
}



JString CVMLObjectBase::print() {
        return toXML();
}

JString CVMLObjectBase::toXML() {
        JString xml = JString::format("<orientation>%f</orientation>\n", box.orientation);
        xml += JString::format("<box x=\"%f\" y=\"%f\" w=\"%f\" h=\"%f\" />\n", box.getLeftX(), box.getUpperY(), box.getWidth(), box.getHeight());

        xml += JString::format("<appearance>%s</appearance>\n", (char*)appearance.xmlStringEncode());

        if (members.getCount() > 0) {
                xml += JString::format("<members>%s</members>\n", (char*) members.printListLine(",").xmlStringEncode());
        }

        JString hypXML;
        for (CVMLHypothesis* hyp = (CVMLHypothesis*) hypotheses.getFirst(); hyp != NULL; hyp = (CVMLHypothesis*) hypotheses.getNext()) {
                hypXML += hyp->toXML();
        }
        if (hypXML.length() > 0)
                xml += JString::format("<hypothesislist>\n%s</hypothesislist>\n", (char*) hypXML.indentXML());

        JString featureXML;
        for (JString feat = features.getFirstKey(); feat.length() > 0; feat = features.getNextKey()) {
                featureXML += JString::format("<%s>%s</%s>\n", (char*) feat, (char*) features.get(feat), (char*) feat);
        }
        if (featureXML.length() > 0)
                xml += JString::format("<featurelist>\n%s</featurelist>\n", (char*) featureXML.indentXML());

        return JString::format("<%s id=\"%s\">\n%s</%s>\n", (char*) type.xmlStringEncode(), (char*) id.xmlStringEncode(), (char*) xml.indentXML(), (char*) type.xmlStringEncode());
}

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

        id = node->getAttribute("id");
        
        ObjectCollection* nodes = node->getChildTags();
        
        CVMLHypothesis* hyp;
        XMLNode* xmlNode;
        XMLNode* subNode;
        ObjectCollection* subNodes;

        if (nodes != NULL) {
                for (int n=0; n<nodes->getCount(); n++) {
                        if ( (xmlNode = (XMLNode*) nodes->get(n)) != NULL) {
                                if (xmlNode->getTag().equalsIgnoreCase("orientation"))
                                        box.orientation = xmlNode->getText().toDouble();
                                else if (xmlNode->getTag().equalsIgnoreCase("box"))
                                        box.fromXML(xmlNode);
                                        //box.set(xmlNode->getAttribute("x").toDouble(), xmlNode->getAttribute("y").toDouble(),
                                        //      xmlNode->getAttribute("w").toDouble(), xmlNode->getAttribute("h").toDouble());
                                else if (xmlNode->getTag().equalsIgnoreCase("appearance"))
                                        appearance = xmlNode->getText();
                                else if (xmlNode->getTag().equalsIgnoreCase("members"))
                                        members = xmlNode->getText().split(",");
                                else if (xmlNode->getTag().equalsIgnoreCase("hypothesislist")) {
                                        if ( (subNodes = xmlNode->getChildTags()) != NULL) {
                                                for (subNode = (XMLNode*) subNodes->getFirst(); subNode != NULL; subNode = (XMLNode*) subNodes->getNext()) {
                                                        if (subNode->getTag().equalsIgnoreCase("hypothesis")) {
                                                                hyp = new CVMLHypothesis(subNode);
                                                                hypotheses.put(hyp->id, hyp);
                                                        }
                                                }
                                        }
                                }
                                else if (xmlNode->getTag().equalsIgnoreCase("featurelist")) {
                                        if ( (subNodes = xmlNode->getChildTags()) != NULL) {
                                                for (subNode = (XMLNode*) subNodes->getFirst(); subNode != NULL; subNode = (XMLNode*) subNodes->getNext()) {
                                                        features.put(subNode->getTag(), subNode->getText());
                                                }
                                        }
                                }
                        }
                }
        }

        return true;
}


















/******************************************************************************************
// CVMLObject
******************************************************************************************/


CVMLObject::CVMLObject() : CVMLObjectBase() {
        type = "object";
}

CVMLObject::CVMLObject(JString xml) : CVMLObjectBase(xml) {
        type = "object";
}

CVMLObject::CVMLObject(XMLNode* node) : CVMLObjectBase(node) {
        type = "object";
}

CVMLObject::~CVMLObject() {}









/******************************************************************************************
// CVMLGroup
******************************************************************************************/


CVMLGroup::CVMLGroup() : CVMLObjectBase() {
        type = "group";
}

CVMLGroup::CVMLGroup(JString xml) : CVMLObjectBase(xml) {
        type = "group";
}

CVMLGroup::CVMLGroup(XMLNode* node) : CVMLObjectBase(node) {
        type = "group";
}

CVMLGroup::~CVMLGroup() {}


bool CVMLGroup::addMember(JString id) {
        return members.add(id);
}

Collection CVMLGroup::getMembers() {
        return members;
}























/******************************************************************************************
// CVMLFrame
******************************************************************************************/


CVMLFrame::CVMLFrame() {
}

CVMLFrame::CVMLFrame(JString xml) {
        if (!Object::fromXML(xml)) {
        }
}

CVMLFrame::CVMLFrame(XMLNode* node) {
        if (!fromXML(node)) {
        }
}

CVMLFrame::~CVMLFrame() {}

Object* CVMLFrame::clone() const {
        CVMLFrame* fv = new CVMLFrame();
        fv->id = id;
        fv->objects.copyAll(this->objects);
        fv->groups.copyAll(this->groups);
        return fv;
}

bool CVMLFrame::addObject(CVMLObject* object) {
        return objects.put(object->id, object);
}

bool CVMLFrame::addGroup(CVMLGroup* group) {
        return groups.put(group->id, group);
}

bool CVMLFrame::removeObject(JString id) {
        return objects.remove(id);
}

bool CVMLFrame::removeGroup(JString id) {
        return groups.remove(id);
}


JString CVMLFrame::print() {
        return toXML();
}

JString CVMLFrame::toXML() {
        JString xml;
        int n;
        CVMLObject* object;
        CVMLGroup* group;

        xml += "<objectlist>\n";
        for (n=0; n<objects.getCount(); n++) {
                if ( (object = ((CVMLObject*) objects.get(n))) != NULL ) {
                        xml += object->toXML().indentXML();
                }
        }
        xml += "</objectlist>\n";

        xml += "<grouplist>\n";
        for (n=0; n<groups.getCount(); n++) {
                if ( (group = ((CVMLGroup*) groups.get(n))) != NULL ) {
                        xml += group->toXML().indentXML();
                }
        }
        xml += "</grouplist>\n";

        return JString::format("<frame number=\"%s\">\n%s</frame>\n", (char*) id.xmlStringEncode(), (char*) xml.indentXML());
}

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

        id = node->getAttribute("number");
        
        CVMLObject* object;
        CVMLGroup* group;
        XMLNode* subNode;

        XMLNode* objectList = node->getChildNode("objectlist");
        if (objectList != NULL) {
                ObjectCollection* objectNodes = objectList->getChildTags();
                if (objectNodes != NULL) {
                        for (subNode = (XMLNode*) objectNodes->getFirst(); subNode != NULL; subNode = (XMLNode*) objectNodes->getNext()) {
                                object = new CVMLObject(subNode);
                                objects.put(object->id, object);
                        }
                }
        }

        XMLNode* groupList = node->getChildNode("grouplist");
        if (groupList != NULL) {
                ObjectCollection* groupNodes = groupList->getChildTags();
                if (groupNodes != NULL) {
                        for (subNode = (XMLNode*) groupNodes->getFirst(); subNode != NULL; subNode = (XMLNode*) groupNodes->getNext()) {
                                group = new CVMLGroup(subNode);
                                groups.put(group->id, group);
                        }
                }
        }

        return true;
}










/******************************************************************************************
// CVMLDataSet
******************************************************************************************/


CVMLDataSet::CVMLDataSet() {
}

CVMLDataSet::CVMLDataSet(JString xml) {
        if (!Object::fromXML(xml)) {
        }
}

CVMLDataSet::CVMLDataSet(XMLNode* node) {
        if (!fromXML(node)) {
        }
}

CVMLDataSet::~CVMLDataSet() {}

Object* CVMLDataSet::clone() const {
        CVMLDataSet* fv = new CVMLDataSet();
        fv->name = name;
        fv->frames.copyAll(this->frames);
        return fv;
}

bool CVMLDataSet::addFrame(CVMLFrame* frame) {
        return frames.put(frame->id, frame);
}

bool CVMLDataSet::removeFrame(JString id) {
        return frames.remove(id);
}


JString CVMLDataSet::print() {
        return toXML();
}

JString CVMLDataSet::toXML() {
        JString xml;
        CVMLFrame* frame;

        for (frame = (CVMLFrame*) frames.getFirst(); frame != NULL; frame = (CVMLFrame*) frames.getNext()) {
                // printf("[%s] ", (char*)frame->id); fflush(stdout);
                xml += frame->toXML().indentXML();
        }

        // printf("[Done] "); fflush(stdout);
        return JString::format("<dataset name=\"%s\">\n%s</dataset>\n", (char*) name.xmlStringEncode(), (char*) xml.indentXML());
}

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

        name = node->getAttribute("name");
        
        CVMLFrame* frame;
        XMLNode* subNode;

        ObjectCollection* frameNodes = node->getChildTags();
        if (frameNodes != NULL) {
                for (subNode = (XMLNode*) frameNodes->getFirst(); subNode != NULL; subNode = (XMLNode*) frameNodes->getNext()) {
                        frame = new CVMLFrame(subNode);
                        frames.put(frame->id, frame);
                }
        }

        return true;
}

int CVMLDataSet::getCount() {
        return frames.getCount();
}




bool CVMLDataSet::unitTest(int max) {

        StopWatch watch;
        watch.start();
        CVMLDataSet dataset;

        int n, m, k; // , max = 10;

        CVMLFrame* frame;
        CVMLObject* object;
        CVMLGroup* group;
        CVMLHypothesis* hyp;
        
        int count = 0;
        for (n=0; n<max; n++) {
                frame = new CVMLFrame();
                frame->id = JString(count++);

                for (m=0; m<3; m++) {
                        object = new CVMLObject();
                        object->setAppearance("Visible");
                        object->setBox(10, 20, 30, 40, 0);
                        object->setID(JString(count++));
                        for (k=0; k<3; k++) {
                                hyp = new CVMLHypothesis();
                                hyp->setID(JString(count++));
                                hyp->setLabel("Moving", "Walking", 1.0);
                                hyp->setEvaluation(1.0);
                                object->addHypothesis(hyp);
                        }
                        frame->addObject(object);

                        group = new CVMLGroup();
                        group->setAppearance("Visible");
                        group->setBox(10, 20, 30, 40, 0);
                        group->setID(JString(count++));
                        group->addMember(JString(1));
                        group->addMember(JString(2));
                        group->addMember(JString(3));
                        for (k=0; k<3; k++) {
                                hyp = new CVMLHypothesis();
                                hyp->setID(JString(count++));
                                hyp->setLabel("Moving", "Walking", 1.0);
                                hyp->setEvaluation(1.0);
                                group->addHypothesis(hyp);
                        }
                        frame->addGroup(group);
                }
                dataset.addFrame(frame);
        }

        watch.setMark(JString::format("Creating set with %d frames", max));

        if (dataset.getCount() != max) {
                printf("Dataset only contains %d frames and not %d\n", dataset.getCount(), max);
                return false;
        }

        JString xml = dataset.toXML();
        watch.setMark("DataSet toXML()");

        XMLParser parser;
        parser.parseXML(xml);
        watch.setMark("Parsing raw XML");

        XMLNode* node = parser.getRootNode();
        
        CVMLDataSet dataset2;
        dataset2.fromXML(node);
        watch.setMark("DataSet fromXML(rootnode)");

        JString xml2 = dataset.toXML();
        watch.setMark("DataSet toXML() again");

        if (!xml.equalsIgnoreCase(xml2)) {
                watch.setMark("DataSet second toXML() does not match first toXML()");
                return false;
        }
        
        watch.stop();
        printf("%s", (char*) watch.print());

        return true;
}


} // namespace cmlabs

---