|| || || || || || || ||

---

Tag.h

Go to the documentation of this file.

/*
 * Tag.h
 *
 *  Created on: 9-jan-2009
 *      Author: dodijk
 */

#ifndef TAG_H_
#define TAG_H_

#include <string>
#include "Util/XmlDoc.h"
#include "Persistency/XmlFileReader.h"

#include "Photo.h"

namespace Impala {
namespace Application {
namespace TagsLife {

using namespace std;

class Tag : public Util::XmlDoc {
public:
        string tag;
        int mostUsedWeek, mostUsedCount, mostViewedWeek, mostViewedCount, nrOfPhotos, lastWeek;
        time_t firstUse, lastUse;
        Tag(string t) {
                tag = t;
                mostUsedCount = mostViewedCount = nrOfPhotos = lastWeek = 0;
                readTag("Data/" + tag + "_analysis.xml");
                readGeo("Data/" + tag + "_analysis_geo.xml");
        }
        //virtual ~Tag();
        Photo* mostPopularPhotos[3];


    class BoundingBox {
    public:
      string boxid;
      int count;
      float left, right, top, bottom;
      float centerLongitude, centerLatitude;

      BoundingBox(string id, int c, float l, float r, float t, float b) :
                  boxid(id), count(c), left(l), right(r), top(t), bottom(b)
                  {
                          centerLongitude = (l+r)/2;
                          centerLatitude = (t+b)/2;
      }

    };
    typedef map<string, BoundingBox*> geoDataType;

        class Week {
    public:
        Week(uint f, uint u, uint v, Photo* p) : flickrWeek(f), usage(u), views(v) {
                mostPopularPhoto = p;
                //ILOG_DEBUG("flickrweek = " << f << "; usage = " << u << "; views = " << v);
        }
        uint flickrWeek;
        uint usage;
        uint views;
        Photo* mostPopularPhoto;
        geoDataType geoData;
    };
    typedef map<uint, Week*> weekStatsType;
    weekStatsType weekStats;

