XML应用

/*****************************************************************************/
/**
 * @file        CTagFile.h
 * @brief        CTagFile クラスヘッダーファイル
 *
 * @author        Yan Hongwei
 * @date        2008/08/15 新規作成
 *
 */
/* Copyright (C) 2008 informedia Co.itd.All right reserved. */
/*****************************************************************************/

#pragma once

#import <MSXML3.dll> named_guids
#include "FrameRoiInfo.h"
#include "FrameRateInfo.h"
#include "IProgressCallBack.h"

/**
 * @brief        CTagFile クラス
 *
 * TAGファイルクラス
 * @author        Yan Hongwei
 */
class CTagFile
{
public:
    /** コンストラクタ */
                    CTagFile(void);
    /** デストラクタ */
    virtual            ~CTagFile(void);

private:
    /** コピーコンストラクタ*/
                    CTagFile(CTagFile &file);
                    CTagFile& operator=(CTagFile &file);
public:
    /** @brief 指定されたパスのTAGファイルをロードする */
    BOOL            Load(LPCTSTR szFilePath, IProgressCallBack* pProgressCallBack = NULL);

    /** @brief フレームのレートメッセージを取得する */
    CFrameRateInfo*    GetFrameRateInfo();

    /** @brief 変換モードを取得する */
    long            GetMode();

    /** @brief RoiTypeが最初に現れるフレーム番号を取得する */
    long            GetRoiInfo(int iType) ;

    /** @brief roiタイプで roiinforを取得する*/
    SingleRoiInfo*    SearchFrameRoiInfo(int iType, const CRect& rtSearch);

    SingleRoiInfo*  GetCurAreaSearchFrameRoiInfo();

    void            ResetAreaSearchFrameRoiInfo();

protected:

private:
    /** @brief ストリングクラス型の時間をTIME_Tクラス型の時間に変換する */
    time_t            GetDataTime(String strDataTime);
    /** @brief モードノートを解析する*/
    BOOL            ParseMode(MSXML2::IXMLDOMNodePtr& pParentNode);
    /** @brief roiノードを解析する*/
    BOOL            ParseBaseRoi(MSXML2::IXMLDOMNodePtr& pParentNode);
    /** @brief　FrameRateノードを解析する*/
    BOOL            ParseFrameRateInfo(MSXML2::IXMLDOMNodePtr& pParentNode);
    /** @brief roiノードを解析する*/
    BOOL            ParseFrameRoiInfo(MSXML2::IXMLDOMNodePtr& pParentNode, BOOL bInitRateInfo);
    /** @brief roiノードを解析する*/
    BOOL            ParseFrameRoi(MSXML2::IXMLDOMNodePtr& pRoiNode, SingleRoiInfo roiInfo);
    /** @brief tagファイルをxmlファイルに転換する*/
    BOOL            RebuildTagFile(LPCTSTR szTagFile);
    /** @brief オブジェクトをリリースする*/
    void            Release();
    CFrameRoiInfo*  GetRoiInfoByType(int iType);

public:

protected:

private:
    /** @brief フレームのレートメッセージ */
    CFrameRateInfo*        m_pFrameRateInfo;

    /** @brief 変換モード(0～3)*/
    long                m_lMode;

    /** @brief RoiTypeが最初に現れるフレーム番号*/
    long                m_lRoiInfo[4];
    /** @brief roiタイプが0であるroi情報*/
    CFrameRoiInfo*        m_pFrameRoiInfo0;
    /** @brief roiタイプが1であるroi情報*/
    CFrameRoiInfo*        m_pFrameRoiInfo1;
    /** @brief roiタイプが2であるroi情報*/
    CFrameRoiInfo*        m_pFrameRoiInfo2;
    /** @brief roiタイプが3であるroi情報*/
    CFrameRoiInfo*        m_pFrameRoiInfo3;
    CFrameRoiInfo*        m_pCuSearchRoiInfo;
    SingleRoiInfo*        m_pCuSingleRoiInfo;
    /** @brief コールバック用のオブジェクトのポインター */
    IProgressCallBack*  m_pCallBack;

};

/********************************更新履歴*************************************/
/**
 * 2008/08/15 Yan Hongwei 新規作成
 */
/*****************************************************************************/

t/*****************************************************************************/
/**
 * @file        TagFile.cpp
 * @brief        TagFile クラスソースファイル
 *
 * @author        Yan Hongwei
 * @date        2008/08/15 新規作成
 *
 */
