• メインページ
  • クラス
  • ファイル
  • ファイル一覧
  • ファイルメンバ

narMarkerDetector.h

説明を見る。
00001 /*-----------------------------------------------------------------------*
00002   Project:  Nintendo Augmented Reality Library.
00003   File:     narMarkerDetector.h
00004 
00005   Copyright (C)2011-2012 Nintendo Co., Ltd.  All rights reserved.
00006 
00007   These coded instructions, statements, and computer programs contain
00008   proprietary information of Nintendo and/or its licensed developers
00009   and are protected by national and international copyright laws. They
00010   may not be disclosed to third parties or copied or duplicated in any
00011   form, in whole or in part, without the prior written consent of
00012   Nintendo.
00013   The content herein is highly confidential and should be handled
00014   accordingly.
00015 *-----------------------------------------------------------------------*/
00021 #ifndef NAR_MARKER_DETECTOR_H__
00022 #define NAR_MARKER_DETECTOR_H__
00023 
00024 #include "narConfig.h"
00025 #include "narPort.h"
00026 #include "narVec2.h"
00027 #include "narEdgeLine.h"
00028 #include "narMarker.h"
00029 #include "narFlags.h"
00030 
00031 namespace mw { namespace nar
00032 {
00033     class Image_cl;
00034 
00035     enum
00036     {
00037         e_MarkerEdgeNum = 30    
00038     };
00039 
00042     class MarkerList_ac
00043     {
00044     public:
00045         MarkerList_ac()
00046              : m_Num( 0 ), m_MultiId( false )
00047         {}
00051         virtual Marker_cl * GetpMarker( u32 idx ) = 0;
00052 
00056         virtual s32 GetMarkerNumWithID( s32 id ) = 0;
00057 
00060         u16     GetMarkerNum() { return m_Num; }
00061 
00063 
00066         virtual bool IsFull() = 0;
00067 
00068         virtual Marker_cl * GetpNewMarker() = 0;
00069 
00070         virtual PatternVtxData_cl * GetpWritableVtxData() = 0;
00071 
00072         void Initialize() { m_Num = 0; m_MultiId = false; }
00073 
00074         void IncMarkerNum() { m_Num++ ; }
00075 
00076         bool IsMultiId() { return m_MultiId; }
00077         void SetMultiId( bool b ) { m_MultiId = b; }
00079     private:
00080         u16             m_Num;
00081         u16             m_MultiId;
00082     };
00086     template < s32 N >
00087     class MarkerList_tc : public MarkerList_ac
00088     {
00089     public:
00090         MarkerList_tc()
00091         {}
00092 
00093         virtual Marker_cl * GetpMarker( u32 idx )
00094         {
00095             if ( idx >= N ) return 0;
00096             else            return &ma_Marker[ idx ];
00097         }
00098 
00099         virtual s32 GetMarkerNumWithID( s32 id )
00100         {
00101             int count = 0;
00102             for ( int idx = GetMarkerNum() - 1; idx >= 0; idx-- )
00103             {
00104                 if ( ma_Marker[ idx ].GetID() == id )
00105                     count++;
00106             }
00107             return count;
00108         }
00109 
00111 
00112         virtual bool        IsFull() { return GetMarkerNum() == N; }
00113 
00114         virtual Marker_cl * GetpNewMarker()
00115         {
00116             int num = GetMarkerNum();
00117             if ( num >= N ) return 0;
00118             else
00119             {
00120                 IncMarkerNum();
00121                 return &ma_Marker[ num ];
00122             }
00123         }
00124 
00125         virtual PatternVtxData_cl * GetpWritableVtxData(){ return 0; }
00126 
00128     private:
00129         Marker_cl           ma_Marker[ N ];
00130     };
00131 
00135     template < s32 N >
00136     class MarkerAnalizableList_tc : public MarkerList_ac
00137     {
00138     public:
00139         MarkerAnalizableList_tc()
00140         {}
00141 
00142         virtual Marker_cl * GetpMarker( u32 idx )
00143         {
00144             if ( idx >= N ) return 0;
00145             else            return &ma_Marker[ idx ];
00146         }
00147 
00148         virtual s32 GetMarkerNumWithID( s32 id )
00149         {
00150             int count = 0;
00151             for ( int idx = GetMarkerNum() - 1; idx >= 0; idx-- )
00152             {
00153                 if ( ma_Marker[ idx ].GetID() == id )
00154                     count++;
00155             }
00156             return count;
00157         }
00158 
00160 
00161         virtual bool        IsFull() { return GetMarkerNum() == N; }
00162 
00163         virtual Marker_cl * GetpNewMarker()
00164         {
00165             int num = GetMarkerNum();
00166             if ( num >= N ) return 0;
00167             else
00168             {
00169                 IncMarkerNum();
00170                 return &ma_Marker[ num ];
00171             }
00172         }
00173 
00174         virtual PatternVtxData_cl * GetpWritableVtxData()
00175         {
00176             // 次の座標保存先
00177             int num = GetMarkerNum();
00178             if ( num >= N ) return 0;
00179             else
00180             {
00181                 return &ma_PatternVtxData[ num ];
00182             }
00183         }
00184 
00186     private:
00187         Marker_cl           ma_Marker[ N ];
00188         PatternVtxData_cl   ma_PatternVtxData[ N ];
00189     };
00190 
00193     class MarkerData_ac
00194     {
00195     public:
00196         MarkerData_ac()
00197              : m_Detecting( 0 )
00198         {}
00199 
00201         virtual MarkerList_ac & GetrDetectingMarkerList() = 0;
00203         virtual MarkerList_ac & GetrLastMarkerList() = 0;
00204 
00206 
00208         virtual bool AddMarker( const MarkerTemplate_st * cp_Temp,
00209                                 const Vec2F_st * cap_Points,
00210                                 s32 dir,
00211                                 const f32 c_Score,
00212                                 const PatternVtxData_cl * cp_VtxData ) = 0;
00213 
00215         void SwapList() { m_Detecting ^= 1; }
00216     protected:
00217         u8         getDetecting() { return m_Detecting; }
00219     private:
00221         u8                  m_Detecting;
00222         u8                  apad[3];
00223     };
00224 
00229     template < typename T, s32 N >
00230     class MarkerContainer_tc : public MarkerData_ac
00231     {
00232     public:
00233         virtual MarkerList_ac & GetrDetectingMarkerList()
00234         {
00235             return ma_MarkerLists[ getDetecting() ];
00236         }
00237         virtual MarkerList_ac & GetrLastMarkerList()
00238         {
00239             return ma_MarkerLists[ getDetecting()^1 ];
00240         }
00241 
00243         
00245         virtual bool AddMarker( const MarkerTemplate_st * cp_Temp,
00246                                 const Vec2F_st * cap_Points,
00247                                 s32 dir,
00248                                 const f32 c_Score,
00249                                 const mw::nar::PatternVtxData_cl * cp_VtxData )
00250         {
00251             MarkerList_ac & r_New  = GetrDetectingMarkerList();
00252 
00253             //  同じ領域を登録しようとしていないかチェック
00254             for ( int idx = r_New.GetMarkerNum() - 1; idx >= 0; idx-- )
00255             {
00256                 Marker_cl * p_Marker = r_New.GetpMarker( idx );
00257                 if ( p_Marker->GetID() == cp_Temp->id )
00258                 {
00259                     if ( p_Marker->IsOverlapped( cap_Points ) )
00260                     {
00261                         //  重なっていたらスコアチェックして高ければ上書き
00262                         if ( p_Marker->GetScore() < c_Score )
00263                         {
00264                             p_Marker->Init( cp_Temp, cap_Points, cp_VtxData, dir, c_Score );
00265                             return true;
00266                         }
00267                         return false;
00268                     }
00269                     else
00270                     {
00271                         //  複数マーカーフラグ
00272                         r_New.SetMultiId( true );
00273                     }
00274                 }
00275             }
00276 
00277             //  新規登録
00278             Marker_cl * p_New = r_New.GetpNewMarker();
00279 
00280             if ( p_New )
00281             {
00282                 //  新しいマーカーが登録できるなら
00283                 p_New->Init( cp_Temp, cap_Points, cp_VtxData, dir, c_Score );
00284                 return true;
00285             }
00286             return false;
00287         }
00289     private:
00294         T  ma_MarkerLists[ 2 ];
00295     };
00296 
00300     template< s32 N >
00301     class MarkerData_tc : public MarkerContainer_tc< mw::nar::MarkerList_tc< N >, N >
00302     {};
00303 
00307     template< s32 N >
00308     class MarkerAnalizableData_tc : public MarkerContainer_tc< mw::nar::MarkerAnalizableList_tc< N >, N >
00309     {};
00310 
00313     class MarkerDetectWork_ac
00314     {
00315     public:
00317         virtual bool Extract( const Image_cl & cr_Image, const Vec2F_st * cap_Points, PatternVtxData_cl * p_VtxData ) = 0;
00318 
00319         virtual MarkerPattern_st &  GetrPattern() = 0;
00320 
00322         EdgeLine_cl         a_MarkerEdge[ e_MarkerEdgeNum ];
00324     };
00327     struct MarkerDetectWork_cl : public MarkerDetectWork_ac
00328     {
00329     public:
00331         virtual bool Extract( const Image_cl & cr_Image, const Vec2F_st * cap_Points, PatternVtxData_cl * p_VtxData )
00332         {
00333             m_Pattern.Extract( cr_Image, cap_Points, p_VtxData );
00334             return true;
00335         }
00336 
00337         virtual MarkerPattern_st &  GetrPattern()    { return m_Pattern; }
00339     private:
00341         MarkerPattern_st    m_Pattern;
00342     };
00347     struct MarkerDetectWorkFast_cl : public MarkerDetectWork_ac
00348     {
00349     public:
00351         virtual bool Extract( const Image_cl & cr_Image, const Vec2F_st * cap_Points, PatternVtxData_cl * p_VtxData )
00352         {
00353             m_Pattern.ExtractFast( cr_Image, cap_Points, p_VtxData );
00354             return true;
00355         }
00356 
00357         virtual MarkerPattern_st &  GetrPattern()    { return m_Pattern; }
00359     private:
00361         MarkerPattern_st    m_Pattern;
00362     };
00367     struct MarkerDetectWorkStrict_cl : public MarkerDetectWork_ac
00368     {
00369     public:
00371         virtual bool Extract( const Image_cl & cr_Image, const Vec2F_st * cap_Points, PatternVtxData_cl * p_VtxData )
00372         {
00373             m_Pattern.ExtractStrictly( cr_Image, cap_Points, p_VtxData );
00374             return true;
00375         }
00376 
00377         virtual MarkerPattern_st &  GetrPattern()    { return m_Pattern; }
00379     private:
00381         MarkerPattern_st    m_Pattern;
00382     };
00383 
00385 
00388     template < s32 N >
00389     class MarkerMakerWork_tc : public MarkerDetectWork_ac
00390     {
00391     public:
00392         MarkerMakerWork_tc()
00393              : m_UseNum( 0 )
00394         {}
00395 
00398         virtual bool Extract( const Image_cl & cr_Image, const Vec2F_st * cap_Points, PatternVtxData_cl * p_VtxData )
00399         {
00400             if ( m_UseNum < N )
00401             {
00402                 ma_Pattern[ m_UseNum ].Extract( cr_Image, cap_Points, p_VtxData );
00403                 maa_Points[ m_UseNum ][ 0 ] = cap_Points[ 0 ];
00404                 maa_Points[ m_UseNum ][ 1 ] = cap_Points[ 1 ];
00405                 maa_Points[ m_UseNum ][ 2 ] = cap_Points[ 2 ];
00406                 maa_Points[ m_UseNum ][ 3 ] = cap_Points[ 3 ];
00407                 m_UseNum++;
00408             }
00409             return false;
00410         }
00413         void PrintPattern( u32 idx )    { ma_Pattern[ idx ].print(); }
00416         void Flush() { m_UseNum = 0; }
00419         s32 GetPatternNum() { return m_UseNum; }
00422         const Vec2F_st *    GetpPoint( u32 idx ) { return maa_Points[ idx ]; }
00425         virtual MarkerPattern_st &  GetrPattern()    { return ma_Pattern[ 0 ]; }
00426 
00427         MarkerPattern_st & GetrPattern( u32 idx )    { return ma_Pattern[ idx ]; }
00428     private:
00429         s32                     m_UseNum;
00430         MarkerPattern_st        ma_Pattern[ N ];
00431         Vec2F_st                maa_Points[ N ][ 4 ];
00432     };
00433 
00436     template < s32 N >
00437     class MarkerMakerWorkStrict_tc : public MarkerDetectWork_ac
00438     {
00439     public:
00440         MarkerMakerWorkStrict_tc()
00441              : m_UseNum( 0 )
00442         {}
00443 
00446         virtual bool Extract( const Image_cl & cr_Image, const Vec2F_st * cap_Points, PatternVtxData_cl * p_VtxData )
00447         {
00448             if ( m_UseNum < N )
00449             {
00450                 ma_Pattern[ m_UseNum ].ExtractStrictly( cr_Image, cap_Points, p_VtxData );
00451                 maa_Points[ m_UseNum ][ 0 ] = cap_Points[ 0 ];
00452                 maa_Points[ m_UseNum ][ 1 ] = cap_Points[ 1 ];
00453                 maa_Points[ m_UseNum ][ 2 ] = cap_Points[ 2 ];
00454                 maa_Points[ m_UseNum ][ 3 ] = cap_Points[ 3 ];
00455                 m_UseNum++;
00456             }
00457             return false;
00458         }
00461         void PrintPattern( u32 idx )    { ma_Pattern[ idx ].print(); }
00464         void Flush() { m_UseNum = 0; }
00467         s32 GetPatternNum() { return m_UseNum; }
00470         const Vec2F_st *    GetpPoint( u32 idx ) { return maa_Points[ idx ]; }
00473         virtual MarkerPattern_st &  GetrPattern()    { return ma_Pattern[ 0 ]; }
00474 
00475         MarkerPattern_st & GetrPattern( u32 idx )    { return ma_Pattern[ idx ]; }
00476     private:
00477         s32                     m_UseNum;
00478         MarkerPattern_st        ma_Pattern[ N ];
00479         Vec2F_st                maa_Points[ N ][ 4 ];
00480     };
00481 
00483 
00487     class MarkerDetector_cl
00488     {
00489     public:
00497         static s32 Detect( Image_cl & r_Image, MarkerDatabase_cl & r_DB, MarkerData_ac & r_Data, MarkerDetectWork_ac & r_Work );
00498     };
00499 }
00500 }
00501 #endif

© 2011-2012 Nintendo Co., Ltd. All rights reserved.