ImageFeatures.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 "ImageFeatures.h"

namespace cmlabs {

ImageFeature::ImageFeature() {}
ImageFeature::~ImageFeature() {}




//////////////////////////////////////////////////////////////////////////
//! The Point type ImageFeature
//////////////////////////////////////////////////////////////////////////

ImagePointFeature::ImagePointFeature(JString creatorName, JTime t, double depth) {
        featureType = FEATURE_POINT;
        creator = creatorName;
        frameTime = t;
        planeDepth = depth;
}

ImagePointFeature::~ImagePointFeature() {
}

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

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

Object* ImagePointFeature::clone() const {
        ImagePointFeature* p = new ImagePointFeature(creator, frameTime, planeDepth);
        *p = *this;
        return p;
}

PointFloat ImagePointFeature::getPoint() {
        return point;
}

Color ImagePointFeature::getColor() {
        return color;
}

bool ImagePointFeature::setPoint(PointFloat p) {
        point = p;
        return true;
}

bool ImagePointFeature::setColor(Color c) {
        color = c;
        return true;
}

JString ImagePointFeature::print() {
        return JString::format("PointFeature: Point:%s Color:%s", (char*) point.print(), (char*) color.print());
}

JString ImagePointFeature::toXML() {
        return JString::format("<pointfeature>\n%s%s</pointfeature>", (char*) point.toXML().indentXML(), (char*) color.toXML().indentXML());
}

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

        XMLNode* xmlNode = node->getChildNode("pointfloat");
        if (xmlNode == NULL) return false;
        point.fromXML(xmlNode);
        xmlNode = node->getChildNode("color");
        if (xmlNode == NULL) return false;
        color.fromXML(xmlNode);

        return true;
}










//////////////////////////////////////////////////////////////////////////
//! The Line type ImageFeature
//////////////////////////////////////////////////////////////////////////

ImageLineFeature::ImageLineFeature(JString creatorName, JTime t, double depth) {
        featureType = FEATURE_LINE;
        creator = creatorName;
        frameTime = t;
        planeDepth = depth;
}

ImageLineFeature::~ImageLineFeature() {
}

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

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

Object* ImageLineFeature::clone() const {
        ImageLineFeature* l = new ImageLineFeature(creator, frameTime, planeDepth);
        *l = *this;
        return l;
}

Line ImageLineFeature::getLine() {
        return line;
}

Color ImageLineFeature::getAverageColor() {
        return colorAverage;
}

Color ImageLineFeature::getColorStartPoint() {
        return colorStartPoint;
}

Color ImageLineFeature::getColorEndPoint() {
        return colorEndPoint;
}

Color ImageLineFeature::getColorLeftEdge() {
        return colorLeftEdge;
}

Color ImageLineFeature::getColorRightEdge() {
        return colorRightEdge;
}

bool ImageLineFeature::setColor(Color c) {
        colorAverage = c;
        return true;
}

bool ImageLineFeature::setColor(Color colorAtStartPoint, Color colorAtEndPoint) {
        colorStartPoint = colorAtStartPoint;
        colorEndPoint = colorAtEndPoint;
        int red = (colorAtStartPoint.r + colorAtEndPoint.r) / 2;
        int green = (colorAtStartPoint.g + colorAtEndPoint.g) / 2;
        int blue = (colorAtStartPoint.b + colorAtEndPoint.b) / 2;
        colorAverage = Color(red, green, blue);
        return true;
}

bool ImageLineFeature::setColor(Color colorAtStartPoint, Color colorAtEndPoint, Color colorAtLeftEdge, Color colorAtRightEdge) {
        colorStartPoint = colorAtStartPoint;
        colorEndPoint = colorAtEndPoint;
        colorLeftEdge = colorAtLeftEdge;
        colorRightEdge = colorAtRightEdge;
        int red = (colorAtStartPoint.r + colorAtEndPoint.r + colorAtLeftEdge.r + colorAtRightEdge.r) / 4;
        int green = (colorAtStartPoint.g + colorAtEndPoint.g + colorAtLeftEdge.g + colorAtRightEdge.g) / 4;
        int blue = (colorAtStartPoint.b + colorAtEndPoint.b + colorAtLeftEdge.b + colorAtRightEdge.b) / 4;
        colorAverage = Color(red, green, blue);
        return true;
}