/* Copyright (C) 2008 informedia Co.itd.All right reserved. */
/*****************************************************************************/

#include "StdAfx.h"
#include "./tagfile.h"
#include "time.h"

/**
 * コンストラクタ
 *
 * @param なし
 * @return なし
 */
CTagFile::CTagFile(void)
{   
    m_pCallBack            = NULL;
    m_pFrameRateInfo    = NULL;
    m_lMode                = 0;
    m_pFrameRoiInfo0    = NULL;
    m_pFrameRoiInfo1    = NULL;
    m_pFrameRoiInfo2    = NULL;
    m_pFrameRoiInfo3    = NULL;
    m_pCuSearchRoiInfo    = NULL;
    m_pCuSingleRoiInfo  = NULL;
    memset(m_lRoiInfo, 0, sizeof(m_lRoiInfo));
}


/**
 * デストラクタ
 *
 * @param なし
 * @return なし
 */
CTagFile::~CTagFile(void)
{
    Release();
}


/**
 * 指定されたパスのTAGファイルをロードする
 *
 * @param szFilePath ファイルフルパス
 * @return ロードが成功したか戻る
 */
BOOL CTagFile::Load(LPCTSTR szFilePath, IProgressCallBack* pProgressCallBack)
{
    if (FALSE == RebuildTagFile(szFilePath))
    {
        return FALSE;
    }

    m_pCallBack = pProgressCallBack;

    Release();

    m_pFrameRateInfo = new CFrameRateInfo();
    m_pFrameRoiInfo0 = new CFrameRoiInfo();
    m_pFrameRoiInfo1 = new CFrameRoiInfo();
    m_pFrameRoiInfo2 = new CFrameRoiInfo();
    m_pFrameRoiInfo3 = new CFrameRoiInfo();
         
    _bstr_t bstrFilepath = szFilePath;
    variant_t vResult;

    MSXML2::IXMLDOMDocumentPtr  pXMLDomDocument;
    HRESULT hr = pXMLDomDocument.CreateInstance(MSXML2::CLSID_DOMDocument);
    if(FAILED(hr))
    {
        return FALSE;
    }

    vResult = pXMLDomDocument->load(bstrFilepath);
    if((bool)vResult != TRUE)
    {
        pXMLDomDocument.Release();
        return FALSE;
    }

    MSXML2::IXMLDOMElementPtr   pDocRoot;
    pDocRoot = pXMLDomDocument->documentElement;
    if (pDocRoot == NULL)
    {
        pXMLDomDocument.Release();
        return FALSE;           
    }


    BOOL bRes = FALSE;
    BOOL bRateInit = FALSE;
    MSXML2::IXMLDOMNodePtr pIndexNode = pDocRoot->selectSingleNode("Index");
    if (pIndexNode != NULL)
    {
        bRes = ParseMode(pIndexNode);

        if (bRes)
        {
            bRes = ParseBaseRoi(pIndexNode);
        }

        if (bRes)
        {
            bRateInit = ParseFrameRateInfo(pIndexNode);
        }

        if (bRateInit)
        {
            bRateInit = m_pFrameRateInfo->Update();
        }
        pIndexNode.Release();
    }

    if (FALSE == bRes)
    {
        pDocRoot.Release();
        pXMLDomDocument.Release();   
        return FALSE;   
    }

    bRes = FALSE;
    MSXML2::IXMLDOMNodePtr pFramesNode = pDocRoot->selectSingleNode("Frames");
    if (pFramesNode != NULL)
    {
        bRes = ParseFrameRoiInfo(pFramesNode, !bRateInit);
        pFramesNode.Release();
    }

    pDocRoot.Release();
    pXMLDomDocument.Release();

    return bRes;
}


/**
 * フレームのレートメッセージを取得する
 *
 * @param なし
 * @return フレームのレート情報を戻る
 */
CFrameRateInfo*    CTagFile::GetFrameRateInfo()
{
    return m_pFrameRateInfo;
}


/**
 * ストリングクラス型の時間をTIME_Tクラス型の時間に変換する
 *
 * @param strDataTime ストリングクラス型の時間値
 * @return TIME_Tクラス型の時間
 */
