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

---

RegionsOfInterestInfo.h

Go to the documentation of this file.

/******************************************************************************
 *
 * Application: An instance of this class may hold meta-information on regions 
 *              of interest for multiple frames of multiple video's.
 *              This implementation uses a description file as used by Thang
 *              Viet Pham on person detection.
 *
 * Primary author(s): Sander Kruseman
 ******************************************************************************/

#ifndef Impala_Application_SDash_RegionsOfInterestInfo_h
#define Impala_Application_SDash_RegionsOfInterestInfo_h

#include <string>
#include <vector>
#include <map>

#include "Util/IOBuffer.h"
#include "Util/IOBufferFile.h"

#include "Core/Geometry/Rectangle.h"

#include "Application/sdash/RoiInfo.h"

namespace Impala {
namespace Application {
namespace SDash {

class RegionsOfInterestInfo {

public:

    typedef Core::Geometry::Rectangle Rectangle;

    struct ScaledRegion
    {
        float left, top, width, height;
    };

    RegionsOfInterestInfo(
        std::string roiInfoFile, 
        int nrOfVideosToCollectRoisFor,
        const int* const maxFrames,
        bool invertYaxis = false,
        bool makeSizesEven = false) :
            mNrOfVideos(nrOfVideosToCollectRoisFor),
            mFrameWidth(ROI_FRAME_WIDTH), 
            mFrameHeight(ROI_FRAME_HEIGHT)
    {
        std::cout << "reading regions of interest info from " << roiInfoFile << std::endl;

        // create an empty map for every video;
        // silly impl; should add maps on the fly
        for (int v = 0; v < mNrOfVideos; v++)
        {
            mRois.push_back(std::map< int, std::vector<Rectangle> >());
            mRoiCountPerVideo[v] = 0;
        }

        const bool readOnly = true;
        const bool readIntoMem = false;
        Util::IOBufferFile ioBuffer(roiInfoFile, readOnly, readIntoMem);
        const int REC_SIZE = 6172; // record size for detected person information

        // limitation of metadata to store:
        //static const float ESTIMATED_FPS = 2.6f; // SK: to be on the safe side
        //static const int ESTIMATED_FPM = (int) (ESTIMATED_FPS * 60.0f);
        //static const int MAX_FRAME_NR = MAX_MINUTES_OF_VIDEO * ESTIMATED_FPM;
        //int maxFrameNr = videoLengthSecs * ESTIMATED_FPM;
        //int maxFrameNr = videoLengthSecs * ESTIMATED_FPS;

        unsigned char byteBuffer[REC_SIZE];
        long position = 0;
        for (int i = 0; i < ROI_INFO_COUNT; i++)
        {
            const int bytesOfInterest = REC_SIZE;
            ioBuffer.SetPosition(position);
            int bytesRead = ioBuffer.Read(byteBuffer, bytesOfInterest);
            if (bytesRead < bytesOfInterest)
                throw std::logic_error("unable to read complete roi info record ");

            int video = byteBuffer[2] * 256 + byteBuffer[3];
            int frame = byteBuffer[6] * 256 + byteBuffer[7] - 1;

            //if (video < nrOfVideosToCollectRoisFor && frame <= MAX_FRAME_NR)
            if (video < nrOfVideosToCollectRoisFor && frame <= maxFrames[video])
            {
                int top = byteBuffer[10] * 256 + byteBuffer[11];
                int left = byteBuffer[14] * 256 + byteBuffer[15];
                int bottom = byteBuffer[18] * 256 + byteBuffer[19];
                int right = byteBuffer[22] * 256 + byteBuffer[23];
                Rectangle region(left, top, right, bottom);

                if (makeSizesEven)
                {
                    int origWidth = region.Width();
                    int origHeight= region.Height();

                    if (origWidth % 2 != 0)
                    {
                        region.mRight -= 1;
                        region.mBottom = region.mTop + (2 * region.Width()) - 1;
                    }
                    else if (origHeight % 4 != 0)
                    {
                        region.mBottom -= origHeight % 4;
                        region.mRight = region.mLeft + (region.Height() / 2) - 1;
                    }

                    //int newWidth = region.Width();
                    //int newHeight= region.Height();
                }

                if (invertYaxis)
                {
                    int topUpward = mFrameHeight - region.mBottom - 1;
                    int bottomUpward = mFrameHeight - region.mTop - 1;
                    region.mTop = topUpward;
                    region.mBottom = bottomUpward;
                }

                std::map<int, std::vector<Rectangle> >& roisInVideo = mRois[video];
                std::vector<Rectangle>& roisInFrame = roisInVideo[frame];
                roisInFrame.push_back(region);
            }

            mRoiCountPerVideo[video] += 1;
            position += REC_SIZE;
        }

        std::cout << "finished reading regions of interest info" << std::endl;
    }

    ~RegionsOfInterestInfo()
    {
    }

    int GetFrameWidth() const
    {
        return mFrameWidth;
    }