JString ImageLineFeature::print() {
        return JString::format("LineFeature: Line:%s AvgColor:%s", (char*) line.print(), (char*) colorAverage.print());
}

JString ImageLineFeature::toXML() {
        JString col1 = JString::format("<startpointcolor>\n%s</startpointcolor>\n", (char*) colorStartPoint.toXML().indentXML());
        JString col2 = JString::format("<endpointcolor>\n%s</endpointcolor>\n", (char*) colorEndPoint.toXML().indentXML());
        JString col3 = JString::format("<leftedgecolor>\n%s</leftedgecolor>\n", (char*) colorLeftEdge.toXML().indentXML());
        JString col4 = JString::format("<rightedgecolor>\n%s</rightedgecolor>\n", (char*) colorRightEdge.toXML().indentXML());
        return JString::format("<linefeature>\n%s%s%s%s%s%s</linefeature>", (char*) line.toXML().indentXML(), (char*) colorAverage.toXML().indentXML(), (char*) col1.indentXML(), (char*) col2.indentXML(), (char*) col3.indentXML(), (char*) col4.indentXML());
}

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

        XMLNode* xmlNode;
        XMLNode* subNode;

        xmlNode = node->getChildNode("line");
        if (xmlNode == NULL) return false;
        line.fromXML(xmlNode);

        xmlNode = node->getChildNode("color");
        if (xmlNode == NULL) return false;
        colorAverage.fromXML(xmlNode);

        xmlNode = node->getChildNode("startpointcolor");
        if (xmlNode == NULL) return false;
        subNode = xmlNode->getChildNode("color");
        if (subNode == NULL) return false;
        colorStartPoint.fromXML(xmlNode);

        xmlNode = node->getChildNode("endpointcolor");
        if (xmlNode == NULL) return false;
        subNode = xmlNode->getChildNode("color");
        if (subNode == NULL) return false;
        colorEndPoint.fromXML(xmlNode);

        xmlNode = node->getChildNode("leftedgecolor");
        if (xmlNode == NULL) return false;
        subNode = xmlNode->getChildNode("color");
        if (subNode == NULL) return false;
        colorLeftEdge.fromXML(xmlNode);

        xmlNode = node->getChildNode("rightedgecolor");
        if (xmlNode == NULL) return false;
        subNode = xmlNode->getChildNode("color");
        if (subNode == NULL) return false;
        colorRightEdge.fromXML(xmlNode);

        return true;
}














//////////////////////////////////////////////////////////////////////////
//! The PolyLine type ImageFeature
//////////////////////////////////////////////////////////////////////////

ImagePolyLineFeature::ImagePolyLineFeature(JString creatorName, JTime t, double depth) {
        featureType = FEATURE_POLYLINE;
        creator = creatorName;
        frameTime = t;
        planeDepth = depth;
}

ImagePolyLineFeature::~ImagePolyLineFeature() {
}

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

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

Object* ImagePolyLineFeature::clone() const {
        ImagePolyLineFeature* l = new ImagePolyLineFeature(creator, frameTime, planeDepth);
        *l = *this;
        return l;
}


PolyLine ImagePolyLineFeature::getPolyLine() {
        return polyLine;
}

Color ImagePolyLineFeature::getColor() {
        return color;
}

bool ImagePolyLineFeature::setPolyLine(PolyLine p) {
        polyLine = p;
        return true;
}

bool ImagePolyLineFeature::setColor(Color c) {
        color = c;
        return true;
}




JString ImagePolyLineFeature::print() {
        return JString::format("PolyLineFeature: PolyLine:%s Color:%s", (char*) polyLine.print(), (char*) color.print());
}

JString ImagePolyLineFeature::toXML() {
        return JString::format("<polylinefeature>\n%s%s</polylinefeature>", (char*) polyLine.toXML().indentXML(), (char*) color.toXML().indentXML());
}

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

        XMLNode* xmlNode = node->getChildNode("polyline");
        if (xmlNode == NULL) return false;
        polyLine.fromXML(xmlNode);
        xmlNode = node->getChildNode("color");
        if (xmlNode == NULL) return false;
        color.fromXML(xmlNode);

        return true;
}











} // namespace cmlabs

---