time_t CTagFile::GetDataTime(String strDataTime)
{
    struct tm time;
    try
    {
        time.tm_year = _tstoi(strDataTime.substr(0, 4).c_str()) - 1900;
        time.tm_mon  = _tstoi(strDataTime.substr(4, 2).c_str());
        time.tm_mday = _tstoi(strDataTime.substr(6, 2).c_str());
        time.tm_hour = _tstoi(strDataTime.substr(8, 2).c_str());
        time.tm_min = _tstoi(strDataTime.substr(10, 2).c_str());
        time.tm_sec = _tstoi(strDataTime.substr(12, 2).c_str());
    }
    catch(...)
    {
   
    }

    return mktime(&time);
}


/**
 * オブジェクトをリリースする
 *
 * @param 　なし
 * @return 　なし
 */
void CTagFile::Release()
{
    delete m_pFrameRateInfo;
    m_pFrameRateInfo = NULL;

    delete m_pFrameRoiInfo1;
    m_pFrameRoiInfo1 = NULL;

    delete m_pFrameRoiInfo2;
    m_pFrameRoiInfo2 = NULL;

    delete m_pFrameRoiInfo3;
    m_pFrameRoiInfo3 = NULL;

    delete m_pFrameRoiInfo0;
    m_pFrameRoiInfo0 = NULL;
}


/**
 * モードノートを解析する
 *
 * @param　pParentNode　ノード
 * @return 解析が成功か戻る
 */
BOOL  CTagFile::ParseMode(MSXML2::IXMLDOMNodePtr& pParentNode)
{
    if (pParentNode == NULL)
    {
        return FALSE;
    }

    MSXML2::IXMLDOMNodePtr pModeNode = pParentNode->selectSingleNode("Mode");
    if (pModeNode == NULL)
    {
        return FALSE;       
    }
    String strMode = pModeNode->Gettext();
    m_lMode = _tstoi(strMode.c_str());
    pModeNode.Release();
    return TRUE;
}


/**
 * roiノードを解析する
 *
 * @param　pParentNode　ノード
 * @return 解析が成功か戻る
 */
BOOL  CTagFile::ParseBaseRoi(MSXML2::IXMLDOMNodePtr& pParentNode)
{
    if (pParentNode == NULL)
    {
        return FALSE;
    }

    MSXML2::IXMLDOMNodeListPtr pRoiNodeList = pParentNode->selectNodes("Roi");
    if (pRoiNodeList == NULL)
    {
        return FALSE;       
    }

    BOOL bRes = TRUE;
    for (int i = 0; i < pRoiNodeList->Getlength(); i++)
    {
        MSXML2::IXMLDOMNodePtr pSubNode  = pRoiNodeList->Getitem(i);
        if (pSubNode == NULL)
        {
            bRes = FALSE;
            break;   
        }

        MSXML2::IXMLDOMNamedNodeMapPtr pAttributNode = pSubNode->Getattributes();
        if (pAttributNode == NULL)
        {
            bRes = FALSE;
            break;   
        }

        MSXML2::IXMLDOMNodePtr pTypeNode = pAttributNode->getNamedItem("Type");
        if (pTypeNode == NULL)
        {
            bRes = FALSE;
            break;   
        }

        String strType = pTypeNode->Gettext();
        if (strType.compare("0") == 0)
        {
            String strTypeValue = pSubNode->Gettext();
            long lValue = -1;
            lValue = _tstoi(strTypeValue.c_str());
            m_lRoiInfo[0] = lValue;

        }
        else if (strType.compare("1") == 0)
        {
            String strTypeValue = pSubNode->Gettext();
            long lValue = -1;
            lValue = _tstoi(strTypeValue.c_str());
            m_lRoiInfo[1] = lValue;
        }
        else if (strType.compare("2") == 0)
        {
            String strTypeValue = pSubNode->Gettext();
            long lValue = -1;
            lValue = _tstoi(strTypeValue.c_str());
            m_lRoiInfo[2] = lValue;       
        }
        else if (strType.compare("3") == 0)
        {
            String strTypeValue = pSubNode->Gettext();
            long lValue = -1;
            lValue = _tstoi(strTypeValue.c_str());
            m_lRoiInfo[3] = lValue;
        }
        else
        {

        }
    }

    pRoiNodeList.Release();
    return bRes;
}


/**
 * roiノードを解析する
 *
 * @param　pParentNode　ノード
 * @return 解析が成功か戻る
 */