    int GetFrameHeight() const
    {
        return mFrameHeight;
    }

    int GetAbsRoiNr(int videoId, int frameNr, int roiNr) const
    {
        int absRoiNr = 0;

        if (videoId >= mNrOfVideos)
            return -1;

        for (int v = 0; v < videoId; v++)
            absRoiNr += ROIS_PER_VIDEO[v];

        // add roi counts for all lower frame nrs for specified video id
        const std::map<int, std::vector<Rectangle> >& roisForVideo = mRois[videoId];
        // note that the map is ordered by frame nr
        std::map<int, std::vector<Rectangle> >::const_iterator frameIter = roisForVideo.begin();
        while (frameIter != roisForVideo.end())
        {
            if (frameIter->first < frameNr)
                absRoiNr += frameIter->second.size();
            else
                break;
            frameIter++;
        }

        if (frameIter == roisForVideo.end() || frameIter->first > frameNr)
            return -1; // no frames for requested video, or no roi's for requested frame

        if (frameIter->second.size() < roiNr)
            return -1; // roi nr invalid for requested frame

        // add roi nr for the specified frame
        absRoiNr += roiNr;

        return absRoiNr;
    }

    // parameter should be based on valid result of call to 
    // GetAbsRoiNr(). This mainly follows from the implementation
    // using nr of video's to collect roi's for.
    RoiInfo GetRoiInfo(int absRoiNr) const
    {
        RoiInfo roiInfo; // data structure to return

        int runningRoiNr = absRoiNr;

        // determine roi nr relative to video:
        for (int v = 0; v < mNrOfVideos; v++)
        {
            if (runningRoiNr < ROIS_PER_VIDEO[v])
            {
                roiInfo.videoId = v;
                break;
            }
            runningRoiNr -= ROIS_PER_VIDEO[v];
        }

        // determine roi nr relative to frame:
        const std::map<int, std::vector<Rectangle> >& roisForVideo = mRois[roiInfo.videoId];
        // note that the map is ordered by frame nr
        std::map<int, std::vector<Rectangle> >::const_iterator frameIter = roisForVideo.begin();
        while (frameIter != roisForVideo.end())
        {
            int frameRois = frameIter->second.size();
            if (runningRoiNr < frameRois)
                break;
            runningRoiNr -= frameRois;
            frameIter++;
        }

        if (frameIter != roisForVideo.end() && runningRoiNr >= 0 && runningRoiNr < frameIter->second.size())
        {
            roiInfo.frameNr = frameIter->first;
            roiInfo.roiNr = runningRoiNr;
        }
        else
        {
            roiInfo.videoId = -1;
            roiInfo.frameNr = -1;
            roiInfo.roiNr = -1;
        }

        return roiInfo;
    }

    const std::vector<Rectangle>& GetRois(int video, int frame) const
    {
        if (video < mNrOfVideos)
        {
            const std::map<int, std::vector<Rectangle> >& roisForVideo = mRois[video];
            std::map<int, std::vector<Rectangle> >::const_iterator pos = roisForVideo.find(frame);
            if (pos == roisForVideo.end())
                return mEmptyList;
            else
                return pos->second;
        }
        else
            return mEmptyList;
    }

    std::vector<ScaledRegion> GetRoisScaled(int video, int frame, float scale = 1.0f) const
    {
        std::vector<ScaledRegion> result;
        const std::vector<Rectangle>& frameRois = GetRois(video, frame);
        int nrOfRois = frameRois.size();
        for (int i = 0; i < nrOfRois; i++)
        {
            const Rectangle& roi = frameRois[i];
            ScaledRegion scaledRoi;
            scaledRoi.left = (float) roi.mLeft * scale;
            scaledRoi.top = (float) roi.mTop * scale;
            scaledRoi.width = (float) roi.Width() * scale;
            scaledRoi.height = (float) roi.Height() * scale;
            result.push_back(scaledRoi);
        }
        return result;
    }

private:

    static const int ROI_FRAME_WIDTH;
    static const int ROI_FRAME_HEIGHT;
    static const int ROI_INFO_COUNT; // total nr of defined roi's
    static const int ROIS_PER_VIDEO[12];

    int mNrOfVideos;
    int mFrameWidth;
    int mFrameHeight;

    std::vector< std::map<int, std::vector<Rectangle> > > mRois;
    const std::vector<Rectangle> mEmptyList;
    std::map<int, int> mRoiCountPerVideo;

}; //class RegionsOfInterestInfo

const int RegionsOfInterestInfo::ROI_FRAME_WIDTH = 696;
const int RegionsOfInterestInfo::ROI_FRAME_HEIGHT = 576;
const int RegionsOfInterestInfo::ROI_INFO_COUNT = 33494; // total nr of defined roi's
const int RegionsOfInterestInfo::ROIS_PER_VIDEO[12] = {2472, 452, 3473, 2921, 653, 4147, 3328, 4542, 25, 4707, 3794, 2980};

} // namespace SDash
} // namespace Application
} // namespace Impala

#endif

---