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

---

RegionOfInterestExtractor.cpp

Go to the documentation of this file.

/******************************************************************************
 *
 * Application: Extracts rois of interest from images, for the
 *              Surveillance Dashboard (MultimediaN project 6);
 *              as seperate files.
 *
 * Primary author(s): Sander Kruseman
 ******************************************************************************/

#include <string>
#include <vector>
#include <iostream>
#include <sstream>

#include "Application/sdash/RegionsOfInterestInfo.h"

#include "Core/Array/Arrays.h"
#include "Core/Geometry/Rectangle.h"
#include "Core/Array/ReadFile.h"
#include "Core/Array/WriteJpg.h"
#include "Core/Array/MakeRoi.h"

#include "Util/DataBaseReadString.h"

namespace Impala 
{
namespace Application 
{
namespace SDash 
{

//static const std::string ROI_INFO_FILE = "D:/GoldenDemoData/thang/roi/boxes-b.bin";
static const std::string ROI_INFO_FILE = "U:/vietp/nfi-demo/data/boxes-b.bin";

// Note: this should contain the "original" png's:
//static const std::string VIDEO_BASE_PATH = "D:/GoldenDemoData/thang/video/";
static const std::string VIDEO_BASE_PATH = "U:/vietp/nfi-cams/";

//static const std::string FRAME_LISTS_PATH = "D:/GoldenDemoData/thang/videolist/original/";
static const std::string FRAME_LISTS_PATH = VIDEO_BASE_PATH;

//static const int VIDEO_COUNT = 12;
static const int VIDEO_COUNT = 1;

static const std::string FRAME_LIST_POSTFIX = ".list-short";

static const std::string INDIV_FRAME_FOLDERS[] = {
    "hd8-cam01",
    "hd8-cam02",
    "hd8-cam03",
    "hd8-cam04",
    "hd8-cam05",
    "hd8-cam06",
    "hd8-cam07",
    "hd9-cam01",
    "hd9-cam02",
    "hd9-cam03",
    "hd9-cam08",
    "hd9-cam09"
};

// Number of frames in each video
static const int FRAMES_PER_VIDEO[] = {
    12322, 8599, 12941, 12841, 12664, 12477, 12225, 10605, 10605, 10614,
    10609, 10603};

// Number of rois in each video
static const int ROIS_PER_VIDEO[] = {
    2472, 452, 3473, 2921, 653, 4147, 3328, 4542, 25, 4707, 3794, 2980};


using namespace Util;

class RoiExtractor
{

typedef Core::Geometry::Rectangle Rectangle;
typedef Core::Array::Array2dVec3UInt8 Array2dVec3UInt8;

public:

    RoiExtractor(const RegionsOfInterestInfo& rois) : mRois(rois)
        {
    }

    void Extract()
    {
        Array2dVec3UInt8 *frameData = 0;

        for (int video = 0; video < VIDEO_COUNT; video++)
        {
            std::cout << "processing video #" << video << std::endl;

            std::string frameListFile = FRAME_LISTS_PATH + INDIV_FRAME_FOLDERS[video] + FRAME_LIST_POSTFIX;
            std::vector<std::string> frameFileNames;
            Util::DatabaseReadStrings(frameFileNames, frameListFile,
                                      &Util::Database::GetInstance());
            int nrOfFrames = frameFileNames.size();
            if (nrOfFrames != FRAMES_PER_VIDEO[video])
                std::cerr << "incorrect frame count for video #" << video << ": " << nrOfFrames << " vs. " << FRAMES_PER_VIDEO[video] << std::endl;

            int roisForVideo = 0;
            for (int frame = 0; frame < nrOfFrames; frame++)
            {
                if (frame % 1000 == 0)
                    std::cout << "  processing frame #" << frame << std::endl;

                const std::vector<Rectangle>& rois = mRois.GetRois(video, frame);
                if (rois.empty())
                    continue;

                // retrieve frame
                std::string frameFile = frameFileNames[frame];
                //std::string framePath = VIDEO_BASE_PATH + frameFile; // SK: op laptop
                std::string framePath = VIDEO_BASE_PATH + INDIV_FRAME_FOLDERS[video] + "/" + frameFile; // op UvA
                Core::Array::ReadFile<Array2dVec3UInt8>(frameData, framePath);

                // extract rois of interest from frame
                int nrOfRegions = rois.size();
                for (int seqNr = 0; seqNr < nrOfRegions; seqNr++)
                {
                    Rectangle region(rois[seqNr]);

                    // create jpg for region
                    Array2dVec3UInt8 *roi = Core::Array::MakeRoi<Array2dVec3UInt8>(frameData, region);

                    // write region jpg to archive
                    // ... not yet implemented.

                    // write region jpg as single file
                    std::ostringstream regionFile;
                    regionFile << "roi/video" << video << "/roi_" << video << '_' << frame<< '_' << seqNr << ".jpg";
                    Core::Array::WriteJpg(roi, regionFile.str());
                }
                roisForVideo += nrOfRegions;
            }
            if (roisForVideo != ROIS_PER_VIDEO[video])
                std::cerr << "incorrect roi count for video #" << video << ": " << roisForVideo << " vs. " << ROIS_PER_VIDEO[video] << std::endl;
        }

        // release frame data
        delete frameData;
        frameData = 0;
    }

private:

    RegionsOfInterestInfo mRois;

}; //class RoiExtractor

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


using namespace Impala::Application::SDash;

int main(int argc, char* argv[])
{
    std::cout << "reading regions-of-interest info file..." << std::endl;
    RegionsOfInterestInfo rois(ROI_INFO_FILE, VIDEO_COUNT, 32); // SK: 32 minutes to be on the safe side
    RoiExtractor roiExtr(rois);
    std::cout << "extracting regions-of-interest..." << std::endl;
    roiExtr.Extract();
    std::cout << "ready." << std::endl;
    return 0;
}

---