BOOL  CTagFile::ParseFrameRateInfo(MSXML2::IXMLDOMNodePtr& pParentNode)
{
    if (pParentNode == NULL)
    {
        return FALSE;
    }

    MSXML2::IXMLDOMNodeListPtr pFrameNodeList = pParentNode->selectNodes("FrameRateInfo");
    if (pFrameNodeList == NULL)
    {
        return FALSE;
    }

    BOOL bRes = TRUE;
    for (int i = 0; i < pFrameNodeList->Getlength(); i++)
    {
        MSXML2::IXMLDOMNodeListPtr pChildNodeList
            = pFrameNodeList->Getitem(i)->GetchildNodes();
        if (pChildNodeList == NULL)
        {
            bRes = FALSE;
            break;
        }

        SubFramesInfo subFrmInfo;
        DWORD dwValue = 0x0;
        for (int j = 0; j < pChildNodeList->Getlength(); j++)
        {
            String strName = pChildNodeList->Getitem(j)->GetnodeName();
            if (strName.compare(TEXT("Rate")) == 0)
            {
                String strRate = pChildNodeList->Getitem(j)->Gettext();
                  int iRate = 1;
                iRate = _tstoi(strRate.c_str());
                subFrmInfo.iRate = iRate;
                dwValue |= 0x1;
            }
            else if (strName.compare(TEXT("StartDate")) == 0)
            {
                String strData = pChildNodeList->Getitem(j)->Gettext();
                  time_t tm = GetDataTime(strData);
                subFrmInfo.tmStart = tm;
                dwValue |= 0x2;
            }
            else if (strName.compare(TEXT("EndDate")) == 0)
            {
                String strData = pChildNodeList->Getitem(j)->Gettext();
                time_t tm = GetDataTime(strData);   
                subFrmInfo.tmEnd = tm;
                dwValue |= 0x4;
            }
        }
        if (dwValue & 0x7)
        {
            m_pFrameRateInfo->AddSubFramesInfo(subFrmInfo);
        }
        pChildNodeList.Release();
    }
    pFrameNodeList.Release();

    return bRes;
}



/**
 * roiノードを解析する
 *
 * @param　pParentNode　ノード
 * @return 解析が成功か戻る
 */
BOOL  CTagFile::ParseFrameRoiInfo(MSXML2::IXMLDOMNodePtr& pParentNode, BOOL bInitRateInfo)
{
    if (pParentNode == NULL)
    {
        return FALSE;
    }

    MSXML2::IXMLDOMNodeListPtr pFrameNodeList = pParentNode->selectNodes("Frame");
    if (pFrameNodeList == NULL)
    {
        return FALSE;       
    }

    BOOL bRes = TRUE;
    time_t    tmStart = 0;
    time_t  tmEnd   = 0;
    int iCount = pFrameNodeList->Getlength();
    int iBasePer = PARSE_TAGFILE_OVER - DOWNLOAD_FILE_OVER;
    for (int i = 0; i < iCount; i++)
    {
        MSXML2::IXMLDOMNodePtr pFrameNode = pFrameNodeList->Getitem(i);
        if (pFrameNode == NULL)
        {
            bRes = FALSE;
            break;
        }

        //NO
        MSXML2::IXMLDOMNamedNodeMapPtr pAttributNode = pFrameNode->Getattributes();
        if (pAttributNode == NULL)
        {
            bRes = FALSE;
            break;   
        }

        MSXML2::IXMLDOMNodePtr pNoNode = pAttributNode->getNamedItem("No");
        if (pNoNode == NULL)
        {
            bRes = FALSE;
            break;   
        }

        String strNo = pNoNode->Gettext();
        long lFrmNo = -1;
        lFrmNo = _tstoi(strNo.c_str());

        MSXML2::IXMLDOMNodeListPtr pChildNodeList = pFrameNode->GetchildNodes();
        if (pChildNodeList == NULL)
        {
            bRes = FALSE;
            break;
        }

        SingleRoiInfo singleRoiInfo;
        singleRoiInfo.iFrmNo = lFrmNo;
        for (int j = 0; j < pChildNodeList->Getlength(); j++)
        {

            MSXML2::IXMLDOMNodePtr pChildNode = pChildNodeList->Getitem(j);
            if (pChildNode == NULL)
            {
                bRes = FALSE;
                break;   
            }

            String strName = pChildNode->GetnodeName();
            if (strName.compare(TEXT("time")) == 0)
            {
                String strData = pChildNode->Gettext();
                  time_t tm = GetDataTime(strData);
                singleRoiInfo.tmFrm = tm;
                if (tmStart == 0)
                {
                    tmStart = tm;
                }
                else
                {
                    tmEnd = tm;
                }
            }
            else if (strName.compare(TEXT("Roi")) == 0)
            {
                bRes = ParseFrameRoi(pChildNode, singleRoiInfo);
                if (bRes == FALSE)
                {
                    break;
                }
            }
            else
            {

            }

            int iPer = DOWNLOAD_FILE_OVER + iBasePer * (i + 1) / iCount;

            if (m_pCallBack)
            {
                m_pCallBack->ProgressUpdate(DOWNLOAD_PROGRESS,
                                            NULL,
                                            NULL,
                                            iPer);
            }
        }
       
        pChildNodeList.Release();

        if (bRes == FALSE)
        {
            break;   
        }
    }

    pFrameNodeList.Release();

    if (bRes &&
        bInitRateInfo)
    {
        SubFramesInfo subFrmInfo;
        subFrmInfo.iRate   = 1;
        subFrmInfo.tmStart = tmStart;
        subFrmInfo.tmEnd   = tmEnd;
        m_pFrameRateInfo->AddSubFramesInfo(subFrmInfo);
        bRes = m_pFrameRateInfo->Update();
    }

    return bRes;
}


