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

---

Reporter.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoJob_Reporter_h
#define Impala_Core_VideoJob_Reporter_h

#include "Basis/ILog.h"
#include "Job/State.h"
#include "Util/IOBufferFile.h"
#include "Core/VideoJob/Data.h"

#include "Core/Array/Arrays.h"
#include "Core/Array/Array2dTem.h"
#include "Core/Array/Pattern/PtrFunc.h"
#include "Core/Array/WritePng.h"
#include "Core/VideoSet/VideoSet.h"

namespace Impala
{
namespace Core
{
namespace VideoJob
{

/***********************************************************************
An instance of this class can report on the management of the processing 
of a video set by generating status files.
************************************************************************/

class Reporter
{
    typedef Job::State::StateType JobStateType;

    typedef Data::VideoMeta VideoMeta;
    typedef Data::VideoJob VideoJob;

    typedef Core::Array::Array2dVec3UInt8 Array2dVec3UInt8;
    typedef Core::Array::Element::Vec3Int32 Vec3Int32;

public:

    Reporter(const Data& data, CmdOptions& options) : mData(data), mStatusImage(0)
    {
        int nImageWidth = options.GetInt("imageWidth", 320);
        if (nImageWidth<320) nImageWidth = 320;

        //mStatusImageColWidth = 1 + Max<int>(2, 320 / mData.VideoSetSize());
        //mStatusImageColWidth = 1 + Max<int>(2, 1024 / mData.VideoSetSize());
        mStatusImageColWidth = 1 + Max<int>(2, nImageWidth / mData.VideoSetSize());

        mStatusImageWidth = 1 + mStatusImageColWidth * mData.VideoSetSize();
        mStatusImageRowHeight = 1 + 12;
        mStatusImageHeight = 1 + mStatusImageRowHeight *
            mData.mProcessDef->StepCount();

        SetupImage();
    }

    ~Reporter()
    {
        delete mStatusImage;
    }

    void
    WriteVideoSet(Core::VideoSet::VideoSet* videoSet) const
    {
        std::ofstream output("videoset.xml");
        if (!output.is_open())
        {
            ILOG_ERROR("Unable to write video file report");
            return;
        }

        output << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl;
        output << "<?xml-stylesheet type=\"text/xsl\" href=\"videojobmanager.xslt\"?>" << std::endl;
        output << "<videoset>" << std::endl;
        int setSize = videoSet->NrFiles();
        for (int v = 0; v < setSize; v++)
        {
            String videoSpec = StringReplaceAll(videoSet->GetAsPath(v), "&",
                                                "&amp;", false);
            output << "  <video id=\"" << v << "\" text=\"" << videoSpec
                   << "\" />" << std::endl;
        }
        output << "</videoset>" << std::endl;
        output.close();
    }

    void
    WriteProcessDefinition() const
    {
        std::ofstream output("procdef.xml");
        if (!output.is_open())
        {
            ILOG_ERROR("Unable to write process definition report");
            return;
        }

        output << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl;
        output << "<?xml-stylesheet type=\"text/xsl\" href=\"videojobmanager.xslt\"?>" << std::endl;
        output << "<procdef>" << std::endl;
        for (int s = 0; s < mData.mProcessDef->StepCount(); s++)
            output << "  <step id=\"" << s << "\" text=\""
                   << mData.mProcessDef->GetStep(s) << "\" />" << std::endl;
        output << "</procdef>" << std::endl;
        output.close();
    }