    static string formatDate(time_t* date) {
        char *months[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
        tm* dateTm = localtime(date);
                string txt = MakeString(months[dateTm->tm_mon]) + " " + MakeString(dateTm->tm_mday) + ", ";
                           txt+= MakeString(dateTm->tm_year+1900);
                return txt;
    }
    static string flickrWeekToString(int flickrweek) {
        static time_t FLICKR_EPOCH = 1072933200;
        static time_t MS_IN_WEEK = 604800;
        time_t start = FLICKR_EPOCH + flickrweek*MS_IN_WEEK;
        time_t end = start + 0.86*MS_IN_WEEK; // 0.86 ~ 6/7
        string txt = formatDate(&start) + " - " + formatDate(&end);
        return txt;
    }

    geoDataType getGeoData(int minVal, int maxVal) {
                geoDataType geoData;
                for(int i=minVal; i < maxVal; i++) {
                  if(weekStats.count(i) == 0) continue;
                  for(geoDataType::iterator iter = weekStats[i]->geoData.begin();
                          iter != weekStats[i]->geoData.end(); iter++) {
                          if(geoData.count(iter->first)) {
                                  geoData[iter->first]->count += iter->second->count;
                          } else {
                                  geoData[iter->first] = iter->second;
                          }
                  }
                }
                return(geoData);
        }

    map<string, vector<string> > relatedTags;

    int readRelated() {
        return readRelated("Data/Flickr." + tag + ".xml");
    }

private:
    void readTag(string xmlFile) {
        Persistency::XmlFileReader reader;
        ILOG_INFO("reading XML file: " + xmlFile);
                DOMDocument* doc = reader.Read(xmlFile);
                DOMNode* root = GetChildNode(doc, "tagdata", true);

                //<tagdata firstusedate="1100909103" lastusedate="1229559285" nrofphotos="4742"
                //tag="amywinehouse" version="0.99">

                nrOfPhotos = atoi(GetAttributeValue(root, "nrofphotos"));
                firstUse = atoi(GetAttributeValue(root, "firstusedate"));
                lastUse = atoi(GetAttributeValue(root, "lastusedate"));

                string s = ctime(&firstUse);

                vector<DOMNode*> mostpopularphotos = GetChildNodes(root, "mostpopularphoto");
                ILOG_INFO("mostpopularphotos.size = " << mostpopularphotos.size());
                for(uint i=0; i < mostpopularphotos.size(); i++) {
                        //<mostpopularphoto rank="1">
                        DOMNode* photo = GetChildNode(mostpopularphotos[i], "photo", true);
                        Photo* p = new Photo(photo);
                        mostPopularPhotos[i] = p;
                }
                vector<DOMNode*> weekstats = GetChildNodes(root, "weekstats");
                ILOG_INFO("weekstats.size = " << weekstats.size());
                for(uint i=0; i < weekstats.size(); i++) {
                        uint flickrWeek = atoi(GetAttributeValue(weekstats[i], "flickrweek"));
                        uint usage = atoi(GetAttributeValue(weekstats[i], "usage"));
                        uint views = atoi(GetAttributeValue(weekstats[i], "views"));
                        // <weekstats flickrweek="84" usage="1" views="43340">
                        if(views > mostViewedCount) {
                                mostViewedWeek = flickrWeek;
                                mostViewedCount = views;
                        }
                        if(usage > mostUsedCount) {
                                mostUsedWeek = flickrWeek;
                                mostUsedCount = usage;
                        }

                        DOMNode* photo = GetChildNode(weekstats[i], "mostpopularphoto", true);
                        Photo* p = new Photo(photo);
                        Week* w = new Week(flickrWeek, usage, views, p);
                        weekStats[flickrWeek] = w;
                        lastWeek = flickrWeek;
                }
    }

    void readGeo(string xmlFile) {
        Persistency::XmlFileReader reader;
        ILOG_INFO("reading XML file: " + xmlFile);
        DOMDocument* doc = reader.Read(xmlFile, false);
        if(doc == 0) {
                ILOG_ERROR("Failed to read XML file: " + xmlFile);
                return;
        }
                DOMNode* root = GetChildNode(doc, "geodata", true);

                vector<DOMNode*> weekstats = GetChildNodes(root, "weekstats");
                ILOG_INFO("GEO: weekstats.size = " << weekstats.size());
                for(uint i=0; i < weekstats.size(); i++) {
                        uint flickrWeek = atoi(GetAttributeValue(weekstats[i], "flickrweek"));

                        vector<DOMNode*> bboxes = GetChildNodes(weekstats[i], "bbox");
                        geoDataType boxes;
                        for(uint j=0; j < bboxes.size(); j++) {
                                uint count = atoi(GetAttributeValue(bboxes[j], "count"));
                                if(count == 0) continue;
                                string boxid = GetAttributeValue(bboxes[j], "boxid");
                                float left = atof(GetAttributeValue(bboxes[j], "left"));
                                float right = atof(GetAttributeValue(bboxes[j], "right"));
                                float top = atof(GetAttributeValue(bboxes[j], "top"));
                                float bottom = atof(GetAttributeValue(bboxes[j], "bottom"));

                                boxes[boxid] = new BoundingBox(boxid, count, left, right, top, bottom);
                        }
                        if(boxes.size() > 0) weekStats[flickrWeek]->geoData = boxes;
                }
    }

    int readRelated(string xmlFile) {
                Persistency::XmlFileReader reader;
                ILOG_INFO("reading XML file: " + xmlFile);
        DOMDocument* doc = reader.Read(xmlFile, false);
        if(doc == 0) {
                ILOG_ERROR("Failed to read XML file: " + xmlFile);
                return -1;
        }
                DOMNode* root = GetChildNode(GetChildNode(doc,"rsp", true), "tags", true);

                vector<DOMNode*> tags = GetChildNodes(root, "tag");
                ILOG_INFO("Related: tag.size = " << tags.size());
                for(uint i=0; i < tags.size(); i++) {
                        relatedTags[tag].push_back(GetElementValue(tags[i]));
                }

        return 0;
    }

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(Tag, Impala.Application.TagsLife);

}
}
}

#endif /* TAG_H_ */

---