/**
 * roiノードを解析する
 *
 * @param　pRoiNode　roiノード
 * @param 　roiInfo　roi情報
 * @return 解析が成功か戻る
 */
BOOL  CTagFile::ParseFrameRoi(MSXML2::IXMLDOMNodePtr& pRoiNode, SingleRoiInfo roiInfo)
{
    if (pRoiNode == NULL)
    {
        return FALSE;
    }

    MSXML2::IXMLDOMNamedNodeMapPtr pAttributNode = pRoiNode->Getattributes();
    if (pAttributNode == NULL)
    {
        return FALSE;   
    }

    MSXML2::IXMLDOMNodePtr pTypeNode = pAttributNode->getNamedItem("Type");
    if (pTypeNode == NULL)
    {
        return FALSE;   
    }

    String strType = pTypeNode->Gettext();
    int       iType = -1;
    iType = _tstoi(strType.c_str());
    CFrameRoiInfo* pRoiInfo = GetRoiInfoByType(iType);
    if (pRoiInfo == NULL)
    {
        return FALSE;
    }


    MSXML2::IXMLDOMNodePtr pMasRectsNode = pRoiNode->selectSingleNode("MasRects");
    if (pMasRectsNode == NULL)
    {
        return FALSE;       
    }

    MSXML2::IXMLDOMNodeListPtr pMasRectNodeList = pMasRectsNode->selectNodes("MasRect");
    if (pMasRectNodeList == NULL)
    {
        pMasRectsNode.Release();
        return FALSE;       
    }

    BOOL bRes = TRUE;
    BOOL bFind = FALSE;
    for (int i = 0; i < pMasRectNodeList->Getlength(); i++)
    {
        MSXML2::IXMLDOMNodePtr pMasRectNode = pMasRectNodeList->Getitem(i);
        if (pMasRectNode == NULL)
        {
            bRes = FALSE;
            break;
        }

        MSXML2::IXMLDOMNodeListPtr pChildNodeList = pMasRectNode->GetchildNodes();
        if (pChildNodeList == NULL)
        {
            bRes = FALSE;
            break;
        }

        SingleRoiInfo::MasRect rect;
        DWORD dwValue = 0;
        for (int j = 0; j < pChildNodeList->Getlength(); j++)
        {
            String strName = pChildNodeList->Getitem(j)->GetnodeName();

            String strPos = pChildNodeList->Getitem(j)->Gettext();

            if (strName.compare(TEXT("x")) == 0)
            {
                rect.iX = _tstoi(strPos.c_str());
                dwValue |= 0x1;
            }
            else if (strName.compare(TEXT("y")) == 0)
            {
                rect.iY = _tstoi(strPos.c_str());
                dwValue |= 0x2;
            }
            else if (strName.compare(TEXT("w")) == 0)
            {
                rect.iW = _tstoi(strPos.c_str());
                dwValue |= 0x4;
            }
            else if (strName.compare(TEXT("h")) == 0)
            {
                rect.iH = _tstoi(strPos.c_str());
                dwValue |= 0x8;
            }
        }
       
        if (dwValue & 0xF)
        {
            roiInfo.arrMasRect.push_back(rect);
            bFind = TRUE;
        }
        else
        {
            pChildNodeList.Release();
            bRes = FALSE;
            break;   
        }
    }

    if (bFind)
    {
        pRoiInfo->AddSingleRoiInfo(roiInfo);
    }

    pMasRectNodeList.Release();
    pMasRectsNode.Release();
    return bRes;
}