    void
    WriteReportStatus() const
    {
        // write status overview image

        static const Vec3Int32 colorStateExcluded(128, 128, 128); // dk grey
        static const Vec3Int32 colorStateInitial(190, 190, 190); // lt grey
        static const Vec3Int32 colorStateScheduled(128, 128, 0);
        static const Vec3Int32 colorStateRunning(255, 255, 0); // gold
        static const Vec3Int32 colorStateCompleted(0, 255, 0); // lt green
        static const Vec3Int32 colorStateFailed(255, 0, 0); // red
        static const Vec3Int32 colorStateUnknown(0, 0, 255); 

        const Vec3Int32* color = 0;

        for (int stepID = 0; stepID < mData.mProcessDef->StepCount(); stepID++)
        {
            for (int vidID = 0; vidID < mData.VideoSetSize(); vidID++)
            {
                // determine status color 
                if (mData.WasInitiallyMaskedOut(vidID))
                {
                    color = &colorStateExcluded;
                }
                else 
                {
                    const VideoMeta& video = mData.mVideos.find(vidID)->second;
                    if (stepID >= video.jobs.size())
                    {
                        if (video.discarded)
                            color = &colorStateExcluded;
                        else
                            color = &colorStateInitial;
                    }
                    else
                    {
                        VideoJob* const job = video.jobs[stepID];
                        switch (job->state)
                        {
                            case Job::State::CREATED:
                            case Job::State::SUBMITTED:
                            case Job::State::SCHEDULED:
                            case Job::State::RESCHEDULED:
                                color = &colorStateScheduled;
                                break;
                            case Job::State::RUNNING:
                                color = &colorStateRunning;
                                break;
                            case Job::State::TERMINATED_NRM:
                                if (job->exitCode != 0)
                                    color = &colorStateFailed;
                                else
                                    color = &colorStateCompleted;
                                break;
                            case Job::State::TERMINATED_ABNRM:
                                color = &colorStateFailed;
                                break;
                            default:
                                ILOG_ERROR("Reporting unexpected job state: "
                                           << job->state);
                                color = &colorStateUnknown;
                        }
                    }
                }

                // set color to relevant status pixels
                int xOffset = vidID * mStatusImageColWidth + 1;
                int yOffset = stepID * mStatusImageRowHeight + 1;
                for (int x = 0; x < mStatusImageColWidth-1; x++)
                {
                    int xAbs = xOffset + x;
                    for (int y = 0; y < mStatusImageRowHeight-1; y++)
                    {
                       int yAbs = yOffset + y;
                       Array::Pattern::PtrWrite(mStatusImage->CPB(xAbs, yAbs),
                                                *color);
                    }
                }
            }
        }

        CString imageFileName = "status.png";
        {
            Util::IOBufferFile buffer(imageFileName, false, false);
            Core::Array::WritePng(mStatusImage, &buffer);
        }


        // Write data to xml

        std::ofstream output("vpdata.xml");
        if (!output.is_open())
        {
            ILOG_ERROR("unable to write report");
            return;
        }

        output << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl;
        output << "<?xml-stylesheet type=\"text/xsl\" href=\"videojobmanager.xslt\"?>" << std::endl;

        output << "<vpdata>" << std::endl << std::endl;

        output << "<infos>" << std::endl;
        output << "  <info label=\"video set file" << "\" text=\""
               << mData.mVideoSetName << "\"/>" << std::endl;
        output << "  <info label=\"number of videos" << "\" text=\""
               << mData.mVideoSetSize << "\"/>" << std::endl;
        output << "  <info label=\"process definition file" << "\" text=\""
               << mData.mProcessDefFile << "\"/>" << std::endl;
        output << "  <info label=\"number of process steps" << "\" text=\""
               << mData.mProcessDef->StepCount() << "\"/>" << std::endl;
        output << "  <info label=\"job server address" << "\" text=\""
               << mData.mServerName << ':' << mData.mPort << "\"/>" << std::endl;
        //output << "  <info label=\"" << ".." << "\" text=\"" << ".."
        // << "\"/>" << std::endl;
        output << "</infos>" << std::endl << std::endl;

        output << "<jobs>" << std::endl;
        for (int j = 0; j < mData.mAllJobs.size(); j++)
        {
            VideoJob* job = mData.mAllJobs[j];
            output << "  <job id=\"" << job->id << "\" video=\""
                   << job->videoNr << "\" step=\"" << job->stepNr
                   << "\" state=\"" << job->state << "\" exit=\""
                   << job->exitCode << "\"/>" << std::endl;
        }
        output << "</jobs>" << std::endl << std::endl;

        output << "</vpdata>" << std::endl;

        output.close();
    }

private:

    void SetupImage()
    {
        static const Vec3Int32 colorBlack(0, 0, 0); 

        mStatusImage = Core::Array::ArrayCreate<Array2dVec3UInt8>
            (mStatusImageWidth, mStatusImageHeight, 0, 0);
        
        // draw vertical grid lines
        for (int x = 0; x <= mStatusImageWidth; x += mStatusImageColWidth)
            for (int y = 0; y < mStatusImageHeight; y++)
                Array::Pattern::PtrWrite(mStatusImage->CPB(x, y), colorBlack);

        // draw horizontal grid lines
        for (int y = 0; y <= mStatusImageHeight; y += mStatusImageRowHeight)
            for (int x = 0; x < mStatusImageWidth; x++)
                Array::Pattern::PtrWrite(mStatusImage->CPB(x, y), colorBlack);
    }

    ILOG_VAR_DECL;

    const Data& mData;

    int mStatusImageColWidth;
    int mStatusImageWidth;
    int mStatusImageRowHeight;
    int mStatusImageHeight;

    Array2dVec3UInt8* mStatusImage;

}; // class

ILOG_VAR_INIT(Reporter, Impala.Core.VideoJob);

} // namespace 
} // namespace 
} // namespace 

#endif

---