/**
 * roiタイプで roiinforを取得する
 *
 * @param　iType Roiのタイプ
 * @return Roi情報
 */
SingleRoiInfo*    CTagFile::SearchFrameRoiInfo(int iType, const CRect& rtSearch)
{
    m_pCuSingleRoiInfo = NULL;
    CFrameRoiInfo* pFrameRoiInfo = GetRoiInfoByType(iType);
    if (pFrameRoiInfo)
    {
        m_pCuSingleRoiInfo = pFrameRoiInfo->Find(rtSearch);
    }

    return m_pCuSingleRoiInfo;
}


SingleRoiInfo* CTagFile::GetCurAreaSearchFrameRoiInfo()
{
    return m_pCuSingleRoiInfo;
}


void CTagFile::ResetAreaSearchFrameRoiInfo()
{   
    m_pCuSearchRoiInfo->Reset();
    m_pCuSingleRoiInfo = NULL;
}


/**
 * TAGファイルをxmlファイルに転換する
 *
 * @param 　ファイルのパス
 * @return 　転換操作が成功した。
 */
BOOL CTagFile::RebuildTagFile(LPCTSTR szTagFile)
{
    // 読み込み
    FILE* ifp = _tfopen(szTagFile, TEXT("rb"));
    if (ifp == NULL)
    {
        return FALSE;
    }

    fseek(ifp, 0L, SEEK_END);
    int size = ftell(ifp);
    fseek(ifp, 0L, SEEK_SET);
    char* buf = (char*)malloc(size);
    memset(buf, 0, size);
    fread(buf, sizeof(unsigned char), size, ifp);
    fclose(ifp);

   
    // 書き込み
    FILE* ofp = _tfopen(szTagFile, TEXT("wb"));
    if (ofp == NULL)
    {
        return FALSE;
    }

    fseek(ofp, 0L, SEEK_SET);
    _fputts(TEXT("<SmartViewer>/n"), ofp);

    char* szBase = buf;
    while (TRUE)
    {
        char* szEnd = strstr(szBase, "?>");
        if (NULL == szEnd)
        {
            break;                   
        }
        szBase = szEnd + 2;   
    }
    fwrite(szBase, sizeof(char), size - (szBase - buf), ofp);   
    _fputts(TEXT("/n</SmartViewer>"), ofp);
    fclose(ofp);
    free(buf);
    return TRUE;
}

CFrameRoiInfo*  CTagFile::GetRoiInfoByType(int iType)
{
    CFrameRoiInfo* pFrameRoiInfo = NULL;
    if (iType == 0)
    {
        pFrameRoiInfo = m_pFrameRoiInfo0;
    }
    else if (iType == 1)
    {
        pFrameRoiInfo = m_pFrameRoiInfo1;
    }

    else if (iType == 2)
    {
        pFrameRoiInfo = m_pFrameRoiInfo2;
    }
    else if (iType == 3)
    {
        pFrameRoiInfo = m_pFrameRoiInfo3;
    }
    else
    {
        return NULL;
    }
    if (pFrameRoiInfo != m_pCuSearchRoiInfo &&
        m_pCuSearchRoiInfo != NULL)
    {
        m_pCuSearchRoiInfo->Reset();
    }
    m_pCuSearchRoiInfo = pFrameRoiInfo;
    return pFrameRoiInfo;
}


/**
 * 変換モードを取得する
 *
 * @param なし
 * @return 変換モードを戻る
 */
long  CTagFile::GetMode()
{
    return m_lMode;
}


/**
 * RoiTypeが最初に現れるフレーム番号を取得する
 *
 * @param iType RoiTypeの値
 * @return RoiTypeが最初に現れるフレーム番号を戻る
 */
long CTagFile::GetRoiInfo(int iType)
{
    if (iType < 0 ||
        iType > 3)
    {
        return -1;
    }
    return m_lRoiInfo[iType];
}


/********************************更新履歴*************************************/
/**
 * 2008/08/15 Yan Hongwei 新規作成
 */
/*****************************************************************************/