\r
/**\r
* このクラスは、NyARToolkitのリアリティモデルを実装します。\r
- * ターゲット要素の保持と、{@link NyARRealitySource}を元にした更新を担当します。\r
+ * Realityターゲット(以下、RTターゲット)要素の保持と、{@link NyARRealitySource}を元にした更新を担当します。\r
* <p>NyARToolkitのリアリティモデル-\r
* NyARToolkitのリアリティモデルは、ARToolKitのマーカー認識処理系をベースとしたデータモデルです。\r
* このモデルでは、空間に存在する複数のマーカを個別に管理し、これらの情報に対するランダムアクセス性をアプリケーションに提供します。\r
* 基本的には複数の{@link NyARRealityTarget}要素を持つテーブルです。\r
- * マーカ１個を１ターゲットとして取り扱い、{@link NyARRealityTarget}クラスに要素として格納します。\r
+ * マーカ１個を１RTターゲットとして取り扱い、{@link NyARRealityTarget}クラスに要素として格納します。\r
* </p>\r
* <p>基本的な使い方-\r
* {@link NyARReality}は、定期的に入力される更新ソース(画像入力)に従ってテーブルの状態を更新することで、全体を管理します。\r
* 他に操作関数がいくつあり、ユーザが要素の状態を制御することもできます。基本的には、ユーザは次の3つの実装をすることになります。\r
* <ul>\r
* <li>定期的に{@link NyARReality}へ更新ソースを入力する処理({@link #progress}関数を使用。)\r
- * <li>更新した{@link NyARReality}のターゲットをチェックし、その状態をユーザへ反映する処理。({@link #refTargetList()}で得られるターゲットリストから要素を読みだす。)\r
- * <li>アプリケーションの都合に合せた、{@link NyARReality}の編集処理({@link NyARReality#changeTargetToDead}関数等により、ターゲットのステータスを更新。)\r
+ * <li>更新した{@link NyARReality}のRTターゲットをチェックし、その状態をユーザへ反映する処理。({@link #refTargetList()}で得られるRTターゲットリストから要素を読みだす。)\r
+ * <li>アプリケーションの都合に合せた、{@link NyARReality}の編集処理({@link NyARReality#changeTargetToDead}関数等により、RTターゲットのステータスを更新。)\r
* </ul>\r
* </p>\r
- * <p>ターゲットのステータス-\r
- * {@link NyARReality}は、所有するターゲット{@link NyARReality}を３つのステータスで管理します。ステータスの意味は以下の通りです。\r
+ * <p>シリアル番号について\r
+ * {@link NyARReality}は、発見した全てのターゲットに、システムの起動から終了までの間一意になる「シリアル番号」を割り振ります。\r
+ * この番号は、システム内でターゲットを区別することに役立ち、{@link NyARRealityTarget#getSerialId()}関数で得ることができます。\r
+ * IDは64bitの数値です。\r
+ * </p>\r
+ * <p>RTターゲットのステータス-\r
+ * {@link NyARReality}は、所有するRTターゲット{@link NyARRealityTarget}を３つのステータスで管理します。\r
+ * 各RTターゲットのステータス値は、{@link NyARRealityTarget#getTargetType()}関数で得ることができます。\r
+ * ステータスの意味は以下の通りです。\r
* <ul>\r
* <li>Unknown -\r
- * 既知のターゲットです。このターゲットは、２次元パラメータ（マーカの画面座標、パターンなど）を読みだすことができます。\r
- * このステータスのターゲットは、手動更新によりKnownステータスに遷移できます。遷移は、{@link #changeTargetToKnown}で手動で行います。\r
+ * 既知のRTターゲットです。このターゲットは、２次元パラメータ（マーカの画面座標、パターンなど）を読みだすことができます。\r
+ * このステータスのRTターゲットは、手動更新によりKnownステータスに遷移できます。遷移は、{@link #changeTargetToKnown}で手動で行います。\r
* また、{@link #progress}による自動更新と、{@link #changeTargetToDead}関数による\r
* 手動更新により、Deadステータスに遷移できます。自動更新は、システムがマーカを見失った場合に自動的に起こります。\r
- * 手動更新は、例えばそのターゲットが不要である場合（パターンチェックで対象外となった）に、無視するために使います。\r
+ * 手動更新は、例えばそのRTターゲットが不要である場合（パターンチェックで対象外となった）に、無視するために使います。\r
+ * ステータス値には、{@link NyARRealityTarget#RT_UNKNOWN}を取ります。\r
* <li>Known -\r
- * 既知のターゲットです。このターゲットは、２次元パラメータと、物理サイズ、物理姿勢等の、３次元パラメータを読みだすことができます。\r
+ * 既知のRTターゲットです。このRTターゲットは、２次元パラメータと、物理サイズ、物理姿勢等の、３次元パラメータを読みだすことができます。\r
* このステータスのターゲットは、{@link #progress}による自動更新と、{@link #changeTargetToDead}関数による\r
* 手動更新により、Deadステータスに遷移できます。自動更新は、システムがマーカを見失った場合に自動的に起こります。\r
- * 手動更新は、例えばそのターゲットが不要である場合（対象外のマーカである）に、認識を無視するために使います。\r
+ * 手動更新は、例えばそのRTターゲットが不要である場合（対象外のマーカである）に、認識を無視するために使います。\r
+ * ステータス値には、{@link NyARRealityTarget#RT_KNOWN}を取ります。\r
* <li>Dead -\r
- * 間もなく消失するターゲットです。次回の{@link #progress}の実行で、テーブルから消失します。\r
+ * 間もなく消失するRTターゲットです。次回の{@link #progress}の実行で、テーブルから消失します。\r
+ * ステータス値には、{@link NyARRealityTarget#RT_DEAD}を取ります。\r
* </ul>\r
- * 全てのターゲットは、{@link #progress}により発生するUnknownステータスから始まり、必要なものだけがKnownステータスまで昇格し、\r
+ * 全てのRTターゲットは、{@link #progress}により発生するUnknownステータスから始まり、必要なものだけがKnownステータスまで昇格し、\r
* 要らないものと消失した者はDeadステータスで終了します。UnknownステータスとKnownステータスの違いは、外部情報（マーカパターンに関する物理知識）\r
* の有無です。Knownステータスのターゲットはより多くの外部情報により、Unknownステータスのターゲットよりも多くの情報を提供します。\r
* </p>\r
*/\r
public class NyARReality\r
{\r
- //視野関係のデータ\r
+ /** 定数値。ARToolKitの視錐台のNEAR値です。(単位はmm)*/\r
public final static double FRASTRAM_ARTK_NEAR=10;\r
+ /** 定数値。ARToolKitの視錐台のFAR値です。(単位はmm)*/\r
public final static double FRASTRAM_ARTK_FAR=10000;\r
- /**frastum*/\r
+ /** 視錐台のキャッシュ用オブジェクト*/\r
protected NyARFrustum _frustum;\r
+ /** 射影変換行列の参照値*/\r
protected NyARPerspectiveProjectionMatrix _ref_prjmat;\r
\r
\r
//Realityでーた\r
/**\r
- * Unknownターゲットの最大数です。\r
+ * Unknownã\82¹ã\83\86ã\83¼ã\82¿ã\82¹ã\81®RTã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81®æ\9c\80大æ\95°ã\81§ã\81\99ã\80\82\r
*/\r
private final int MAX_LIMIT_UNKNOWN;\r
/**\r
- * Knownターゲットの最大数です。\r
+ * KnownターゲットのRTターゲットの最大数です。\r
*/\r
private final int MAX_LIMIT_KNOWN; \r
\r
\r
/**\r
* コンストラクタ。\r
- * 樽型歪みが少ない、または補正済みの画像を入力するときには、{@link #NyARReality(NyARIntSize, double, double, NyARPerspectiveProjectionMatrix, NyARCameraDistortionFactor, int, int)}\r
+ * 初期状態のインスタンスを生成します。\r
+ * {@link #progress}に入力する入力画像の樽型歪みがすくないか、外部で補正した画像を入力するときは、別のコンストラクタ{@link #NyARReality(NyARIntSize, double, double, NyARPerspectiveProjectionMatrix, NyARCameraDistortionFactor, int, int)}\r
* のi_dist_factorにnullを指定すると、より高速な動作が期待できます。\r
* @param i_param\r
* カメラパラメータを指定します。\r
* @param i_near\r
* 視錐体のnear-pointをmm単位で指定します。\r
- * default値は{@link #FRASTRAM_ARTK_NEAR}です。\r
+ * 標準値は{@link #FRASTRAM_ARTK_NEAR}です。\r
* @param i_far\r
* 視錐体のfar-pointをmm単位で指定します。\r
- * default値は{@link #FRASTRAM_ARTK_FAR}です。\r
+ * 標準値は{@link #FRASTRAM_ARTK_FAR}です。\r
* @param i_max_known_target\r
- * Knownターゲットの最大数を指定します。\r
+ * Knownã\82¹ã\83\86ã\83¼ã\82¿ã\82¹ã\81®RTã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81®æ\9c\80大æ\95°ã\82\92æ\8c\87å®\9aã\81\97ã\81¾ã\81\99ã\80\82\r
* @param i_max_unknown_target\r
- * UnKnownターゲットの最大数を指定します。\r
+ * UnKnownã\82¹ã\83\86ã\83¼ã\82¿ã\82¹ã\81®RTã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81®æ\9c\80大æ\95°ã\82\92æ\8c\87å®\9aã\81\97ã\81¾ã\81\99ã\80\82\r
* @throws NyARException\r
*/\r
public NyARReality(NyARParam i_param,double i_near,double i_far,int i_max_known_target,int i_max_unknown_target) throws NyARException\r
}\r
/**\r
* コンストラクタ。\r
+ * 初期状態のインスタンスを生成します。\r
* @param i_screen\r
* スクリーン(入力画像)のサイズを指定します。\r
* @param i_near\r
* @param i_prjmat\r
* ARToolKit形式の射影変換パラメータを指定します。\r
* @param i_dist_factor\r
- * カメラ歪み矯正オブジェクトを指定します。歪み矯正が不要な時は、nullを指定します。\r
+ * 樽型歪み矯正オブジェクトを指定します。歪み矯正が不要な時は、nullを指定します。\r
* @param i_max_known_target\r
* {@link #NyARReality(NyARParam i_param,double i_near,double i_far,int i_max_known_target,int i_max_unknown_target)}を参照\r
* @param i_max_unknown_target\r
/**\r
* Realityの状態を、i_inの{@link NyARRealitySource}を元に、１サイクル進めます。\r
* 現在の更新ルールは以下の通りです。\r
- * 0.呼び出されるごとに、トラックターゲットからUnknownターゲットを生成する。\r
- * 1.一定時間捕捉不能なKnown,Unknownターゲットは、deadターゲットへ移動する。\r
- * 2.knownターゲットは最新の状態を維持する。\r
- * 3.deadターゲットは（次の呼び出しで）捕捉対象から削除する。\r
- * Knownターゲットが捕捉不能になった時の動作は、以下の通りです。\r
- * 4.[未実装]捕捉不能なターゲットの予測と移動\r
+ * <ul>\r
+ * <li>呼び出されるごとに、トラックターゲットからUnknownステータスのRTターゲットを生成する。\r
+ * <li>一定時間捕捉不能なKnown,Unknownステータスは、deadステータスへ移動する。\r
+ * <li>knownステータスのRTターゲットは最新の状態を維持する。\r
+ * <li>deadステータスのRTターゲットは（次の呼び出しで）捕捉対象から削除する。\r
+ * </ul>\r
+ * <p>メモ-\r
+ * [未実装]捕捉不能なRTターゲットの予測と移動\r
+ * </p>\r
* @param i_in\r
+ * 入力する画像をセットしたオブジェクト。\r
* @throws NyARException\r
*/\r
public void progress(NyARRealitySource i_in) throws NyARException\r
return;\r
}\r
/**\r
- * Realityターゲットリストの全ての項目を更新します。この関数内では、リスト要素の増減はありません。\r
* {@link #progress}のサブ関数です。\r
+ * RTターゲットリストの全ての項目を更新します。この関数内では、リスト要素の増減はありません。\r
* @throws NyARException\r
*/\r
private final void upgradeLists() throws NyARException\r
}\r
}\r
/**\r
- * Realityターゲットリストの全ての項目のアップグレード処理を行います。この関数内でリスト要素の加算/減算/種別変更処理を行います。\r
* {@link #progress}のサブ関数です。\r
+ * RTターゲットリストの全ての項目のアップグレード処理を行います。この関数内でリスト要素の加算/減算/種別変更処理を行います。\r
* @throws NyARException\r
*/\r
private final void updateLists() throws NyARException\r
NyARRealityTarget tar=rt_array[i];\r
if(tar._ref_tracktarget._delay_tick==0){\r
//30fps前後で1秒間の認識率とする。\r
- tar.grab_rate+=3;\r
- if(tar.grab_rate>100){tar.grab_rate=100;}\r
+ tar._grab_rate+=3;\r
+ if(tar._grab_rate>100){tar._grab_rate=100;}\r
switch(tar._target_type)\r
{\r
case NyARRealityTarget.RT_DEAD:\r
}\r
}else{\r
//更新をパスして補足レートの再計算(混ぜて8で割る)\r
- tar.grab_rate=tar.grab_rate-(3*tar._ref_tracktarget._delay_tick);\r
- if(tar.grab_rate<0){tar.grab_rate=0;}\r
+ tar._grab_rate=tar._grab_rate-(3*tar._ref_tracktarget._delay_tick);\r
+ if(tar._grab_rate<0){tar._grab_rate=0;}\r
}\r
}\r
}\r
//RealityTargetの編集関数\r
\r
/**\r
- * Realityターゲットリストへ新しい{@link NyARRealityTarget}を追加する。\r
+ * RTターゲットリストへ新しい{@link NyARRealityTarget}を追加する。\r
* @param i_track_target\r
- * UnknownTargetに関連付ける{@link NyARTarget}.このターゲットは、{@link NyARTargetStatus#ST_RECT}であること？\r
+ * UnknownTargetに関連付ける{@link NyARTarget}.このRTターゲットは、{@link NyARTargetStatus#ST_RECT}であること？\r
*/\r
private final NyARRealityTarget addUnknownTarget(NyARTarget i_track_target) throws NyARException\r
{\r
return rt;\r
}\r
/**\r
- * Realityターゲットリストから指定したインデクス番号のターゲットを削除します。\r
+ * RTターゲットリストから指定したインデクス番号のRTターゲットを削除します。\r
* @param i_index\r
*/\r
private final void deleteTarget(int i_index)\r
////////////////////////////////////////////////////////////////////////////////\r
\r
/**\r
- * 指定したターゲットを、UnknownターゲットからKnownターゲットへ遷移させます。\r
+ * この関数は、指定したRTターゲットをUnknownステータスからKnownステータスへ遷移させます。\r
* @param i_item\r
- * 移動するターゲット\r
+ * 遷移させるRTターゲット。thisインスタンスから得られたものである必要があります。\r
* @param i_dir\r
- * ã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81®äº\88å\82\99ç\9f¥è\98ã\80\82ARToolkitのdirectionでどの方位であるかを示す値\r
+ * ã\81\93ã\81®RTã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81\8cã\80\81ARToolKitのdirectionでどの方位であるかを示す値\r
* @param i_marker_size\r
- * ã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81®äº\88å\82\99ç\9f¥è\98ã\80\82ã\83\9eã\83¼ã\82«ã\83¼ã\81®é«\98ã\81\95/å¹\85ã\81\8cã\81\84ã\81\8fã\82\89ã\81§ã\81\82ã\82\8bã\81\8bã\82\92示ã\81\99å\80¤[mmå\8d\98ä½\8d]\r
+ * マーカーの高さ/幅がいくらであるかを示す値[mm単位]\r
* @return\r
* 成功するとtrueを返します。\r
* @throws NyARException \r
\r
\r
/**\r
- * 指定したターゲットを、UnknownターゲットからKnownターゲットへ遷移させます。\r
+ * この関数は、指定したRTターゲットをUnknownステータスからKnownステータスへ遷移させます。\r
* @param i_item\r
- * 移動するターゲット\r
+ * 遷移させるRTターゲット。thisインスタンスから得られたものである必要があります。\r
* @param i_dir\r
- * ã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81®äº\88å\82\99ç\9f¥è\98ã\80\82ARToolkitのdirectionでどの方位であるかを示す値\r
+ * ã\81\93ã\81®RTã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81\8cã\80\81ARToolKitのdirectionでどの方位であるかを示す値\r
* @param i_marker_width\r
- * ã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81®äº\88å\82\99ç\9f¥è\98ã\80\82ã\83\9eã\83¼ã\82«ã\83¼ã\81®é«\98ã\81\95がいくらであるかを示す値[mm単位]\r
+ * ã\83\9eã\83¼ã\82«ã\83¼ã\81®å¹\85がいくらであるかを示す値[mm単位]\r
* @param i_marker_height\r
- * ã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81®äº\88å\82\99ç\9f¥è\98ã\80\82ã\83\9eã\83¼ã\82«ã\83¼ã\81®å¹\85がいくらであるかを示す値[mm単位]\r
+ * ã\83\9eã\83¼ã\82«ã\83¼ã\81®é«\98ã\81\95がいくらであるかを示す値[mm単位]\r
* @return\r
* 成功するとtrueを返します。\r
* @throws NyARException \r
return true;\r
}\r
/**\r
- * 指定したKnown,またはUnknownターゲットを、50サイクルの間Deadターゲットにします。\r
- * Deadターゲットは次回のサイクルでRealityターゲットリストから削除され、一定のサイクル期間の間システムから無視されます。\r
+ * この関数は、指定しRTたターゲットをKnown,またはUnknownステータスからDeadステータスへ遷移させます。\r
+ * {@link #changeTargetToDead(NyARRealityTarget, int)}の第二引数に、50を設定したときと同じ動作です。\r
* @param i_item\r
+ * 遷移させるRTターゲット。thisインスタンスから得られたものである必要があります。\r
* @throws NyARException \r
*/ \r
public final void changeTargetToDead(NyARRealityTarget i_item) throws NyARException\r
}\r
\r
/**\r
- * 指定したKnown,またはUnknownターゲットを、Deadターゲットにします。\r
- * Deadターゲットは次回のサイクルでRealityターゲットリストから削除され、一定のサイクル期間の間システムから無視されます。\r
+ * この関数は、指定したRTターゲットをKnown,またはUnknownステータスからDeadステータスへ遷移させます。\r
+ * Deadターゲットは次回のサイクルでRealityターゲットリストから削除され、i_dead_cycleに指定したサイクル期間、システムから無視されます。\r
* @param i_item\r
+ * 遷移させるターゲット。thisインスタンスから得られたものである必要があります。\r
* @param i_dead_cycle\r
- * 無視するサイクルを指定します。1サイクルは1フレームです。デフォルトは50です。\r
+ * 無視するサイクルを指定します。1サイクルは1フレームです。画像入力のフレームレートにより、実時間は異なります。\r
* @throws NyARException \r
*/\r
public final void changeTargetToDead(NyARRealityTarget i_item,int i_dead_cycle) throws NyARException\r
return;\r
}\r
/**\r
- * 指定したシリアル番号のUnknownターゲットを、Knownターゲットへ移動します。\r
+ * この関数は、シリアル番号に一致するRTターゲットをUnknownステータスからKnownステータスへ遷移させます。\r
* @param i_serial\r
- * ターゲットのシリアル番号を示す値\r
+ * RTターゲットのシリアル番号を示す値。この値は、{@link NyARRealityTarget#getSerialId()}で得られる値です。\r
* @param i_dir\r
- * ã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81®äº\88å\82\99ç\9f¥è\98ã\80\82ARToolkitのdirectionでどの方位であるかを示す値\r
- * @param i_marker_width\r
- * ã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81®äº\88å\82\99ç\9f¥è\98ã\80\82ã\83\9eã\83¼ã\82«ã\83¼ã\81®ã\82µã\82¤ã\82ºがいくらであるかを示す値[mm単位]\r
+ * ã\81\93ã\81®RTã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81\8cã\80\81ARToolKitのdirectionでどの方位であるかを示す値\r
+ * @param i_marker_size\r
+ * ã\83\9eã\83¼ã\82«ã\83¼ã\81®é«\98ã\81\95/å¹\85がいくらであるかを示す値[mm単位]\r
* @return\r
* 成功すると、trueを返します。\r
* @throws NyARException \r
return changeTargetToKnown(item,i_dir,i_marker_width);\r
}\r
/**\r
- * 指定したシリアル番号のKnown/UnknownターゲットをDeadターゲットへ遷移します。\r
+ * この関数は、シリアル番号に一致するRTターゲットをKnown/UnknownステータスからDeadターゲットへ遷移させます。\r
* @param i_serial\r
+ * RTターゲットのシリアル番号を示す値。この値は、{@link NyARRealityTarget#getSerialId()}で得られる値です。\r
+ * @return\r
+ * 成功すると、遷移したRTターゲットを返します。\r
* @throws NyARException \r
*/\r
public final NyARRealityTarget changeTargetToDeadBySerial(long i_serial) throws NyARException\r
}\r
\r
/**\r
- * 現在のUnKnownターゲットの数を返します。\r
+ * この関数は、UnKnownステータスのRTターゲット数を返します。\r
* @return\r
+ * Unknownステータスのターゲット数。\r
*/\r
public final int getNumberOfUnknown()\r
{\r
return this._number_of_unknown;\r
}\r
/**\r
- * 現在のKnownターゲットの数を返します。\r
+ * この関数は、KnownステータスのRTターゲット数を返します。\r
* @return\r
+ * Knownステータスのターゲット数。\r
*/\r
public final int getNumberOfKnown()\r
{\r
return this._number_of_known;\r
}\r
/**\r
- * 現在のDeadターゲットの数を返します。\r
+ * この関数は、DeadステータスのRTターゲット数を返します。\r
* @return\r
+ * Deadステータスのターゲット数。\r
*/\r
public final int getNumberOfDead()\r
{\r
return this._number_of_dead;\r
}\r
/**\r
- * Realityターゲットリストへの参照値を返します。\r
- * このリストは編集関数を持ちますが、直接編集してはいけません。\r
+ * この関数は、RTターゲットリストへの参照値を返します。\r
+ * 得られたオブジェクトは、読出し専用です。直接操作しないでください。\r
* @return\r
+ * [READ ONLY]RTターゲットリストへの参照値。\r
*/\r
public NyARRealityTargetList refTargetList()\r
{\r
}\r
\r
/**\r
- * Knownターゲットを検索して、配列に返します。\r
+ * この関数は、KnownステータスのRTターゲットを検索して、配列に返します。\r
* @param o_result\r
* 結果を格納する配列です。格納されるターゲットの最大数は、コンストラクタの設定値と同じです。\r
- * 配列サイズが不足した場合は、発見した順に最大数を返します。\r
+ * 配列サイズが不足した場合は、発見した順に配列の個数だけ返します。\r
* @return\r
* 配列に格納したターゲットの数を返します。\r
*/\r
return this.target.selectTargetsByType(NyARRealityTarget.RT_KNOWN, o_result);\r
}\r
/**\r
- * Unknownターゲットを検索して、配列に返します。\r
+ * この関数は、UnknownステータスのRTターゲットを検索して、配列に返します。\r
* @param o_result\r
* 結果を格納する配列です。格納されるターゲットの最大数は、コンストラクタの設定値と同じです。\r
- * 配列サイズが不足した場合は、発見した順に最大数を返します。\r
+ * 配列サイズが不足した場合は、発見した順に配列の個数だけ返します。\r
* @return\r
* 配列に格納したターゲットの数を返します。\r
*/\r
return this.target.selectTargetsByType(NyARRealityTarget.RT_UNKNOWN, o_result);\r
}\r
/**\r
- * Unknownターゲットを1個検索して返します。\r
+ * この関数は、UnknownステータスのRTターゲットを1個検索して返します。\r
+ * <p>注意-\r
+ * この関数を使うと、複数のUnknownステータスのRTターゲットがあるときに、その順番の影響で取りこぼしが発生することがあります。\r
+ * </p>\r
* @return\r
* 一番初めに発見したターゲットを返します。見つからないときはNULLです。\r
*/\r
return this.target.selectSingleTargetByType(NyARRealityTarget.RT_UNKNOWN);\r
}\r
/**\r
- * フラスタムオブジェクトを返します。\r
+ * この関数は、フラスタムオブジェクトの参照値を返します。\r
+ * フラスタムオブジェクトは、コンストラクタに与えたカメラパラメータから計算されます。\r
* @return\r
+ * [READ ONLY]フラスタムオブジェクト。\r
*/\r
public NyARFrustum refFrustum()\r
{\r
return this._frustum;\r
}\r
/**\r
- * ARToolKitスタイルの射影変換行列を返します。\r
+ * この関数は、ARToolKitスタイルの射影変換行列の参照値を返します。\r
+ * 射影変換行列は、コンストラクタに与えたカメラパラメータから計算されます。\r
* @return\r
+ * [READ ONLY]射影変換行列オブジェクト。\r
*/\r
public NyARPerspectiveProjectionMatrix refPerspectiveProjectionMatrix()\r
{\r
return this._ref_prjmat;\r
}\r
/**\r
- * 画面座標系の4頂点でかこまれる領域から、RGB画像をo_rasterに取得します。\r
+ * この関数は、画面座標系の4頂点でかこまれる領域を遠近法で自由変形して、o_rasterにRGB画像を取得します。\r
* @param i_vertex\r
+ * 四角形を定義する4頂点を格納した配列。\r
* @param i_resolution\r
* 1ピクセルあたりのサンプル数です。二乗した値が実際のサンプル数になります。\r
+ * 2なら4ピクセル、4なら16ピクセルの入力から、出力1ピクセルを生成します。\r
* @param o_raster\r
+ * 出力先のラスタオブジェクト。\r
* @return\r
+ * 画像取得に成功するとtrue\r
* @throws NyARException\r
*/\r
public final boolean getRgbPatt2d(NyARRealitySource i_src,NyARIntPoint2d[] i_vertex,int i_resolution,INyARRgbRaster o_raster) throws NyARException\r
return i_src.refPerspectiveRasterReader().read4Point(i_src.refRgbSource(),i_vertex,0,0,i_resolution, o_raster);\r
}\r
/**\r
- * 画面座標系の4頂点でかこまれる領域から、RGB画像をo_rasterに取得します。\r
+ * この関数は、画面座標系の4頂点でかこまれる領域を遠近法で自由変形して、o_rasterにRGB画像を取得します。\r
* @param i_vertex\r
+ * 四角形を定義する4頂点を格納した配列。 \r
* @param i_resolution\r
* 1ピクセルあたりのサンプル数です。二乗した値が実際のサンプル数になります。\r
+ * 2なら4ピクセル、4なら16ピクセルの入力から、出力1ピクセルを生成します。\r
* @param o_raster\r
+ * 出力先のラスタオブジェクト。\r
* @return\r
+ * 画像取得に成功するとtrue\r
* @throws NyARException\r
*/\r
public final boolean getRgbPatt2d(NyARRealitySource i_src,NyARDoublePoint2d[] i_vertex,int i_resolution,INyARRgbRaster o_raster) throws NyARException\r
{\r
return i_src.refPerspectiveRasterReader().read4Point(i_src.refRgbSource(),i_vertex,0,0,i_resolution, o_raster);\r
- } \r
+ }\r
/**\r
- * ã\82«ã\83¡ã\83©åº§æ¨\99ç³»ã\81®4é \82ç\82¹ã\81§ã\81\8bã\81\93ã\81¾ã\82\8cã\82\8bé \98å\9f\9fã\81\8bã\82\89ã\80\81RGBç\94»å\83\8fã\82\92o_rasterã\81«取得します。\r
+ * ã\81\93ã\81®é\96¢æ\95°ã\81¯ã\80\81RTã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\81®ï¼\93次å\85\83座æ¨\99ç³»ã\81§å®\9a義ã\81\95ã\82\8cã\82\8b4é \82ç\82¹ã\81§ã\81\8bã\81\93ã\81¾ã\82\8cã\82\8bé \98å\9f\9fã\81\8bã\82\89ã\80\81o_rasterã\81«RGBç\94»å\83\8fã\82\92取得します。\r
* @param i_vertex\r
+ * RTターゲットの３次元座標系にある、四角形を定義する4頂点を格納した配列。 \r
* @param i_matrix\r
* i_vertexに適応する変換行列。\r
- * ターゲットの姿勢行列を指定すると、ターゲット座標系になります。不要ならばnullを設定してください。\r
+ * ターゲットの姿勢行列を指定すると、ターゲット座標系になります。不要ならばnullを設定してください\r
+ * (nullの場合、カメラ座標系での定義になります。)\r
* @param i_resolution\r
+ * 1ピクセルあたりのサンプル数です。二乗した値が実際のサンプル数になります。\r
+ * 2なら4ピクセル、4なら16ピクセルの入力から、出力1ピクセルを生成します。\r
* @param o_raster\r
+ * 出力先のラスタオブジェクト。\r
* @return\r
+ * 画像取得に成功するとtrue\r
* @throws NyARException\r
*/\r
public final boolean getRgbPatt3d(NyARRealitySource i_src,NyARDoublePoint3d[] i_vertex,NyARDoubleMatrix44 i_matrix,int i_resolution,INyARRgbRaster o_raster) throws NyARException\r
import jp.nyatla.nyartoolkit.rpf.tracker.nyartk.status.NyARRectTargetStatus;\r
\r
/**\r
- * Realityターゲットを定義します。\r
- * {@link #tag}以外のクラスメンバに対する書き込み操作を行わないでください。\r
- *\r
+ * このクラスは、Realityターゲット(RTターゲット)のプロパティを格納します。\r
+ * プロパティには、ターゲットのメタデータ、二次元座標系データ、三次元座標系データの３個があります。\r
+ * ターゲットのメタデータは常に利用が可能です。二次元座標系データは、{@link #RT_DEAD}以外のステータスを持つ\r
+ * RTターゲットだけが利用できます。三次元座標データは、{@link #RT_KNOWN}ステータスを持つRTターゲットだけが利用できます。\r
+ * ユーザーが直接書き込みできるのは{@link #tag}メンバのみです。他のメンバには、書き込みをしないでください。\r
+ * \r
*/\r
public class NyARRealityTarget extends NyARManagedObject\r
{\r
- /**ã\80\80ã\83¦ã\83¼ã\82¶ã\82ªã\83\96ã\82¸ã\82§ã\82¯ã\83\88ã\82\92é\85\8dç½®ã\81\99ã\82\8bã\83\9dã\82¤ã\83³ã\82¿ã\83¼ã\82¿ã\82°ã\80\82ã\83¦ã\83¼ã\82¶ã\81\8cè\87ªç\94±ã\81«ã\82ªã\83\96ã\82¸ã\82§ã\82¯ã\83\88ã\83\9dã\82¤ã\83³ã\82¿ã\82\92é\85\8dç½®ã\81§ã\81\8dã\82\8b。\r
- * {@link INyARDisposable}ã\82¤ã\83³ã\82¿ã\83\95ã\82§ã\82¤ã\82¹ã\82\92æ\8c\81ã\81¤ã\82ªã\83\96ã\82¸ã\82§ã\82¯ã\83\88ã\82\92æ\8c\87å®\9aã\81\99ã\82\8bã\81¨ã\80\81ã\81\93ã\81®ã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\82\92é\96\8bæ\94¾ã\81\99ã\82\8bã\81¨ã\81\8dã\81«{@link INyARDisposable#dispose()}ã\82\92ã\82³ã\83¼ã\83«ã\81\99ã\82\8b。\r
- * <p>{@link INyARDisposable}インタフェイスは、Managed環境下では通常不要。</p>\r
+ /**ã\80\80ã\83¦ã\83¼ã\82¶ã\82ªã\83\96ã\82¸ã\82§ã\82¯ã\83\88ã\82\92é\85\8dç½®ã\81\99ã\82\8bã\83\9dã\82¤ã\83³ã\82¿ã\83¼ã\82¿ã\82°ã\81§ã\81\99ã\80\82ã\83¦ã\83¼ã\82¶ã\81\8cè\87ªç\94±ã\81«ã\82ªã\83\96ã\82¸ã\82§ã\82¯ã\83\88ã\82\92é\85\8dç½®ã\81§ã\81\8dã\81¾ã\81\99。\r
+ * {@link INyARDisposable}ã\82¤ã\83³ã\82¿ã\83\95ã\82§ã\82¤ã\82¹ã\82\92æ\8c\81ã\81¤ã\82ªã\83\96ã\82¸ã\82§ã\82¯ã\83\88ã\82\92æ\8c\87å®\9aã\81\99ã\82\8bã\81¨ã\80\81ã\81\93ã\81®ã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\82\92é\96\8bæ\94¾ã\81\99ã\82\8bã\81¨ã\81\8dã\81«{@link INyARDisposable#dispose()}ã\81\8cè\87ªå\8b\95ç\9a\84ã\81«ã\82³ã\83¼ã\83«ã\81\95ã\82\8cã\81¾ã\81\99。\r
+ * <p>{@link INyARDisposable}インタフェイスは、RTターゲットの消失時に特別な処理を実行したいときに追加してください。</p>\r
*/\r
public Object tag;\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * この関数は、ユーザが使うことはありません。\r
+ * @param i_pool\r
+ * 親となるマネージドオブジェクトプール\r
+ */\r
public NyARRealityTarget(NyARRealityTargetPool i_pool)\r
{\r
super(i_pool._op_interface);\r
this._ref_pool=i_pool;\r
}\r
/**\r
- * @Override\r
+ * ファイナライザです。\r
+ * この関数は、ユーザが使うことはありません。\r
+ * {@link INyARDisposable}に関する処理を追加しています。\r
*/\r
public int releaseObject()\r
{\r
}\r
return ret;\r
}\r
- /** 無効なシリアルID値*/\r
+ /** 定数値。無効なシリアルID値を定義します。*/\r
public final static int INVALID_REALITY_TARGET_ID=-1;\r
private static Object _serial_lock=new Object();\r
private static long _serial_counter=0;\r
\r
/**\r
- * ID生成器。システムの稼働範囲内で一意なIDを持つこと。\r
+ * ID生成器。システムの稼働期間中、一意なRealityTargetSerialIDを返します。\r
+ * この関数は、ユーザが使うことはありません。\r
* @return\r
+ * 一意なID\r
*/\r
public static long createSerialId()\r
{\r
}\r
////////////////////////\r
\r
- /**\r
- * 親情報\r
- */\r
+ /** 親情報*/\r
private NyARRealityTargetPool _ref_pool;\r
////////////////////////\r
//targetの基本情報\r
\r
- /** 内部向けの公開メンバ変数です。{@link #getSerialId}を使ってください。*/\r
+ /** 内部向けのメンバ変数です。{@link #getSerialId}を使ってください。*/\r
public long _serial;\r
- /** 内部向けの公開メンバ変数です。{@link #refTransformMatrix}を使ってください。*/\r
+ /** 内部向けのメンバ変数です。{@link #refTransformMatrix}を使ってください。*/\r
public NyARTransMatResult _transform_matrix=new NyARTransMatResult();\r
\r
- /** ターゲットの種類。未知のターゲット。*/\r
+ /** ターゲットの種類。Unknownステータスであることを示します。*/\r
public final static int RT_UNKNOWN =0;\r
- /** ターゲットの種類。既知のターゲット。*/\r
+ /** ターゲットの種類。Knownステータスである事を示します。*/\r
public final static int RT_KNOWN =2;\r
- /** ターゲットの種類。間もなく消失するターゲット。次回のprogressでリストから除去される。*/\r
+ /** ターゲットの種類。Deadステータスである事を示します。*/\r
public final static int RT_DEAD =4;\r
\r
- /** 内部向けpublicメンバ変数。{@link #getTargetType()}を使ってください。*/\r
+ /** 内部向けのメンバ変数です。{@link #getTargetType()}を使ってください。*/\r
public int _target_type;\r
\r
- /** 内部向けpublicメンバ。 ターゲットのオフセット位置。*/\r
+ /** 内部向けのメンバ変数です。ターゲットのオフセット位置。*/\r
public NyARRectOffset _offset=new NyARRectOffset();\r
- /** 内部向けpublicメンバ。このターゲットが参照しているトラックターゲット*/\r
+ /** 内部向けのメンバ変数です。このターゲットが参照しているトラックターゲット*/\r
public NyARTarget _ref_tracktarget;\r
- /** 内部向けpublicメンバ。スクリーン上の歪み解除済み矩形。*/\r
+ /** 内部向けのメンバ変数です。スクリーン上の歪み解除済み矩形。*/\r
public NyARSquare _screen_square=new NyARSquare();\r
- /** 内部向けpublicメンバ。getGrabbRateを使ってください。*/\r
- public int grab_rate;\r
+ /** 内部向けのメンバ変数です。{@link #getGrabbRate}を使ってください。*/\r
+ public int _grab_rate;\r
\r
\r
\r
/**\r
- * カメラ座標系をターゲット座標系に変換する行列の参照値を返します。\r
+ * この関数は、RTターゲットの姿勢変換行列の参照値を返します。\r
+ * 姿勢変換行列は、カメラ座標系をRTターゲット座標系に変換する行列です。\r
* この値は変更しないでください。（編集するときは、コピーを作ってください。）\r
+ * 値は、次のサイクルを実行するまで有効です。\r
* @return\r
+ * [READ ONLY]姿勢変換行列の参照値。\r
*/\r
public final NyARTransMatResult refTransformMatrix()\r
{\r
return this._transform_matrix;\r
}\r
/**\r
- * このターゲットのタイプを返します。\r
- * {@link #RT_UNKNOWN}=未確定ターゲット。2次元座標利用可能\r
- * {@link #RT_KNOWN} =確定した既知のターゲット。3次元座標利用可能\r
- * {@link #RT_DEAD} =次のprogressで削除するターゲット\r
+ * この関数は、RTターゲットのステータスタイプを返します。\r
+ * <p>値のサマリ-\r
+ * 詳しくは、{@link NyARReality}を参考にして下さい。\r
+ * <ul>\r
+ * <li>{@link #RT_UNKNOWN}=未確定ターゲット。2次元座標利用可能\r
+ * <li>{@link #RT_KNOWN} =確定した既知のターゲット。3次元座標利用可能\r
+ * <li>{@link #RT_DEAD} =次のprogressで削除するターゲット\r
+ * </ul>\r
* @return\r
+ * RTターゲットのステータス値\r
*/\r
public int getTargetType()\r
{\r
return this._target_type;\r
}\r
/**\r
- * Reality内で一意な、ターゲットのシリアルIDです。\r
+ * この関数は、RTターゲットのシリアルIDを返します。\r
+ * 詳しくは、{@link NyARReality}を参考にして下さい。\r
* @return\r
+ * シリアルID。\r
*/\r
public long getSerialId()\r
{\r
}\r
\r
/**\r
- * このターゲットの補足率を返します。0-100の数値です。\r
- * 20を切ると消失の可能性が高い？\r
+ * この関数は、RTターゲットの補足率を返します。\r
+ * 値は、一定期間における、ターゲットの認識率を元に計算します。\r
+ * 20を切ると消失の可能性が高い？様な気がします。\r
* @return\r
+ * 補足率の値。0-100の数値です。\r
*/\r
public int getGrabbRate()\r
{\r
- return this.grab_rate;\r
+ return this._grab_rate;\r
}\r
/**\r
- * ターゲットの頂点配列への参照値を返します。この値は、二次元検出系の出力値です。\r
- * 値が有効なのは、次のサイクルを実行するまでの間です。\r
+ * この関数は、RTターゲットの四角系頂点配列への参照値を返します。\r
+ * 二次元系の座標値です。{@link #RT_KNOWN}と{@link #RT_UNKNOWN}ステータスのRTターゲットで使用できます。\r
+ * 樽型歪みの逆矯正は行いません。\r
+ * 値は、次のサイクルを実行するまで有効です。\r
* @return\r
+ * [READ ONLY]ターゲットの四角系の頂点配列(4要素)。\r
*/\r
public final NyARDoublePoint2d[] refTargetVertex()\r
{\r
return ((NyARRectTargetStatus)(this._ref_tracktarget._ref_status)).vertex;\r
}\r
/**\r
- * 対象矩形の頂点配列をコピーして返します。\r
+ * この関数は、RTターゲットの四角系頂点配列をコピーして返します。\r
+ * 二次元系の座標値です。{@link #RT_KNOWN}と{@link #RT_UNKNOWN}ステータスのRTターゲットで使用できます。\r
* 樽型歪みの逆矯正は行いません。\r
* @param o_vertex\r
+ * 値を格納する配列。4要素である事。\r
*/\r
public final void getTargetVertex(NyARDoublePoint2d[] o_vertex)\r
{\r
}\r
}\r
/**\r
- * 対象矩形の中央点を返します。\r
- * 樽型歪みの逆矯正は行いません。\r
+ * この関数は、RTターゲットの四角系の中央点を返します。\r
+ * 二次元系の座標値です。{@link #RT_KNOWN}と{@link #RT_UNKNOWN}ステータスのRTターゲットで使用できます。\r
+ * 樽型歪み逆矯正は行いません。\r
* @param o_center\r
+ * 値を格納するオブジェクト。\r
*/\r
public final void getTargetCenter(NyARDoublePoint2d o_center)\r
{\r
NyARDoublePoint2d.makeCenter(((NyARRectTargetStatus)(this._ref_tracktarget._ref_status)).vertex,4,o_center);\r
}\r
/**\r
- * {@link #getTargetCenter}の出力型違いの関数です。\r
+ * {@link #getTargetCenter(NyARDoublePoint2d)}の出力型違いの関数です。\r
* @param o_center\r
+ * 値を格納するオブジェクト。\r
*/\r
public final void getTargetCenter(NyARIntPoint2d o_center)\r
{\r
NyARDoublePoint2d.makeCenter(((NyARRectTargetStatus)(this._ref_tracktarget._ref_status)).vertex,4,o_center);\r
}\r
/**\r
- * 画面上の点が、このターゲットを構成する頂点の内側にあるか判定します。\r
+ * この関数は、点がRTターゲットの二次元座標系の四角形の内側にあるか判定します。\r
* (範囲ではなく、頂点の内側であることに注意してください。)\r
- * この関数は、Known/Unknownターゲットに使用できます。\r
+ * 二次元系の座標値です。{@link #RT_KNOWN}と{@link #RT_UNKNOWN}ステータスのRTターゲットで使用できます。\r
+ * 入力値の樽型歪み矯正は行いません。\r
* @param i_x\r
+ * 検査する座標x\r
* @param i_y\r
+ * 検査する座標y\r
* @return\r
+ * 点が内側にあるときはtrue,無い時はfalse\r
*/\r
public final boolean isInnerVertexPoint2d(int i_x,int i_y)\r
{\r
return true;\r
}\r
/**\r
- * 画面上の点が、このターゲットを包括する矩形の内側にあるかを判定します。\r
- * この関数は、Known/Unknownターゲットに使用できます。\r
+ * この関数は、点がRTターゲットの二次元座標系の四角形を包括する矩形の内側にあるか判定します。\r
+ * 二次元系の座標値です。{@link #RT_KNOWN}と{@link #RT_UNKNOWN}ステータスのRTターゲットで使用できます。\r
+ * 入力値の樽型歪み矯正は行いません。\r
+ * <p>メモ-この関数にはnewが残っています。大量に呼び出すときにはnewの削除を検討しましょう。\r
+ * </p>\r
* @param i_x\r
+ * 検査する座標x\r
* @param i_y\r
+ * 検査する座標y\r
* @return\r
- * <p>メモ:この関数にはnewが残ってるので注意</p>\r
+ * 点が内側にあるときはtrue,無い時はfalse\r
*/\r
public final boolean isInnerRectPoint2d(int i_x,int i_y)\r
{\r
}\r
\r
/**\r
- * ターゲット座標系の4頂点でかこまれる領域を射影した平面から、RGB画像をo_rasterに取得します。\r
+ * この関数は、RTターゲット座標系の4頂点で囲まれる領域を射影した平面から、RGB画像をo_rasterに取得します。\r
+ * 三次元系の座標値です。{@link #RT_KNOWN}ステータスのRTターゲットで使用できます。\r
+ * <p>メモ:この関数にはnewが残ってるので注意</p>\r
+ * @param i_src\r
+ * 画像ソース。このRTターゲットの親の{@link NyARReality}に入力した{@link NyARRealitySource}オブジェクト。\r
* @param i_vertex\r
* ターゲットのオフセットを基準値とした、頂点座標。要素数は4であること。(mm単位)\r
* @param i_matrix\r
- * i_vertexに適応する変換行列。\r
- * ターゲットの姿勢行列を指定すると、ターゲット座標系になります。不要ならばnullを設定してください。\r
+ * RTターゲット座標系の姿勢変換行列。値を指定すると、RTターゲット座標系と平行な面から、任意の姿勢に変換した後にパターンを取得します。\r
+ * nullを指定すると、RTターゲット座標系と同じ平面の座標系で取得します。\r
+ * この変数は、例えばマーカの40mm上のパターンを取得したりするときに役立ちます。(誤差の影響を強く受けるため、精密な測定には向いていません。)\r
* @param i_resolution\r
- * 1ピクセルあたりのサンプリング値(n^2表現)\r
+ * 1ピクセルあたりのサンプル数です。二乗した値が実際のサンプル数になります。\r
+ * 2なら4ピクセル、4なら16ピクセルの入力から、出力1ピクセルを生成します。\r
* @param o_raster\r
- * 出力ラスタ\r
+ * 出力先のラスタオブジェクト。\r
* @return\r
+ * 画像取得に成功するとtrue\r
* @throws NyARException\r
- * <p>メモ:この関数にはnewが残ってるので注意</p>\r
*/\r
public final boolean getRgbPatt3d(NyARRealitySource i_src,NyARDoublePoint3d[] i_vertex,NyARDoubleMatrix44 i_matrix,int i_resolution,INyARRgbRaster o_raster) throws NyARException\r
{\r
return i_src.refPerspectiveRasterReader().read4Point(i_src.refRgbSource(),da4,0,0,i_resolution, o_raster);\r
}\r
/**\r
- * ターゲットと同じ平面に定義した矩形から、パターンを取得します。\r
+ * RTターゲット座標系の4頂点で定義する矩形から、RGB画像をo_rasterに取得します。\r
+ * 三次元系の座標値です。{@link #RT_KNOWN}ステータスのRTターゲットで使用できます。\r
* @param i_src\r
+ * 画像ソース。このRTターゲットの親の{@link NyARReality}に入力した{@link NyARRealitySource}オブジェクト。\r
* @param i_x\r
- * ターゲットのオフセットを基準値とした、矩形の左上座標(mm単位)\r
+ * RTターゲット座標系の矩形の左上座標X(mm単位)\r
* @param i_y\r
- * ターゲットのオフセットを基準値とした、矩形の左上座標(mm単位)\r
+ * RTターゲット座標系の矩形の左上座標Y(mm単位)\r
* @param i_w\r
- * ターゲットのオフセットを基準値とした、矩形の幅(mm単位)\r
+ * RTターゲット座標系の矩形の幅(mm単位)\r
* @param i_h\r
- * ターゲットのオフセットを基準値とした、矩形の幅(mm単位)\r
+ * RTターゲット座標系の矩形の高さ(mm単位)\r
* @param i_resolution\r
- * 1ピクセルあたりのサンプリング値(n^2表現)\r
+ * 1ピクセルあたりのサンプル数です。二乗した値が実際のサンプル数になります。\r
+ * 2なら4ピクセル、4なら16ピクセルの入力から、出力1ピクセルを生成します。\r
* @param o_raster\r
- * 出力ラスタ\r
+ * 出力先のラスタオブジェクト。\r
* @return\r
+ * 画像取得に成功するとtrue\r
* @throws NyARException\r
*/\r
public final boolean getRgbRectPatt3d(NyARRealitySource i_src,double i_x,double i_y,double i_w,double i_h,int i_resolution,INyARRgbRaster o_raster) throws NyARException\r
import jp.nyatla.nyartoolkit.NyARException;\r
import jp.nyatla.nyartoolkit.core.types.stack.*;\r
\r
+/**\r
+ * このクラスは、{@link NyARRealityTarget}の参照リストを定義します。\r
+ * 基本的にユーザが生成することはありません。\r
+ * {@link NyARReality}がメンバ変数としてオブジェクトを所有します。\r
+ */\r
public class NyARRealityTargetList extends NyARPointerStack<NyARRealityTarget>\r
{\r
+ /**\r
+ * コンストラクタです。\r
+ * @param i_max_target\r
+ * リストの最大格納数です。\r
+ * @throws NyARException\r
+ */\r
public NyARRealityTargetList(int i_max_target) throws NyARException\r
{\r
super.initInstance(i_max_target,(Class<NyARRealityTarget>)NyARRealityTarget.class);\r
}\r
/**\r
- * RealityTargetのシリアル番号をキーに、ターゲットを探索します。\r
+ * この関数は、シリアル番号をキーに、リストからターゲットを探索します。\r
* @param i_serial\r
+ * 検索するシリアルID。{@link RealityTarget}を参照。\r
* @return\r
+ * 見つかると、そのオブジェクトの参照値。無ければnull\r
*/\r
public final NyARRealityTarget getItemBySerial(long i_serial)\r
{\r
return null;\r
}\r
/**\r
- * ã\82·ã\83ªã\82¢ã\83«IDã\81\8ci_serialã\81«ä¸\80è\87´ã\81\99ã\82\8bã\82¿ã\83¼ã\82²ã\83\83ã\83\88のインデクス番号を返します。\r
+ * ã\81\93ã\81®é\96¢æ\95°ã\81¯ã\80\81ã\82·ã\83ªã\82¢ã\83«ç\95ªå\8f·ã\82\92ã\82ã\83¼ã\81«ã\80\81ã\83ªã\82¹ã\83\88ã\81\8bã\82\89ã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\82\92æ\8e¢ç´¢ã\81\97ã\81¦ã\80\81ã\81\9dのインデクス番号を返します。\r
* @param i_serial\r
+ * 検索するシリアルID。{@link RealityTarget}を参照。\r
* @return\r
- * @throws NyARException\r
+ * リスト中のインデクス番号。\r
*/\r
public final int getIndexBySerial(int i_serial)\r
{\r
return -1;\r
}\r
/**\r
- * リストから特定のタイプのターゲットだけを選択して、一括でo_resultへ返します。\r
+ * この関数は、特定のステータスのRTターゲットだけを選択して、一括でo_resultへ返します。\r
+ * 配列サイズが十分でない場合、見つかった順に、配列の上限まで要素を返します。\r
* @param i_type\r
- * ターゲットタイプです。NyARRealityTarget.RT_*を指定してください。\r
+ * 検索するRTターゲットのステータス値。{@link NyARRealityTarget}で定義される、RT_から始まるステータスタイプ値を指定します。\r
* @param o_list\r
* 選択したターゲットを格納する配列です。\r
* @return\r
return num;\r
}\r
/**\r
- * ã\83ªã\82¹ã\83\88ã\81\8bã\82\89ç\89¹å®\9aã\81®ã\82¿ã\82¤ã\83\97ã\81®ã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\82\921å\80\8bé\81¸æ\8a\9eã\81\97ã\81¦ã\80\81返します。\r
+ * ã\81\93ã\81®é\96¢æ\95°ã\81¯ã\80\81ç\89¹å®\9aã\81®ã\82¹ã\83\86ã\83¼ã\82¿ã\82¹ã\81®RTã\82¿ã\83¼ã\82²ã\83\83ã\83\88ã\82\921å\80\8bé\81¸æ\8a\9eã\81\97ã\81¦返します。\r
* @param i_type\r
- * ターゲットタイプです。NyARRealityTarget.RT_*を指定してください。\r
+ * 検索するRTターゲットのステータス値。{@link NyARRealityTarget}で定義される、RT_から始まるステータスタイプ値を指定します。\r
* @return\r
* 見つかるとターゲットへの参照を返します。見つからなければNULLです。\r
*/\r
import jp.nyatla.nyartoolkit.core.utils.NyARManagedObjectPool;\r
import jp.nyatla.nyartoolkit.rpf.tracker.nyartk.NyARTarget;\r
\r
+/**\r
+ * このクラスは、{@link NyARRealityTarget}のオブジェクトプールを定義します。\r
+ * 基本的にユーザが生成することはありません。\r
+ * {@link NyARReality}がメンバ変数としてオブジェクトを所有します。\r
+ */\r
public class NyARRealityTargetPool extends NyARManagedObjectPool<NyARRealityTarget>\r
{\r
- //targetでの共有オブジェクト\r
+ /** 所有する{@link NyARRealityTarget}が共有する計算インスタンスの参照値*/\r
public NyARPerspectiveProjectionMatrix _ref_prj_mat;\r
- /** Target間での共有ワーク変数。*/\r
+ /** 所有する{@link NyARRealityTarget}が共有する一時オブジェクト*/\r
public NyARDoublePoint3d[] _wk_da3_4=NyARDoublePoint3d.createArray(4);\r
public NyARDoublePoint2d[] _wk_da2_4=NyARDoublePoint2d.createArray(4);\r
- \r
+ /**\r
+ * コンストラクタ。\r
+ * @param i_size\r
+ * プールの最大サイズです。\r
+ * @param i_ref_prj_mat\r
+ * 計算インスタンスの参照値です。\r
+ * 所有する{@link NyARRealityTarget}が射影変換をするときに使います。\r
+ * @throws NyARException\r
+ */\r
public NyARRealityTargetPool(int i_size,NyARPerspectiveProjectionMatrix i_ref_prj_mat) throws NyARException\r
{\r
this.initInstance(i_size,NyARRealityTarget.class);\r
this._ref_prj_mat=i_ref_prj_mat;\r
return;\r
}\r
+ /**\r
+ * 要素のインスタンスを生成します。\r
+ */\r
protected NyARRealityTarget createElement() throws NyARException\r
{\r
return new NyARRealityTarget(this);\r
}\r
/**\r
- * 新しいRealityTargetを作って返します。\r
+ * オブジェクトプールから、新しい{@link NyARRealityTarget}を割り当てます。\r
* @param tt\r
+ * ラップするトラックターゲットオブジェクト\r
* @return\r
+ * 成功すれば初期化済みのオブジェクト。失敗するとnull\r
* @throws NyARException \r
*/\r
public NyARRealityTarget newNewTarget(NyARTarget tt) throws NyARException\r
if(ret==null){\r
return null;\r
}\r
- ret.grab_rate=50;//開始時の捕捉レートは10%\r
+ ret._grab_rate=50;//開始時の捕捉レートは10%\r
ret._ref_tracktarget=(NyARTarget) tt.refObject();\r
ret._serial=NyARRealityTarget.createSerialId();\r
ret.tag=null;\r
\r
import jp.nyatla.nyartoolkit.rpf.reality.nyartk.*;\r
/**\r
- * NyARRealityクラスの入力コンテナです。\r
- * NyARRealityへ入力する情報セットを定義します。\r
- * \r
- * このクラスは、元画像、元画像に対するPerspectiveReader,元画像からのSampleOutを提供します。\r
+ * このクラスは、{@link NyARReality}へのデータ入力コンテナです。\r
+ * {@link NyARReality}へ入力する情報セットをメンバに持ちます。\r
+ * このクラスは情報セットのみ定義します。関数の実体とメンバ変数の生成は、継承クラスで実装してください。\r
+ * <p>クラスの責務 -\r
+ * 情報セットは、{@link NyARTrackerSource},{@link INyARRgbRaster},{@link NyARPerspectiveRasterReader}\r
+ * の３要素で構成します。クラスは、これらのメンバ間の情報同期を責務とします。同期のタイミングは、メンバ関数の動作で定義します。\r
+ * </p>\r
+ * <p>使い方 -\r
+ * このクラスの派生クラスは、次のように使います。\r
+ * <ol>\r
+ * <li>内部RGBラスタへの書込み({@link #refRgbSource}で得られたオブジェクトへの直接書き込み、又は継承クラスで提供する関数を使った書込み。)\r
+ * <li>{@link NyARReality}への入力。\r
+ * </ol>\r
+ * なお、内部RGBラスタラスタと関連オブジェクトの同期は、{@link NyARReality#progress}で行います。\r
+ * {@link NyARReality}オブジェクトと同期した{@link NyARRealitySource}オブジェクトが完成するのは、{@link NyARReality#progress}を実行した後です。\r
+ * </p>\r
* </ul>\r
*/\r
public abstract class NyARRealitySource\r
{\r
- /**\r
- * RealitySourceの主ラスタ。継承先のコンストラクタで実体を割り当ててください。\r
- */\r
+ /** RealitySourceの主ラスタ。継承先のコンストラクタで実体を割り当ててください。*/\r
protected INyARRgbRaster _rgb_source;\r
- /**\r
- * RealitySourceの主ラスタにリンクしたPerspectiveReader。継承先のコンストラクタで実体を割り当ててください。\r
- */\r
+ /** RealitySourceの主ラスタにリンクしたPerspectiveReader。継承先のコンストラクタで実体を割り当ててください。*/\r
protected NyARPerspectiveRasterReader _source_perspective_reader;\r
\r
- /**\r
- * TrackerSorceのホルダ。継承先のコンストラクタで実体を割り当ててください。\r
- */\r
+ /** TrackerSorceのホルダ。継承先のコンストラクタで実体を割り当ててください。*/\r
protected NyARTrackerSource _tracksource;\r
\r
- \r
+ /**\r
+ * コンストラクタです。\r
+ * 継承クラスでオーバライドして、メンバ変数を割り当てる処理を書いてください。\r
+ */\r
protected NyARRealitySource(){}\r
\r
\r
/**\r
- * このRealitySourceに対する読出し準備ができているかを返します。\r
+ * この関数には、thisインスタンスの読出し準備ができているか返す処理を実装します。\r
+ * 読出し可能な状態とは、{@link #makeTrackSource}を実行できる状態を指します。\r
* @return\r
- * trueならば、{@link #makeTrackSource}が実行可能。\r
+ * trueならば、読出し可能である。\r
*/\r
public abstract boolean isReady(); \r
/**\r
- * 現在のRGBラスタを{@link NyARTrackerSource}の基本ラスタに書込み、その参照値を返します。\r
- * この関数は、{@link NyARReality#progress}が呼び出します。\r
- * この関数は、{@link NyARTrackerSource}内の基本ラスタに書き込みを行うだけで、その内容を同期しません。\r
- * 継承クラスでは、{@link #_tracksource}の基本GS画像を、{@link #_rgb_source}の内容で更新する実装をしてください。\r
- * @throws NyARException \r
+ * この関数には、{@link #_rgb_source}の内容を{@link #_tracksource}のグレースケール画像へ反映する処理を書きます。\r
+ * {@link NyARTrackerSource}のベースラスタに書き込みを行うだけである事に注意してください。\r
+ * この関数は{@link NyARReality#progress}から呼び出される関数であり、ユーザが使用することはありません。\r
+ * @throws NyARException\r
+ * @return\r
+ * RGB画像の内容を反映した{@link NyARTrackerSource}オブジェクトへの参照値。\r
*/\r
public abstract NyARTrackerSource makeTrackSource() throws NyARException;\r
/**\r
- * 現在のRGBラスタを{@link NyARTrackerSource}の基本ラスタに書込み、{@link NyARTrackerSource}も含めて同期します。\r
- * é\80\9a常ã\80\81ã\81\93ã\81®é\96¢æ\95°ã\81¯ä½¿ç\94¨ã\81\99ã\82\8bã\81\93ã\81¨ã\81¯ã\81\82ã\82\8aã\81¾ã\81\9bã\82\93ã\80\82ã\83\87ã\83\90ã\83\83ã\82¯ã\81ªã\81©ã\81§ã\80\81{@link NyARReality#progress}以å¤\96ã\81®æ\96¹æ³\95ã\81§ã\82¤ã\83³ã\82¹ã\82¿ã\83³ã\82¹ã\81®å\90\8cæ\9c\9fã\82\92è¡\8cã\81\84ã\81\9fã\81\84ã\81¨ã\81\8dã\81«ä½¿ç\94¨ã\81\97ã\81¦ã\81\8fã\81 ã\81\95ã\81\84。\r
+ * この関数には、{@link #_rgb_source}の内容を{@link #_tracksource}のグレースケール画像へ反映し、{@link NyARTrackerSource#syncResource}を実行する処理を書きます。\r
+ * é\80\9a常ã\80\81ã\83¦ã\83¼ã\82¶ã\81\8cã\81\93ã\81®é\96¢æ\95°ã\82\92使ç\94¨ã\81\99ã\82\8bã\81\93ã\81¨ã\81¯ã\81\82ã\82\8aã\81¾ã\81\9bã\82\93ã\80\82ã\83\87ã\83\90ã\83\83ã\82¯ã\81ªã\81©ã\81§ã\80\81{@link NyARReality#progress}以å¤\96ã\81®æ\96¹æ³\95ã\81§ã\82ªã\83\96ã\82¸ã\82§ã\82¯ã\83\88ã\81®å\90\8cæ\9c\9fã\82\92è¡\8cã\81\84ã\81\9fã\81\84ã\81¨ã\81\8dã\81«ä½¿ç\94¨ã\81\97ã\81¾ã\81\99。\r
* 継承クラスでは、{@link #_tracksource}の基本GS画像を、{@link #_rgb_source}の内容で更新してから、この関数を呼び出して同期する処理を実装をしてください。\r
* @throws NyARException \r
*/\r
this._tracksource.syncResource();\r
}\r
/**\r
- * {@link #_rgb_source}を参照するPerspectiveRasterReaderを返します。\r
- * @return\r
+ * RGBソースラスタ{@link #_rgb_source}を参照する{@link PerspectiveRasterReader}を返します。\r
+ * @return [read only] {@link #_rgb_source}にリンクした{@link PerspectiveRasterReader}オブジェクト\r
*/\r
public NyARPerspectiveRasterReader refPerspectiveRasterReader()\r
{\r
}\r
\r
/**\r
- * 元画像への参照値を返します。\r
+ * RGBソースラスタへの参照値を返します。\r
* @return\r
+ * RGBソースラスタへの参照値。\r
*/\r
public final INyARRgbRaster refRgbSource()\r
{\r
return this._rgb_source;\r
}\r
/**\r
- * 最後に作成したTrackSourceへのポインタを返します。\r
+ * 最後に作成したTrackSourceへの参照ポインタを返します。\r
+ * 更新の完了した{@link NyARReality}オブジェクトから情報を得るために使います。\r
* この関数は、{@link NyARReality#progress}、または{@link #syncResource}の後に呼び出すことを想定しています。\r
* それ以外のタイミングでは、返却値の内容が同期していないことがあるので注意してください。\r
* @return\r
+ * [read only]現在のトラッキングオブジェクトの参照ポインタ\r
*/\r
public final NyARTrackerSource refLastTrackSource()\r
{\r
import jp.nyatla.nyartoolkit.core.raster.rgb.NyARRgbRaster;\r
import jp.nyatla.nyartoolkit.core.rasterfilter.rgb2gs.NyARRasterFilter_Rgb2Gs_RgbAve192;\r
import jp.nyatla.nyartoolkit.core.rasterreader.NyARPerspectiveRasterReader;\r
-import jp.nyatla.nyartoolkit.rpf.tracker.nyartk.NyARTrackerSource;\r
-import jp.nyatla.nyartoolkit.rpf.tracker.nyartk.NyARTrackerSource_Reference;\r
-\r
-\r
+import jp.nyatla.nyartoolkit.core.types.NyARBufferType;\r
+import jp.nyatla.nyartoolkit.rpf.tracker.nyartk.*;\r
+import jp.nyatla.nyartoolkit.rpf.reality.nyartk.*;\r
/**\r
- * RGBラスタをラップしたRealitySourceです。\r
- * @author nyatla\r
- *\r
+ * このクラスは、入力ソースに{@link NyARRgbRaster}クラスを使う{@link NyARRealitySource}です。\r
+ * 環境に依存しない、基本機能のみを実装しています。\r
+ * <p>使い方-\r
+ * <ul>\r
+ * <li>ラスタのバッファタイプとサイズを指定して、インスタンスを生成します。\r
+ * <li>{@link #refRgbSource()}関数でラスタオブジェクトを得て、そこへ画像を書き込みます。\r
+ * <li>{@link NyARReality#progress}関数に入力します。\r
+ * </ul>\r
+ * </p>\r
*/\r
public class NyARRealitySource_Reference extends NyARRealitySource\r
{\r
+ /** 二値化用のフィルタオジェクト。*/\r
protected NyARRasterFilter_Rgb2Gs_RgbAve192 _filter;\r
/**\r
- * \r
+ * コンストラクタです。\r
+ * thisが所有するラスタの情報と、トラッカの特性値を指定して、インスタンスを生成します。\r
* @param i_width\r
* ラスタのサイズを指定します。\r
* @param i_height\r
* ラスタのサイズを指定します。\r
* @param i_ref_raster_distortion\r
- * 歪み矯正の為のオブジェクトを指定します。歪み矯正が必要ない時は、NULLを指定します。\r
+ * 樽型歪み矯正オブジェクトを指定します。\r
+ * 樽型歪み矯正が必要ない時は、NULLを指定します。\r
* @param i_depth\r
* エッジ画像のサイズを1/(2^n)で指定します。(例:QVGA画像で1を指定すると、エッジ検出画像は160x120になります。)\r
- * 数値が大きいほど高速になり、検出精度は低下します。実用的なのは、1<=n<=3の範囲です。標準値は2です。\r
+ * 数値が大きいほど高速になり、検出精度は低下します。(接近したエッジを検出できなくなる。)\r
+ * 実用的なのは、1<=n<=3の範囲です。標準値は2です。\r
* @param i_number_of_sample\r
- * サンプリングするターゲット数を指定します。大体100以上をしておけばOKです。具体的な計算式は、{@link NyARTrackerSource_Reference#NyARTrackerSource_Reference}を参考にして下さい。\r
+ * 所有するトラッカがサンプリングする、トラックターゲット数を指定します。\r
+ * 大体100以上をしておけばOKです。\r
+ * 具体的な計算式は、{@link NyARTrackerSource_Reference#NyARTrackerSource_Reference}を参考にして下さい。\r
* @param i_raster_type\r
- * ラスタタイプ\r
+ * ソースラスタのバッファタイプ。使用できる値に制限があります。\r
+ * 標準値は、{@link NyARBufferType#BYTE1D_B8G8R8X8_32}です。\r
* @throws NyARException\r
*/\r
public NyARRealitySource_Reference(int i_width,int i_height,NyARCameraDistortionFactor i_ref_raster_distortion,int i_depth,int i_number_of_sample,int i_raster_type) throws NyARException\r
this._tracksource=new NyARTrackerSource_Reference(i_number_of_sample,i_ref_raster_distortion,i_width,i_height,i_depth,true);\r
return;\r
}\r
+ /**\r
+ * 所有するラスタが読出し可能であるかを返します。このクラスの場合には、常にtrueです。\r
+ * @see {@link NyARRealitySource#isReady()}\r
+ */\r
public final boolean isReady()\r
{\r
return this._rgb_source.hasBuffer();\r
}\r
+ /**\r
+ * RGBソースとトラッカのリソースとの内容の同期を取ります。\r
+ * @see {@link NyARRealitySource#syncResource()}\r
+ */\r
public final void syncResource() throws NyARException\r
{\r
this._filter.doFilter(this._rgb_source,this._tracksource.refBaseRaster());\r
super.syncResource();\r
}\r
+ /**\r
+ * RGBソースとトラッカのグレースケール画像との同期を取ります。\r
+ * @see {@link NyARRealitySource#makeTrackSource()}\r
+ */\r
public final NyARTrackerSource makeTrackSource() throws NyARException\r
{\r
this._filter.doFilter(this._rgb_source,this._tracksource.refBaseRaster()); \r
\r
/**\r
* このクラスは、4本の直線式から、凸包の頂点を計算する機能を提供します。\r
+ * <p>アルゴリズム -\r
+ * 4直線の交差点0から6の間で変動します。4以上の交差点があるときに、以下の手順で求めます。\r
+ * <ol>\r
+ * <li>4直線に、AからDまでの番号を振る。\r
+ * <li>AとBの交点を0として、AB→AC→AD→BC→BD→CDの順に、交点番号を振る。 \r
+ * <li>0-5,1-4,2-3の頂点を通る直線は存在しない事が判る。\r
+ * <li>{0,1,5,4},{0,2,5,3},{1,2,4,3}の順で頂点を辿った時、4個の外積が0か4になるものが凸包。\r
+ * </ol>\r
+ * 4,5頂点の場合も、頂点順序を辿る始点を変えることで、求められます。\r
+ * </p>\r
*/\r
public class LineBaseVertexDetector\r
{\r
private NyARDoublePoint2d[] __wk_v=NyARDoublePoint2d.createArray(6);\r
/**\r
* ４直線の交点から、凸包の頂点座標を計算します。\r
+ * 頂点の回転方向は、時計回りに正規化されます。\r
* @param i_line\r
* 直線式の配列です。要素数は4である必要があります。\r
* @param o_point\r
\r
import jp.nyatla.nyartoolkit.core.types.NyARVecLinear2d;\r
\r
+/**\r
+ * このクラスは、RFFパッケージが使う輪郭データのリストです。\r
+ * リスト要素に対する計算機能と、リストの操作機能を提供します。\r
+ *\r
+ */\r
public class VecLinearCoordinates\r
{ \r
/**\r
* データ型です。\r
- * 輪郭ベクトルを格納します。\r
+ * {@link NyARVecLinear2d}に輪郭強度値を追加したものです。\r
*/\r
public static class VecLinearCoordinatePoint extends NyARVecLinear2d\r
{\r
}\r
return r;\r
}\r
- } \r
+ }\r
+ /**\r
+ * [read only] リストの有効な長さです。\r
+ */\r
public int length;\r
+ /**\r
+ * リスト要素を格納する配列です。\r
+ * この長さは、有効なデータの長さで無いことに注意してください。有効な長さは、{@link #length}から得られます。\r
+ */\r
public VecLinearCoordinatePoint[] items;\r
+ /**\r
+ * コンストラクタです。\r
+ * @param i_length\r
+ * リストの最大数を指定します。\r
+ */\r
\r
public VecLinearCoordinates(int i_length)\r
{\r
this.items = VecLinearCoordinatePoint.createArray(i_length);\r
}\r
/**\r
- * ã\83\99ã\82¯ã\83\88ã\83«ã\82\921,2象é\99\90に制限します。\r
+ * ã\81\93ã\81®é\96¢æ\95°ã\81¯ã\80\81è¦\81ç´ ã\81®ã\83\99ã\82¯ã\83\88ã\83«ã\82\92ã\80\811,2象é\99\90æ\96¹å\90\91に制限します。\r
*/\r
public final void limitQuadrantTo12()\r
{\r
}\r
}\r
}\r
- \r
-\r
/**\r
- * 輪郭配列から、から、キーのベクトル(絶対値の大きいベクトル)を順序を壊さずに抽出します。\r
- * \r
- * @param i_vecpos\r
- * 抽出元の\r
- * @param i_len\r
+ * この関数は、輪郭配列からキーのベクトル(絶対値の大きいベクトル)を抽出して、そのインデクスを配列に返します。\r
+ * 抽出したベクトルの順序は、元の配列と同じです。\r
* @param o_index\r
- * インデクス番号を受け取る配列。受け取るインデックスの個数は、この配列の数と同じになります。\r
+ * インデクス番号を受け取る配列。受け取るインデックスの個数は、この配列の数と同じになります。\r
*/\r
public void getOrderdKeyCoordIndexes(int[] o_index)\r
{\r
}\r
return;\r
}\r
+ /**\r
+ * この関数は、輪郭配列からキーのベクトル(絶対値の大きいベクトル)を抽出して、そのインデクスを配列に返します。\r
+ * 抽出したベクトルの順序は、元の配列と異なります。そのかわり、{@link #getOrderdKeyCoordIndexes}より若干高速です。\r
+ * @param o_index\r
+ * インデクス番号を受け取る配列。受け取るインデックスの個数は、この配列の数と同じになります。\r
+ */\r
public void getKeyCoordIndexes(int[] o_index)\r
{\r
VecLinearCoordinatePoint[] vp = this.items;\r
}\r
return;\r
}\r
+ /**\r
+ * この関数は、輪郭配列からキーのベクトル(絶対値の大きいベクトル)を抽出して、そのオブジェクトの参照値を配列に返します。\r
+ * 抽出したベクトルの順序は、元の配列と異なります。\r
+ * @param o_index\r
+ * オブジェクトの参照値を受け取る配列。受け取るオブジェクトの個数は、この配列の数と同じになります。\r
+ */\r
public void getKeyCoord(VecLinearCoordinatePoint[] o_index)\r
{\r
VecLinearCoordinatePoint[] vp = this.items;\r
} \r
\r
/**\r
- * 最も大きいベクトル成分のインデクスを返します。\r
- * \r
+ * この関数は、最も大きいベクトル成分のインデクスを返します。\r
* @return\r
+ * ベクトルのインデクス。\r
*/\r
public final int getMaxCoordIndex()\r
{\r
}\r
\r
\r
+\r
/**\r
- * ノイズレベルを指定して、ノイズ（だと思われる）ベクトルを削除します。\r
- */\r
- /**\r
- * 大きさ(sq_dist)が0のベクトルを削除して、要素を前方に詰めます。\r
+ * この関数は、リストから大きさ(sq_dist)が0のベクトルを削除して、要素を前方に詰めます。\r
*/\r
public void removeZeroDistItem()\r
{\r
\r
import jp.nyatla.nyartoolkit.core.types.NyARDoublePoint2d;\r
import jp.nyatla.nyartoolkit.core.types.NyARLinear;\r
-import jp.nyatla.nyartoolkit.core.types.NyARVecLinear2d;\r
import jp.nyatla.nyartoolkit.core.utils.NyARMath;\r
\r
+/**\r
+ * このクラスは、{@link VecLinearCoordinates}を編集する機能を提供します。\r
+ * 将来、{@link VecLinearCoordinates}へ統合するかもしれません。\r
+ */\r
public class VecLinearCoordinatesOperator\r
{\r
/**\r
private NyARDoublePoint2d _p = new NyARDoublePoint2d();\r
\r
/**\r
- * 配列の前方に、似たベクトルを集めます。似たベクトルの判定基準は、2線の定義点における直線の法線上での距離の二乗和です。\r
- * ベクトルの統合と位置情報の計算には、加重平均を用います。\r
+ * この関数は、リストにある似たベクトルを集めます。\r
+ * 似たベクトルの判定基準は、2線の定義点における直線の法線上での距離の二乗和です。\r
+ * スケール値は単純加算され、ベクトルと位置は加重平均して加算します。\r
+ * 集めたベクトルは、配列の前方に集められ、i_vectorの長さは処理後に減少します。\r
* @param i_vector\r
* 編集するオブジェクトを指定します。\r
*/\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
/**\r
- *\r
+ * このクラスは、{@link NyARLabeling_ARToolKit}の出力するラべリング画像を格納するラスタです。\r
+ * データに、インデクス化したラべリング画像と、ラベルの配列、画像のインデクスの配列を持ちます。\r
+ * <p>ラベル画像-\r
+ * ラべリング画像は、ラベルのインデクス値を格納します。インデクス値は、{@link #getIndexArray}で\r
+ * 得られるインデクス配列を使って、ラベル番号に変換できます。\r
+ * 例えば、インデクス番号nの画素は、ラベル番号L[n]になります。\r
+ * </p>\r
*/\r
public class NyARLabelingImage extends NyARRaster_BasicClass\r
{\r
private final static int MAX_LABELS = 1024*32;\r
-\r
- protected int[] _ref_buf;\r
+ /** 画像バッファ*/\r
+ protected int[] _buf;\r
+ /** ラベル配列のスタック*/\r
protected NyARLabelingLabelStack _label_list;\r
+ /** インデクステーブル*/\r
protected int[] _index_table;\r
+ /** インデクステーブルが有効であるかを示す値*/\r
protected boolean _is_index_table_enable;\r
+ /**\r
+ * コンストラクタです。\r
+ * ラべリング画像のサイズを指定して、インスタンスを生成します。\r
+ * @param i_width\r
+ * ラスタの幅を指定します。\r
+ * @param i_height\r
+ * ラスタの高さを指定します。\r
+ * @throws NyARException\r
+ */\r
public NyARLabelingImage(int i_width, int i_height) throws NyARException\r
{\r
super(i_width,i_height,NyARBufferType.INT1D);\r
- this._ref_buf =new int[i_height*i_width];\r
+ this._buf =new int[i_height*i_width];\r
this._label_list = new NyARLabelingLabelStack(MAX_LABELS);\r
this._index_table=new int[MAX_LABELS];\r
this._is_index_table_enable=false;\r
drawFrameEdge();\r
return;\r
}\r
+ /**\r
+ * 画像バッファを返します。バッファの形式は、{@link NyARBufferType.INT1D}(int[])です。\r
+ */\r
public Object getBuffer()\r
{\r
- return this._ref_buf;\r
+ return this._buf;\r
}\r
public boolean hasBuffer()\r
{\r
- return this._ref_buf!=null;\r
+ return this._buf!=null;\r
}\r
+ /**\r
+ * このクラスでは、関数は機能しません。\r
+ */\r
public void wrapBuffer(Object i_ref_buf) throws NyARException\r
{\r
NyARException.notImplement();\r
} \r
/**\r
- * エッジを書きます。\r
+ * この関数は、矩形エッジ（画像を囲む枠）を書きます。\r
+ * ARToolKit互換のコーナー検出の前処理に必要なため、実装しています。\r
*/\r
public void drawFrameEdge()\r
{\r
int w=this._size.w;\r
int h=this._size.h;\r
// NyLabelingImageのイメージ初期化(枠書き)\r
- int[] img = (int[]) this._ref_buf;\r
+ int[] img = (int[]) this._buf;\r
int bottom_ptr = (h - 1) * w;\r
for (int i = 0; i < w; i++) {\r
img[i] = 0;\r
}\r
\r
/**\r
- * ラベリング結果がインデックステーブルを持つ場合、その配列を返します。\r
- * 持たない場合、nullを返します。\r
- * \r
+ * この関数は、ラベルのインデクステーブルを返します。\r
+ * <p>格納値 - \r
* 値がnullの時はラベル番号そのものがラスタに格納されていますが、\r
* null以外の時はラスタに格納されているのはインデクス番号です。\r
- * \r
* インデクス番号とラベル番号の関係は、以下の式で表されます。\r
- * ラベル番号:=value[インデクス番号]\r
- * \r
+ * ラベル番号n,インデクス番号i: n=indextable[i]\r
+ * </p>\r
+ * @return\r
+ * ラベリング結果がインデックステーブルを持つ場合、その配列を返します。\r
+ * 持たない場合、nullを返します。\r
*/\r
public int[] getIndexArray()\r
{\r
return this._is_index_table_enable?this._index_table:null;\r
}\r
- \r
+ /**\r
+ * この関数は、ラベル情報を格納したスタックオブジェクトを返します。\r
+ * @return\r
+ * 現在の画像に対するラベルのスタック\r
+ */\r
public NyARLabelingLabelStack getLabelStack()\r
{\r
return this._label_list;\r
}\r
+ /**\r
+ * この関数は、インスタンスの状態をリセットします。\r
+ * リセット後にインスタンスのラベルスタックはクリアされますが、画像情報は未定義値になります。\r
+ * @param i_label_index_enable\r
+ * モード値。現在指定できるのは、trueのみです。\r
+ */\r
public void reset(boolean i_label_index_enable)\r
{\r
assert(i_label_index_enable==true);//非ラベルモードは未実装\r
return;\r
}\r
/**\r
- * i_labelのラベルの、クリップ領域が上辺に接しているx座標を返します。\r
- * @param i_index\r
+ * この関数は、i_labelのラベルのクリップ領域が上辺に接している点の、x座標を返します。\r
+ * NyARToolkitでは、ラベルの輪郭をトレースするときに、その始点を探索するために使います。\r
+ * @param i_label\r
+ * 探索するラベル\r
* @return\r
+ * ラベルの上辺クリップとの接点となる、x位置\r
*/\r
public int getTopClipTangentX(NyARLabelingLabel i_label) throws NyARException\r
{\r
int pix;\r
int i_label_id=i_label.id;\r
int[] index_table=this._index_table;\r
- int[] limage=this._ref_buf;\r
+ int[] limage=this._buf;\r
int limage_ptr=i_label.clip_t*this._size.w;\r
final int clip1 = i_label.clip_r;\r
// p1=ShortPointer.wrap(limage,j*xsize+clip.get());//p1 =&(limage[j*xsize+clip[0]]);\r
package jp.nyatla.nyartoolkit.core.labeling.artoolkit;\r
\r
import jp.nyatla.nyartoolkit.core.labeling.*;\r
+\r
/**\r
- * [[Strage class]]\r
- *\r
+ * このクラスは、{@link NyARLabelingImage}クラスの使うデータ型です。\r
+ * ラベル１個分のデータを格納します。\r
+ * {@link NyARLabelInfo}にラベル番号が追加されています。\r
*/\r
public class NyARLabelingLabel extends NyARLabelInfo\r
{\r
- public int id; // フラグメントラベルのインデクス\r
+ /** ラベルのID番号。この番号については、{@link NyARLabelingImage}を参照してください。*/\r
+ public int id;\r
\r
}\r
import jp.nyatla.nyartoolkit.core.types.stack.NyARObjectStack;\r
\r
/**\r
- * NyLabelの予約型動的配列\r
- * \r
+ * このクラスは、NyARLabelingLabelの動的配列です。\r
+ * {@link NyARLabeling_ARToolKit}が使います。\r
+ * {@link NyARObjectStack}からの追加機能として、配列要素のソート機能があります。\r
*/\r
public class NyARLabelingLabelStack extends NyARObjectStack<NyARLabelingLabel>\r
{\r
+ /**\r
+ * コンストラクタです。\r
+ * @param i_max_array_size\r
+ * 配列の最大サイズ。\r
+ * @throws NyARException\r
+ */\r
public NyARLabelingLabelStack(int i_max_array_size) throws NyARException\r
{\r
super();\r
super.initInstance(i_max_array_size,NyARLabelingLabel.class);\r
}\r
+ /** {@link NyARLabelingLabel}要素を返します。*/\r
protected NyARLabelingLabel createElement()\r
{\r
return new NyARLabelingLabel();\r
}\r
/**\r
- * 配列をエリアでソートする。\r
- * @param i_array\r
- * @param i_length\r
+ * この関数は、配列を{@link NyARLabelingLabel#area}でソートします。\r
*/\r
final public void sortByArea()\r
{\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
/**\r
- * ARToolKit互換のラベリングクラスです。 ARToolKitと同一な評価結果を返します。\r
- * \r
+ * このクラスは、ARToolKitのアルゴリズムと互換性のあるラベリングクラスです。\r
+ * 入力画像に対して、インデクス化されたラべリング画像を出力します。\r
*/\r
final public class NyARLabeling_ARToolKit\r
{\r
private static final int WORK_SIZE = 1024 * 32;// #define WORK_SIZE 1024*32\r
\r
- private final NyARWorkHolder work_holder = new NyARWorkHolder(WORK_SIZE);\r
+ private final NyARWorkHolder _work_holder = new NyARWorkHolder(WORK_SIZE);\r
\r
\r
/**\r
- * static ARInt16 *labeling2( ARUint8 *image, int thresh,int *label_num, int **area, double **pos, int **clip,int **label_ref, int LorR ) 関数の代替品\r
- * ラスタimageをラベリングして、結果を保存します。 Optimize:STEP[1514->1493]\r
- * \r
+ * この関数は、ラスタをラべリングします。\r
+ * 結果は、o_destinationに出力します。\r
+ * <p>メモ -\r
+ * この関数の元になるARToolKitの関数は、static ARInt16 *labeling2( ARUint8 *image, int thresh,int *label_num, int **area, double **pos, int **clip,int **label_ref, int LorR )です。\r
+ * </p>\r
* @param i_raster\r
+ * 入力元の二値ラスタオブジェクトです。バッファフォーマットは、{@link NyARBufferType.INT1D_BIN_8}である必要があります。\r
+ * @param o_destination\r
+ * ラべリング画像の出力先オブジェクトです。i_rasterと同じサイズである必要があります。\r
* @throws NyARException\r
*/\r
public int labeling(NyARBinRaster i_raster,NyARLabelingImage o_destination) throws NyARException\r
int wk_max = 0;\r
\r
int pixel_index;\r
- int[][] work2 = this.work_holder.work2;\r
+ int[][] work2 = this._work_holder.work2;\r
\r
// [1,1](ptr0)と、[0,1](ptr1)のインデクス値を計算する。\r
for (j = 1; j < lysize - 1; j++) {// for (int j = 1; j < lysize - 1;j++, pnt += poff*2, pnt2 += 2) {\r
}\r
} else {\r
// 現在地までの領域を予約\r
- this.work_holder.reserv(wk_max);\r
+ this._work_holder.reserv(wk_max);\r
wk_max++;\r
label_idxtbl[wk_max - 1] = wk_max;\r
label_pixel = wk_max;// work[wk_max-1] = *pnt2 = wk_max;\r
}\r
\r
/**\r
- * NyARLabeling_O2のworkとwork2を可変長にするためのクラス\r
+ * このクラスは、{@link NyARLabeling_ARToolKit}のworkとwork2メンバを可変長にするためのクラスです。\r
* \r
* \r
*/\r
import jp.nyatla.nyartoolkit.core.types.*;\r
import jp.nyatla.nyartoolkit.core.types.stack.NyARObjectStack;\r
\r
-class RleInfoStack extends NyARObjectStack<NyARRleLabelFragmentInfo>\r
-{ \r
- public RleInfoStack(int i_length) throws NyARException\r
- {\r
- super();\r
- super.initInstance(i_length, NyARRleLabelFragmentInfo.class);\r
- return;\r
- }\r
-\r
- protected NyARRleLabelFragmentInfo createElement()\r
- {\r
- return new NyARRleLabelFragmentInfo();\r
- }\r
-}\r
-/**\r
- * [strage class]\r
- */\r
-\r
\r
-class RleElement\r
-{\r
- int l;\r
- int r;\r
- int fid;\r
- public static RleElement[] createArray(int i_length)\r
- {\r
- RleElement[] ret = new RleElement[i_length];\r
- for (int i = 0; i < i_length; i++) {\r
- ret[i] = new RleElement();\r
- }\r
- return ret;\r
- }\r
-}\r
\r
\r
/**\r
- * ラべリングクラスです。入力画像をラべリングして、そのエントリポイントと情報を、ハンドラ関数を介して返します。\r
- * \r
- *\r
+ * このクラスは、RLE圧縮を利用した輪郭線エントリポイント検出用のラべリングクラスです。\r
+ * ラべリング画像を生成せずに、ラベル輪郭へのエントリーポイントの一覧を作ることに注意してください。\r
+ * <p>コールバック関数\r
+ * このクラスはいくつかの自己コールバック関数を持つ抽象クラスです。継承クラスでコールバック関数を実装して使います。\r
+ * <ul>\r
+ * <li>{@link #onLabelFound}- {@link #labeling}関数が検出したラベルを通知するコールバック関数です。\r
+ * ここに、発見したラベルを処理するコードを書きます。\r
+ * </ul>\r
+ * </p>\r
+ * <p>ラベル輪郭のエントリーポイント -\r
+ * このエントリポイントは、ラベルを構成する塊の輪郭を指す１点です。ここから８方位輪郭検出を実行すると、\r
+ * ラベルの輪郭を一周することができます。\r
+ * </p>\r
+ * <p>入力できる画素形式 -\r
+ * <p>{@link NyARBinRaster}を入力する場合\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#INT1D_BIN_8}\r
+ * </ul>\r
+ * </p>\r
+ * <p>{@link NyARGrayscaleRaster}を入力する場合\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#INT1D_GRAY_8}\r
+ * </ul>\r
+ * </p>\r
+ * </p>\r
*/\r
public abstract class NyARLabeling_Rle\r
{\r
private RleElement[] _rle2;\r
private int _max_area;\r
private int _min_area;\r
+ /** 入力ラスタのサイズ*/\r
+ protected NyARIntSize _raster_size=new NyARIntSize();\r
/**\r
- * 処理対象のラスタサイズ\r
+ * コンストラクタです。{@link #labeling}に入力するラスタのサイズを指定して、インスタンスを生成します。\r
+ * @param i_width\r
+ * 入力画像の幅\r
+ * @param i_height\r
+ * 入力画像の高さ\r
+ * @throws NyARException\r
*/\r
- protected NyARIntSize _raster_size=new NyARIntSize();\r
-\r
public NyARLabeling_Rle(int i_width,int i_height) throws NyARException\r
{\r
this._raster_size.setValue(i_width,i_height);\r
return;\r
}\r
/**\r
- * 対象サイズ\r
+ * 検出するラベルのエリア（画素数）範囲を設定します。\r
+ * この範囲にあるラベルのみが、結果に返されます。\r
+ * 初期値は、{@link #AR_AREA_MAX},{@link #AR_AREA_MIN}です。\r
* @param i_max\r
+ * エリアの最大値を指定します。\r
* @param i_min\r
+ * エリアの最小値を指定します。\r
*/\r
public void setAreaRange(int i_max,int i_min)\r
{\r
// 行確定\r
return current;\r
}\r
-\r
+ /**\r
+ * フラグメントをRLEスタックへ追加する。\r
+ * @param i_rel_img\r
+ * @param i_nof\r
+ * @param i_row_index\r
+ * @param o_stack\r
+ * @return\r
+ * @throws NyARException\r
+ */\r
private final boolean addFragment(RleElement i_rel_img, int i_nof, int i_row_index,RleInfoStack o_stack) throws NyARException\r
{\r
int l=i_rel_img.l;\r
return true;\r
}\r
/**\r
- * BINラスタをラベリングします。\r
+ * この関数は、2値イメージの{@link NyARBinRaster}ラスタをラベリングします。\r
+ * 検出したラベルは、自己コールバック関数{@link #onLabelFound}で通知します。\r
* @param i_bin_raster\r
- * @param o_stack\r
- * 結果を蓄積するスタックオブジェクトを指定します。\r
- * 関数は、このオブジェクトに結果を追記します。\r
- * @return\r
+ * 入力画像。対応する形式は、クラスの説明を参照してください。\r
* @throws NyARException\r
*/\r
public void labeling(NyARBinRaster i_bin_raster) throws NyARException\r
NyARIntSize size=i_bin_raster.getSize();\r
this.imple_labeling(i_bin_raster,0,0,0,size.w,size.h);\r
}\r
+ /**\r
+ * この関数は、2値イメージの{@link NyARBinRaster}ラスタの指定範囲をラベリングします。\r
+ * 検出したラベルは、自己コールバック関数{@link #onLabelFound}で通知します。\r
+ * @param i_bin_raster\r
+ * 入力画像。対応する形式は、クラスの説明を参照してください。\r
+ * @param i_area\r
+ * ラべリングする画像内の範囲\r
+ * @throws NyARException\r
+ */\r
public void labeling(NyARBinRaster i_bin_raster,NyARIntRect i_area) throws NyARException\r
{\r
assert(i_bin_raster.isEqualBufferType(NyARBufferType.INT1D_BIN_8));\r
this.imple_labeling(i_bin_raster,0,i_area.x,i_area.y,i_area.w,i_area.h);\r
}\r
/**\r
- * GSラスタの２値ラべリングを実行します。\r
+ * この関数は、2値イメージの{@link NyARBinRaster}ラスタをラベリングします。\r
+ * 検出したラベルは、自己コールバック関数{@link #onLabelFound}で通知します。\r
* @param i_gs_raster\r
+ * 入力画像。対応する形式は、クラスの説明を参照してください。\r
* @param i_th\r
- * 二値化の敷居値を指定します。\r
- * @param o_stack\r
- * 結果を蓄積するスタックオブジェクトを指定します。\r
- * 関数は、このオブジェクトに結果を追記します。\r
- * @return\r
+ * 暗点を判定するための敷居値0から255の数値である事。\r
* @throws NyARException\r
*/\r
public void labeling(NyARGrayscaleRaster i_gs_raster,int i_th) throws NyARException\r
this.imple_labeling(i_gs_raster,i_th,0,0,size.w,size.h);\r
}\r
/**\r
- * 範囲付きでGSラスタの２値ラべリングを実行します。\r
+ * この関数は、2値イメージの{@link NyARBinRaster}ラスタの指定範囲をラベリングします。\r
+ * 検出したラベルは、自己コールバック関数{@link #onLabelFound}で通知します。\r
* @param i_gs_raster\r
+ * 入力画像。対応する形式は、クラスの説明を参照してください。\r
* @param i_area\r
+ * ラべリングする画像内の範囲\r
* @param i_th\r
- * @param o_stack\r
- * 結果を蓄積するスタックオブジェクトを指定します。\r
- * 関数は、このオブジェクトに結果を追記します。\r
- * @return\r
+ * 暗点を判定するための敷居値0から255の数値である事。\r
* @throws NyARException\r
*/\r
public void labeling(NyARGrayscaleRaster i_gs_raster,NyARIntRect i_area,int i_th) throws NyARException\r
}\r
}\r
/**\r
- * ハンドラ関数です。継承先クラスでオーバライドしてください。\r
- * i_labelのインスタンスは、次のラべリング実行まで保証されていますが、将来にわたり保証されないかもしれません。(恐らく保証されますが)\r
- * コールバック関数から参照を使用する場合は、互換性を確認するために、念のため、assertで_af_label_array_safe_referenceフラグをチェックしてください。\r
- * @param i_label\r
+ * この仮想関数は自己コールバック関数です。\r
+ * {@link #labeling}関数が、検出したラベルを通知するために使います。\r
+ * @param i_ref_label\r
+ * 検出したラベルを格納したオブジェクト。値の有効期間は、次の{@link #labeling}が実行されるまでです。\r
+ * (注)この仕様は変わるかもしれません。\r
+ * @throws NyARException\r
*/\r
+\r
protected abstract void onLabelFound(NyARRleLabelFragmentInfo i_ref_label) throws NyARException;\r
\r
/**\r
* クラスの仕様確認フラグです。ラベル配列の参照アクセスが可能かを返します。\r
- * \r
+ * このクラスでは、true固定です。\r
*/\r
public final static boolean _sf_label_array_safe_reference=true;\r
}\r
\r
+/**\r
+ * このクラスは、{@link NyARLabeling_Rle}が内部的に使うRLEスタックです。\r
+ * ユーザが使うことはありません。\r
+ */\r
+class RleInfoStack extends NyARObjectStack<NyARRleLabelFragmentInfo>\r
+{ \r
+ public RleInfoStack(int i_length) throws NyARException\r
+ {\r
+ super();\r
+ super.initInstance(i_length, NyARRleLabelFragmentInfo.class);\r
+ return;\r
+ }\r
\r
+ protected NyARRleLabelFragmentInfo createElement()\r
+ {\r
+ return new NyARRleLabelFragmentInfo();\r
+ }\r
+}\r
+/**\r
+ * このクラスは、{@link #RleInfoStack}の要素です。\r
+ * RLEフラグメントのパラメータを保持します。\r
+ * ユーザが使うことはありません。\r
+ */\r
+class RleElement\r
+{\r
+ int l;\r
+ int r;\r
+ int fid;\r
+ public static RleElement[] createArray(int i_length)\r
+ {\r
+ RleElement[] ret = new RleElement[i_length];\r
+ for (int i = 0; i < i_length; i++) {\r
+ ret[i] = new RleElement();\r
+ }\r
+ return ret;\r
+ }\r
+}\r
\r
\r
import jp.nyatla.nyartoolkit.core.labeling.NyARLabelInfo;\r
\r
+/**\r
+ * このクラスは、{@link NyARLabeling_Rle}の出力するフラグメント値を格納します。\r
+ * {@link NyARLabelInfo}に追加した要素は、輪郭のエントリポイント{@link #entry_x}です。\r
+ * {@link #entry_x}と{@link #clip_t}から、輪郭追跡の為のエントリポイントが求まります。\r
+ */\r
public class NyARRleLabelFragmentInfo extends NyARLabelInfo\r
{\r
public int entry_x; // フラグメントラベルの位置\r
\r
\r
import jp.nyatla.nyartoolkit.NyARException;\r
+import jp.nyatla.nyartoolkit.core.labeling.artoolkit.NyARLabelingLabel;\r
+import jp.nyatla.nyartoolkit.core.labeling.artoolkit.NyARLabeling_ARToolKit;\r
+import jp.nyatla.nyartoolkit.core.types.stack.NyARObjectStack;\r
import jp.nyatla.nyartoolkit.core.types.stack.NyARPointerStack;\r
\r
-\r
+/**\r
+ * このクラスは、{@link NyARRleLabelFragmentInfo}の参照値の動的配列です。\r
+ * {@link NyARLabeling_Rle}が使います。\r
+ * {@link NyARPointerStack}からの追加機能として、配列要素のソート機能があります。\r
+ */\r
public class NyARRleLabelFragmentInfoPtrStack extends NyARPointerStack<NyARRleLabelFragmentInfo>\r
{\r
public NyARRleLabelFragmentInfoPtrStack(int i_length) throws NyARException\r
}\r
\r
/**\r
- * ã\82¨ã\83ªã\82¢ã\81®å¤§ã\81\8dã\81\84é \86ã\81«ã\83©ã\83\99ã\83«ã\82\92ソートします。\r
+ * ã\81\93ã\81®é\96¢æ\95°ã\81¯ã\80\81é\85\8då\88\97ã\82\92{@link NyARLabelingLabel#area}ã\81§ソートします。\r
*/\r
final public void sortByArea()\r
{\r
import jp.nyatla.nyartoolkit.core.NyARCode;\r
\r
/**\r
- * ARCodeとINyARColorPattの間で一致計算をするインタフェイスです。\r
+ * このインタフェイスは、パターンマッチ処理の共通関数を定義します。\r
+ * パターンマッチクラスは、基準{@link NyARCode}パターンと、入力した画像の比較機能を提供します。\r
+ * 比較関数の多くが実体クラスに移動したため、現在このインタフェイスは意味を失っています。\r
*/\r
public interface INyARMatchPatt\r
{\r
+ /**\r
+ * この関数は、インスタンスに基準となるARマーカオブジェクトをセットします。\r
+ * @param i_code\r
+ * セットするARマーカ\r
+ */\r
public void setARCode(NyARCode i_code);\r
}\r
\r
\r
import jp.nyatla.nyartoolkit.core.raster.*;\r
+import jp.nyatla.nyartoolkit.core.types.*;\r
\r
\r
/**\r
- * INyARMatchPattのColor差分ラスタを格納するクラスです。\r
- *\r
+ * このクラスは、グレースケールの差分画像を格納します。\r
+ * 差分画像は、p[i]=((255-画素[i])-画像全体の平均値)のピクセルで構成されている、平均値との差分値です。\r
+ * {@link NyARMatchPatt_BlackWhite}の入力値と使います。\r
+ * <p>使い方 - \r
+ * {@link #setRaster}関数で、差分画像を作成し、プロパティ取得関数でその情報を得ます。\r
+ * </p>\r
*/\r
public class NyARMatchPattDeviationBlackWhiteData\r
{\r
private double _pow;\r
//\r
private int _number_of_pixels;\r
+ /**\r
+ * この関数は、画素データを格納した配列を返します。\r
+ * {@link NyARMatchPatt_BlackWhite#evaluate}関数から使います。\r
+ */\r
public int[] refData()\r
{\r
return this._data;\r
}\r
+ /**\r
+ * この関数は、差分画像の強度値を返します。\r
+ * 強度値は、差分画像の画素を二乗した値の合計です。\r
+ * @return\r
+ * 0<nの強度値。\r
+ */\r
public double getPow()\r
{\r
return this._pow;\r
}\r
- \r
+ /**\r
+ * コンストラクタです。\r
+ * 差分画像のサイズを指定して、インスタンスを生成します。\r
+ * @param i_width\r
+ * 差分画像のサイズ\r
+ * @param i_height\r
+ * 差分画像のサイズ\r
+ */\r
public NyARMatchPattDeviationBlackWhiteData(int i_width,int i_height)\r
{\r
this._number_of_pixels=i_height*i_width;\r
return;\r
}\r
/**\r
- * XRGB[width*height]の配列から、パターンデータを構築。\r
+ * この関数は、ラスタから差分画像を生成して、格納します。\r
+ * 制限事項として、{@link NyARBufferType#INT1D_X8R8G8B8_32}形式のラスタのみ、入力できます。\r
* @param i_buffer\r
+ * 差分画像の元画像。サイズは、このインスタンスと同じである必要があります。\r
*/\r
public void setRaster(INyARRaster i_raster)\r
{\r
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
\r
/**\r
- * INyARMatchPattのRGBColor差分データを格納するクラスです。\r
- *\r
+ * このクラスは、RGBカラーの差分画像を格納します。\r
+ * 差分画像は、p[i]=((255-画素[i])-画像全体の平均値)のピクセルで構成されている、平均値との差分値です。\r
+ * {@link NyARMatchPatt_BlackWhite}の入力値と使います。\r
+ * <p>使い方 - \r
+ * {@link #setRaster}関数で、差分画像を作成し、プロパティ取得関数でその情報を得ます。\r
+ * </p>\r
*/\r
public class NyARMatchPattDeviationColorData\r
{\r
private NyARIntSize _size;\r
//\r
private int _optimize_for_mod;\r
+ /**\r
+ * この関数は、画素データを格納した配列を返します。\r
+ * {@link NyARMatchPatt_Color_WITHOUT_PCA#evaluate}関数等から使います。\r
+ * R,G,Bの順番で、直列にデータを格納します。\r
+ */ \r
public int[] refData()\r
{\r
return this._data;\r
}\r
+ /**\r
+ * この関数は、差分画像の強度値を返します。\r
+ * 強度値は、差分画像の画素を二乗した値の合計です。\r
+ * @return\r
+ * 0<nの強度値。\r
+ */ \r
public double getPow()\r
{\r
return this._pow;\r
}\r
- \r
+ /**\r
+ * コンストラクタです。\r
+ * 差分画像のサイズを指定して、インスタンスを生成します。\r
+ * @param i_width\r
+ * 差分画像のサイズ\r
+ * @param i_height\r
+ * 差分画像のサイズ\r
+ */ \r
public NyARMatchPattDeviationColorData(int i_width,int i_height)\r
{\r
this._size=new NyARIntSize(i_width,i_height);\r
\r
\r
/**\r
- * NyARRasterからパターンデータをセットします。\r
- * この関数は、データを元に所有するデータ領域を更新します。\r
+ * この関数は、ラスタから差分画像を生成して、格納します。\r
* @param i_buffer\r
- * @throws NyARException \r
+ * 差分画像の元画像。サイズは、このインスタンスと同じである必要があります。\r
+ * {@link NyARBufferType#INT1D_X8R8G8B8_32}形式のバッファを持つラスタの場合、他の形式よりも\r
+ * 何倍か高速に動作します。\r
*/\r
public void setRaster(INyARRgbRaster i_raster) throws NyARException\r
{\r
return;\r
}\r
/**\r
- * 回転方向を指定してラスタをセットします。\r
+ * この関数は、元画像を回転してから、差分画像を生成して、格納します。\r
+ * 制限として、この関数はあまり高速ではありません。連続使用するときは、最適化を検討してください。\r
* @param i_reader\r
+ * 差分画像の元画像。サイズは、このインスタンスと同じである必要があります。\r
* @param i_direction\r
* 右上の位置です。0=1象限、1=2象限、、2=3象限、、3=4象限の位置に対応します。\r
* @throws NyARException\r
package jp.nyatla.nyartoolkit.core.match;\r
\r
\r
-\r
/**\r
- * [[Strage class]]\r
- *\r
+ * このクラスは、{@link NyARMatchPatt_BlackWhite}や{@link NyARMatchPatt_Color_WITHOUT_PCA}のevaluate\r
+ * 関数の戻り値を格納します。\r
*/\r
public class NyARMatchPattResult\r
{\r
+ /** {@link #direction}の初期値。方位不明である事を表します。*/\r
public static final int DIRECTION_UNKNOWN=-1;\r
+ /** パターンの一致率。0から1.0までの数値です。高い方が、一致率が高いことを示します。*/\r
public double confidence;\r
+ /** ARToolKit準拠の方位定数です。\r
+ * 画像の右上位置が、0=1象限、1=2象限、、2=3象限、、3=4象限の位置にあることを示します。\r
+ */\r
public int direction;\r
}
\ No newline at end of file
import jp.nyatla.nyartoolkit.core.*;\r
\r
/**\r
- * AR_TEMPLATE_MATCHING_BWと同等のルールで マーカを評価します。\r
- * \r
+ * このクラスは、グレースケールで２パターンの一致度を計算します。\r
+ * 評価アルゴリズムは、ARToolKitの、AR_TEMPLATE_MATCHING_BWと同様です。\r
+ * 比較対象のデータには、{@link NyARMatchPattDeviationBlackWhiteData}クラスの物を使います。\r
*/\r
public class NyARMatchPatt_BlackWhite implements INyARMatchPatt\r
{\r
- protected NyARCode _code_patt; \r
+ /** 基準となるARマーカパターンを格納するオブジェクトへの参照値です。*/\r
+ protected NyARCode _ref_code_patt;\r
+ /** 基準パターンの*/\r
protected int _pixels;\r
- \r
+ /**\r
+ * コンストラクタ。\r
+ * 基準パターンの解像度を指定して、インスタンスを生成します。\r
+ * このコンストラクタで生成したインスタンスの基準パターンは、NULLになっています。\r
+ * 後で基準パターンを{@link setARCode}関数で設定してください。\r
+ * @param i_width\r
+ * 基準パターンのサイズ\r
+ * @param i_height\r
+ * 基準パターンのサイズ\r
+ */\r
public NyARMatchPatt_BlackWhite(int i_width, int i_height)\r
{\r
//最適化定数の計算\r
this._pixels=i_height*i_width;\r
return;\r
}\r
+ /**\r
+ * コンストラクタ。\r
+ * 基準パターンを元に、評価インスタンスを生成します。\r
+ * @param i_code_ref\r
+ * セットする基準パターン\r
+ */\r
public NyARMatchPatt_BlackWhite(NyARCode i_code_ref)\r
{\r
//最適化定数の計算\r
this._pixels=i_code_ref.getWidth()*i_code_ref.getHeight();\r
- this._code_patt=i_code_ref;\r
+ //基準パターンをセット\r
+ this._ref_code_patt=i_code_ref;\r
return;\r
} \r
/**\r
- * 比較対象のARCodeをセットします。\r
+ * 基準パターンをセットします。セットできる基準パターンは、コンストラクタに設定したサイズと同じものである必要があります。\r
+ * @param i_code_ref\r
+ * セットする基準パターンを格納したオブジェクト\r
* @throws NyARException\r
*/\r
public void setARCode(NyARCode i_code_ref)\r
{\r
- this._code_patt=i_code_ref;\r
+ this._ref_code_patt=i_code_ref;\r
return;\r
}\r
/**\r
- * 現在セットされているコードとパターンを比較して、結果値o_resultを更新します。\r
- * 比較部分はFor文を16倍展開してあります。\r
+ * この関数は、現在の基準パターンと検査パターンを比較して、類似度を計算します。\r
+ * @param i_patt\r
+ * 検査パターンを格納したオブジェクトです。このサイズは、基準パターンと一致している必要があります。\r
+ * @param o_result\r
+ * 結果を受け取るオブジェクトです。\r
+ * @return\r
+ * 検査に成功するとtrueを返します。\r
+ * @throws NyARException\r
*/\r
public boolean evaluate(NyARMatchPattDeviationBlackWhiteData i_patt,NyARMatchPattResult o_result) throws NyARException\r
{\r
- assert this._code_patt!=null;\r
+ assert this._ref_code_patt!=null;\r
\r
final int[] linput = i_patt.refData();\r
int sum;\r
for (int j = 0; j < 4; j++) {\r
//合計値初期化\r
sum=0;\r
- final NyARMatchPattDeviationBlackWhiteData code_patt=this._code_patt.getBlackWhiteData(j);\r
+ final NyARMatchPattDeviationBlackWhiteData code_patt=this._ref_code_patt.getBlackWhiteData(j);\r
final int[] pat_j = code_patt.refData();\r
//<全画素について、比較(FORの1/16展開)/>\r
int i;\r
import jp.nyatla.nyartoolkit.core.*;\r
\r
/**\r
- * AR_TEMPLATE_MATCHING_COLORかつAR_MATCHING_WITHOUT_PCAと同等のルールで マーカーを評価します。\r
- * \r
+ * このクラスは、カラーで２パターンの一致度を計算します。\r
+ * 評価アルゴリズムは、ARToolKitの、AR_TEMPLATE_MATCHING_COLORかつAR_MATCHING_WITHOUT_PCAと同様です。\r
+ * 比較対象のデータには、{@link NyARMatchPattDeviationColorData}クラスの物を使います。\r
*/\r
public class NyARMatchPatt_Color_WITHOUT_PCA implements INyARMatchPatt\r
{\r
+ /** 基準パターンへの産初値*/\r
protected NyARCode _code_patt;\r
-\r
+ /** 最適化定数*/\r
protected int _optimize_for_mod;\r
+ /** 最適化定数*/\r
protected int _rgbpixels;\r
+ /**\r
+ * コンストラクタ。\r
+ * 基準パターンの解像度を指定して、インスタンスを生成します。\r
+ * このコンストラクタで生成したインスタンスの基準パターンは、NULLになっています。\r
+ * 後で基準パターンを{@link setARCode}関数で設定してください。\r
+ * @param i_width\r
+ * 基準パターンのサイズ\r
+ * @param i_height\r
+ * 基準パターンのサイズ\r
+ */ \r
public NyARMatchPatt_Color_WITHOUT_PCA(NyARCode i_code_ref)\r
{\r
int w=i_code_ref.getWidth();\r
this.setARCode(i_code_ref);\r
return;\r
}\r
+ /**\r
+ * コンストラクタ。\r
+ * 基準パターンを元に、評価インスタンスを生成します。\r
+ * @param i_code_ref\r
+ * セットする基準パターン\r
+ */ \r
public NyARMatchPatt_Color_WITHOUT_PCA(int i_width, int i_height)\r
{\r
//最適化定数の計算\r
return;\r
}\r
/**\r
- * 比較対象のARCodeをセットします。\r
+ * 基準パターンをセットします。セットできる基準パターンは、コンストラクタに設定したサイズと同じものである必要があります。\r
+ * @param i_code_ref\r
+ * セットする基準パターンを格納したオブジェクト\r
* @throws NyARException\r
*/\r
public void setARCode(NyARCode i_code_ref)\r
return;\r
}\r
/**\r
- * 現在セットされているARコードとi_pattを比較します。\r
- */\r
+ * この関数は、現在の基準パターンと検査パターンを比較して、類似度を計算します。\r
+ * @param i_patt\r
+ * 検査パターンを格納したオブジェクトです。このサイズは、基準パターンと一致している必要があります。\r
+ * @param o_result\r
+ * 結果を受け取るオブジェクトです。\r
+ * @return\r
+ * 検査に成功するとtrueを返します。\r
+ * @throws NyARException\r
+ */ \r
public boolean evaluate(NyARMatchPattDeviationColorData i_patt,NyARMatchPattResult o_result) throws NyARException\r
{\r
assert this._code_patt!=null;\r
import jp.nyatla.nyartoolkit.NyARException;\r
import jp.nyatla.nyartoolkit.core.NyARCode;\r
\r
+\r
/**\r
- * AR_TEMPLATE_MATCHING_COLORかつAR_MATCHING_WITH_PCAと同等のルールで マーカーを評価します。\r
- * \r
+ * このクラスは、カラーで２パターンの一致度を計算します。\r
+ * 評価アルゴリズムは、ARToolKitの、AR_TEMPLATE_MATCHING_COLORかつAR_MATCHING_WITH_PCAと同様です。\r
+ * 比較対象のデータには、{@link NyARMatchPattDeviationColorData}クラスの物を使います。\r
+ * @bug このクラスは動作確認が不十分です。動作しないかもしれませんので、注意してください。\r
*/\r
public class NyARMatchPatt_Color_WITH_PCA extends NyARMatchPatt_Color_WITHOUT_PCA\r
{\r
private double[][] evec;// static double evec[EVEC_MAX][AR_PATT_SIZE_Y*AR_PATT_SIZE_X*3];\r
private double[][] epat = new double[4][EVEC_MAX];// static double epat[AR_PATT_NUM_MAX][4][EVEC_MAX];\r
\r
-\r
+ /**\r
+ * コンストラクタ。\r
+ * 基準パターンの解像度を指定して、インスタンスを生成します。\r
+ * このコンストラクタで生成したインスタンスの基準パターンは、NULLになっています。\r
+ * 後で基準パターンを{@link setARCode}関数で設定してください。\r
+ * @param i_width\r
+ * 基準パターンのサイズ\r
+ * @param i_height\r
+ * 基準パターンのサイズ\r
+ */\r
public NyARMatchPatt_Color_WITH_PCA(int i_width, int i_height)\r
{\r
super(i_width,i_height);\r
return;\r
}\r
+ /**\r
+ * コンストラクタ。\r
+ * 基準パターンを元に、評価インスタンスを生成します。\r
+ * @param i_code_ref\r
+ * セットする基準パターン\r
+ */\r
public NyARMatchPatt_Color_WITH_PCA(NyARCode i_code_ref)\r
{\r
super(i_code_ref);\r
return;\r
- } \r
+ }\r
+ /**\r
+ * この関数は、現在の基準パターンと検査パターンを比較して、類似度を計算します。\r
+ * @param i_patt\r
+ * 検査パターンを格納したオブジェクトです。このサイズは、基準パターンと一致している必要があります。\r
+ * @param o_result\r
+ * 結果を受け取るオブジェクトです。\r
+ * @return\r
+ * 検査に成功するとtrueを返します。\r
+ * @throws NyARException\r
+ */ \r
public boolean evaluate(NyARMatchPattDeviationColorData i_patt,NyARMatchPattResult o_result) throws NyARException\r
{\r
final int[] linput = i_patt.refData();\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
/**\r
- * ARToolKitの樽型歪みパラメータを使う、歪み設定/解除クラスです。\r
- * パラメータと理論については、以下の資料、11pageを参照。\r
+ * このクラスは、樽型歪み設定/解除クラスです。\r
+ * パラメータには、ARToolKitの樽型歪みパラメータを使います。\r
+ * <p>アルゴリズム - \r
+ * このクラスでは、歪み矯正前の座標を観察座標系、歪み矯正後の座標を理想座標系と呼びます。\r
+ * パラメータと理論については、以下の資料、11pageを参照してください。\r
* http://www.hitl.washington.edu/artoolkit/Papers/ART02-Tutorial.pdf\r
- * \r
- * このクラスでは、歪み矯正前の座標を観察座標系、歪み矯正後の座標を理想座標系とします。\r
- * \r
+ * <pre>\r
* x=x(xi-x0),y=s(yi-y0)\r
* d^2=x^2+y^2\r
* p=(1-fd^2)\r
* xd=px+x0,yd=py+y0\r
+ * </pre>\r
+ * </p>\r
+ * このクラスは{@link NyARParam}に所有されることを前提にしており、単独の仕様は考慮されていません。\r
*/\r
public class NyARCameraDistortionFactor\r
{\r
private static final int PD_LOOP = 3;\r
private double _f0;//x0\r
private double _f1;//y0\r
- private double _f2;//100000000.0*ｆ\r
+ private double _f2;//100000000.0*f\r
private double _f3;//s\r
\r
\r
/**\r
- * 参照元から値をコピーします。\r
+ * この関数は、参照元から歪みパラメータ値をコピーします。\r
* @param i_ref\r
+ * コピー元のオブジェクト。\r
*/\r
public void copyFrom(NyARCameraDistortionFactor i_ref)\r
{\r
}\r
\r
/**\r
- * 配列の値をファクタ値としてセットします。\r
+ * この関数は、配列の値を歪みパラメータ値として、このインスタンスにセットします。\r
* @param i_factor\r
- * 4要素以上の配列\r
+ * 歪みパラメータ値を格納した配列。4要素である必要があります。\r
*/\r
public void setValue(double[] i_factor)\r
{\r
}\r
\r
/**\r
- * ファクタ値を配列に返します。\r
- * @param o_factor\r
+ * この関数は、パラメータ値を配列へ返します。\r
+ * @param i_factor\r
+ * 歪みパラメータ値の出力先配列。4要素である必要があります。\r
*/\r
public void getValue(double[] o_factor)\r
{\r
}\r
\r
/**\r
- * 歪みパラメータのスケールを変更します。\r
+ * この関数は、歪みパラメータをスケール倍します。\r
+ * パラメータ値は、スケール値の大きさだけ、拡大、又は縮小します。\r
* @param i_scale\r
+ * パラメータの倍率。\r
*/\r
public void changeScale(double i_scale)\r
{\r
- this._f0=this._f0*i_scale;// newparam->dist_factor[0] =source->dist_factor[0] *scale;\r
- this._f1=this._f1*i_scale;// newparam->dist_factor[1] =source->dist_factor[1] *scale;\r
+ this._f0=this._f0*i_scale;//X\r
+ this._f1=this._f1*i_scale;//Y\r
this._f2=this._f2/ (i_scale * i_scale);// newparam->dist_factor[2]=source->dist_factor[2]/ (scale*scale);\r
//this.f3=this.f3;// newparam->dist_factor[3] =source->dist_factor[3];\r
return;\r
}\r
- /*********\r
- * override\r
- *********/\r
\r
/**\r
- * 理想座標から、観察座標系へ変換します。\r
+ * この関数は、座標点を理想座標系から観察座標系へ変換します。\r
* @param i_in\r
+ * 変換元の座標\r
* @param o_out\r
+ * 変換後の座標を受け取るオブジェクト\r
*/\r
public final void ideal2Observ(NyARDoublePoint2d i_in, NyARDoublePoint2d o_out)\r
{\r
return;\r
}\r
\r
-\r
/**\r
- * 理想座標から、観察座標系へ変換します。\r
+ * この関数は、座標点を理想座標系から観察座標系へ変換します。\r
* @param i_in\r
+ * 変換元の座標\r
* @param o_out\r
+ * 変換後の座標を受け取るオブジェクト\r
*/\r
public final void ideal2Observ(NyARDoublePoint2d i_in, NyARIntPoint2d o_out)\r
{\r
}\r
\r
/**\r
- * 理想座標から、観察座標系へ変換します。\r
+ * この関数は、座標点を理想座標系から観察座標系へ変換します。\r
* @param i_x\r
+ * 変換元の座標\r
* @param i_y\r
+ * 変換元の座標\r
* @param o_out\r
+ * 変換後の座標を受け取るオブジェクト\r
*/\r
public final void ideal2Observ(double i_x,double i_y, NyARIntPoint2d o_out)\r
{\r
return;\r
}\r
\r
-\r
/**\r
- * 理想座標から、観察座標系へ変換します。\r
+ * この関数は、複数の座標点を、一括して理想座標系から観察座標系へ変換します。\r
* @param i_in\r
+ * 変換元の座標配列\r
* @param o_out\r
+ * 変換後の座標を受け取る配列\r
* @param i_size\r
+ * 変換する座標の個数。\r
*/\r
public final void ideal2ObservBatch(NyARDoublePoint2d[] i_in, NyARDoublePoint2d[] o_out, int i_size)\r
{\r
}\r
\r
/**\r
- * 複数の座標点について、観察座標から、理想座標系へ変換します。\r
+ * この関数は、複数の座標点を、一括して理想座標系から観察座標系へ変換します。\r
* @param i_in\r
+ * 変換元の座標配列\r
* @param o_out\r
+ * 変換後の座標を受け取る配列\r
* @param i_size\r
+ * 変換する座標の個数。\r
*/\r
public final void ideal2ObservBatch(NyARDoublePoint2d[] i_in, NyARIntPoint2d[] o_out, int i_size)\r
{\r
}\r
\r
/**\r
- * ARToolKitの観察座標から、理想座標系への変換です。\r
- * 樽型歪みを解除します。\r
+ * この関数は、座標を観察座標系から理想座標系へ変換します。\r
* @param ix\r
+ * 変換元の座標\r
* @param iy\r
+ * 変換元の座標\r
* @param o_point\r
+ * 変換後の座標を受け取るオブジェクト\r
*/\r
public final void observ2Ideal(double ix, double iy, NyARDoublePoint2d o_point)\r
{\r
}\r
\r
/**\r
- * {@link #observ2Ideal(double, double, NyARDoublePoint2d)}の出力型違い。o_veclinearのx,yフィールドに値を出力する。\r
+ * この関数は、座標を観察座標系から理想座標系へ変換します。\r
* @param ix\r
+ * 変換元の座標\r
* @param iy\r
- * @param o_point\r
+ * 変換元の座標\r
+ * @param o_veclinear\r
+ * 変換後の座標を受け取るオブジェクト。{@link NyARVecLinear2d#x}と{@link NyARVecLinear2d#y}のみに値をセットします。\r
*/\r
public void observ2Ideal(double ix, double iy, NyARVecLinear2d o_veclinear)\r
{\r
import jp.nyatla.nyartoolkit.core.types.matrix.NyARDoubleMatrix44;\r
\r
/**\r
- * 視錐台と、これを使った演算関数を定義します。\r
- * @author nyatla\r
- *\r
+ * このクラスは、視錐台と、これを使った演算関数を定義します。\r
+ * クラスのメンバには、視錐台行列、その逆行列があります。\r
+ * 提供する機能は、視錐台を使った演算です。\r
*/\r
public class NyARFrustum\r
{\r
- /** frastum行列*/\r
+ /** frustum行列*/\r
protected NyARDoubleMatrix44 _frustum_rh=new NyARDoubleMatrix44();\r
- /** frastum逆行列*/\r
- protected NyARDoubleMatrix44 _inv_frustum_rh=new NyARDoubleMatrix44(); \r
+ /** frustum逆行列*/\r
+ protected NyARDoubleMatrix44 _inv_frustum_rh=new NyARDoubleMatrix44();\r
+ /** 撮像画面のサイズ*/\r
protected NyARIntSize _screen_size=new NyARIntSize();\r
/**\r
- * コンストラクタです。ARToolkitの射影変換行列から、インスタンスを作ります。\r
+ * コンストラクタです。\r
+ * ARToolkitの射影変換行列から、インスタンスを作ります。\r
* @param i_projection\r
* @param i_width\r
* スクリーンサイズです。\r
this.setValue(i_projection, i_width, i_height, i_near, i_far);\r
}\r
/**\r
- * ARToolKitスタイルの射影変換行列から、視錐台をセットします。\r
+ * この関数は、ARToolKitスタイルの射影変換行列から視錐台を作成してセットします。\r
* @param i_projection\r
+ * ARToolKitスタイルの射影変換行列\r
* @param i_width\r
+ * スクリーンサイズです。\r
* @param i_height\r
+ * スクリーンサイズです。\r
* @param i_near\r
* nearポイントをmm単位で指定します。\r
* @param i_far\r
this._screen_size.setValue(i_width,i_height);\r
}\r
/**\r
- * 画像上の座標を、撮像点座標に変換します。\r
- * この座標は、カメラ座標系です。\r
+ * このスクリーン座標を、撮像点座標に変換します。\r
+ * 撮像点の座標系は、カメラ座標系になります。\r
+ * <p>公式 - \r
+ * この関数は、gluUnprojectのビューポートとモデルビュー行列を固定したものです。\r
+ * 公式は、以下の物使用しました。\r
+ * http://www.opengl.org/sdk/docs/man/xhtml/gluUnProject.xml\r
+ * ARToolKitの座標系に合せて計算するため、OpenGLのunProjectとはix,iyの与え方が違います。画面上の座標をそのまま与えてください。\r
+ * </p>\r
* @param ix\r
- * 画像上の座標\r
+ * スクリーン上の座標\r
* @param iy\r
* 画像上の座標\r
* @param o_point_on_screen\r
* 撮像点座標\r
- * <p>\r
- * この関数は、gluUnprojectのビューポートとモデルビュー行列を固定したものです。\r
- * 公式は、以下の物使用。\r
- * http://www.opengl.org/sdk/docs/man/xhtml/gluUnProject.xml\r
- * ARToolKitの座標系に合せて計算するため、OpenGLのunProjectとはix,iyの与え方が違います。画面上の座標をそのまま与えてください。\r
- * </p>\r
*/\r
public final void unProject(double ix,double iy,NyARDoublePoint3d o_point_on_screen)\r
{\r
return;\r
}\r
/**\r
- * 画面上の点と原点を結ぶ直線と任意姿勢の平面の交差点を、カメラの座標系で取得します。\r
+ * この関数は、スクリーン上の点と原点を結ぶ直線と、任意姿勢の平面の交差点を、カメラの座標系で取得します。\r
* この座標は、カメラ座標系です。\r
* @param ix\r
+ * スクリーン上の座標\r
* @param iy\r
+ * スクリーン上の座標\r
* @param i_mat\r
* 平面の姿勢行列です。\r
* @param o_pos\r
+ * 結果を受け取るオブジェクトです。\r
*/\r
public final void unProjectOnCamera(double ix,double iy,NyARDoubleMatrix44 i_mat,NyARDoublePoint3d o_pos)\r
{\r
/**\r
* 画面上の点と原点を結ぶ直線と任意姿勢の平面の交差点を、平面の座標系で取得します。\r
* ARToolKitの本P175周辺の実装と同じです。\r
+ * <p>\r
+ * このAPIは繰り返し使用には最適化されていません。同一なi_matに繰り返しアクセスするときは、展開してください。\r
+ * </p>\r
* @param ix\r
+ * スクリーン上の座標\r
* @param iy\r
+ * スクリーン上の座標\r
* @param i_mat\r
* 平面の姿勢行列です。\r
* @param o_pos\r
+ * 結果を受け取るオブジェクトです。\r
* @return\r
- * <p>\r
- * このAPIは繰り返し使用には最適化されていません。同一なi_matに繰り返しアクセスするときは、展開してください。\r
- * </p>\r
+ * 計算に成功すると、trueを返します。\r
*/\r
public final boolean unProjectOnMatrix(double ix,double iy,NyARDoubleMatrix44 i_mat,NyARDoublePoint3d o_pos)\r
{\r
return true;\r
}\r
/**\r
- * ã\82«ã\83¡ã\83©åº§æ¨\99ç³»ã\82\92ã\80\81ç\94»é\9d¢åº§æ¨\99へ変換します。\r
+ * ã\82«ã\83¡ã\83©åº§æ¨\99ç³»ã\81®ç\82¹ã\82\92ã\80\81ã\82¹ã\82¯ã\83ªã\83¼ã\83³åº§æ¨\99ã\81®ç\82¹へ変換します。\r
* @param i_x\r
+ * カメラ座標系の点\r
* @param i_y\r
+ * カメラ座標系の点\r
* @param i_z\r
+ * カメラ座標系の点\r
* @param o_pos2d\r
+ * 結果を受け取るオブジェクトです。\r
*/\r
public final void project(double i_x,double i_y,double i_z,NyARDoublePoint2d o_pos2d)\r
{\r
* 透視変換行列の参照値を返します。\r
* この値は読出し専用です。変更しないでください。\r
* @return\r
+ * [read only]透視変換行列を格納したオブジェクト\r
*/\r
public final NyARDoubleMatrix44 refMatrix()\r
{\r
* 透視変換行列の逆行列を返します。\r
* この値は読出し専用です。変更しないでください。\r
* @return\r
+ * [read only]透視変換行列の逆行列を格納したオブジェクト\r
*/\r
public final NyARDoubleMatrix44 refInvMatrix()\r
{\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
/**\r
- * 歪み矯正した座標系を格納したクラスです。\r
- * ２次元ラスタを１次元配列で表現します。\r
- *\r
+ * このクラスは、観察座標系を理想座標系へ変換するテーブルです。\r
+ * 座標系を変換するテーブルと、変換機能を提供します。\r
*/\r
public class NyARObserv2IdealMap\r
{\r
+ /** テーブル１行当たりのデータ数*/\r
protected int _stride;\r
+ /** X座標の変換テーブル*/\r
protected double[] _mapx;\r
+ /** Y座標の変換テーブル*/\r
protected double[] _mapy;\r
+ /**\r
+ * コンストラクタです。\r
+ * 入力した{@link NyARCameraDistortionFactor}とそのサイズから、テーブルを作成します。\r
+ * ２つのパラメータは整合性が取れていなければなりません。\r
+ * (通常は、{@link NyARParam}の{@link NyARParam#getDistortionFactor()},{@link NyARParam#getScreenSize()}から得られた\r
+ * パラメータを入力します。)\r
+ * @param i_distfactor\r
+ * 樽型歪みパラメータのオブジェクト。\r
+ * @param i_screen_size\r
+ * スクリーンサイズ\r
+ */\r
public NyARObserv2IdealMap(NyARCameraDistortionFactor i_distfactor,NyARIntSize i_screen_size)\r
{\r
NyARDoublePoint2d opoint=new NyARDoublePoint2d();\r
}\r
return;\r
}\r
+ /**\r
+ * この関数は、観察座標を理想座標へ変換します。\r
+ * 入力できる値範囲は、コンストラクタに設定したスクリーンサイズの範囲内です。\r
+ * @param ix\r
+ * 観察座標の値\r
+ * @param iy\r
+ * 観察座標の値\r
+ * @param o_point\r
+ * 理想座標を受け取るオブジェクト。\r
+ */\r
public void observ2Ideal(int ix, int iy, NyARIntPoint2d o_point)\r
{\r
int idx=ix+iy*this._stride;\r
o_point.x=(int)this._mapx[idx];\r
o_point.y=(int)this._mapy[idx];\r
return;\r
- } \r
+ }\r
+ /**\r
+ * この関数は、観察座標を理想座標へ変換します。\r
+ * 入力できる値範囲は、コンストラクタに設定したスクリーンサイズの範囲内です。\r
+ * @param ix\r
+ * 観察座標の値\r
+ * @param iy\r
+ * 観察座標の値\r
+ * @param o_point\r
+ * 理想座標を受け取るオブジェクト。\r
+ */ \r
public void observ2Ideal(int ix, int iy, NyARDoublePoint2d o_point)\r
{\r
int idx=ix+iy*this._stride;\r
o_point.y=this._mapy[idx];\r
return;\r
}\r
- \r
+ /**\r
+ * この関数は、一括して観察座標を理想座標へ変換します。\r
+ * 入力できる値範囲は、コンストラクタに設定したスクリーンサイズの範囲内です。\r
+ * @param i_coord\r
+ * 観察座標の配列\r
+ * @param i_start\r
+ * 変換対象にする配列の開始インデクス。\r
+ * @param i_num\r
+ * 変換対象にする要素の数。\r
+ * i_startから、i_start+i_num-1までの要素を変換します。\r
+ * @param o_x_coord\r
+ * 変換したX座標を受け取る配列。\r
+ * @param o_y_coord\r
+ * 変換したY座標を受け取る配列。\r
+ * @param i_out_start_index\r
+ * 出力先配列の開始インデクス。指定した位置から先に結果を返します。\r
+ */\r
public void observ2IdealBatch(NyARIntPoint2d[] i_coord,int i_start, int i_num, double[] o_x_coord,double[] o_y_coord,int i_out_start_index)\r
{\r
int idx;\r
import jp.nyatla.nyartoolkit.core.types.matrix.NyARDoubleMatrix44;\r
\r
/**\r
- * typedef struct { int xsize, ysize; double mat[3][4]; double dist_factor[4]; } ARParam;\r
- * NyARの動作パラメータを格納するクラス\r
- *\r
+ * このクラスは、NyARToolkitの環境パラメータを格納します。\r
+ * 環境パラメータは、ARToolKitのパラメータと同一です。\r
+ * パラメータの要素には、以下のものがあります。\r
+ * <ul>\r
+ * <li>樽型歪みパラメータ - 入力画像の樽型歪みパラメータです。\r
+ * <li>スクリーンサイズ - 入力画像の解像度です。\r
+ * <li>透視変換パラメータ - 4x4行列です。\r
+ * </ul>\r
*/\r
public class NyARParam\r
{\r
+ /** スクリーンサイズです。*/\r
protected NyARIntSize _screen_size=new NyARIntSize();\r
private static final int SIZE_OF_PARAM_SET = 4 + 4 + (3 * 4 * 8) + (4 * 8);\r
private NyARCameraDistortionFactor _dist=new NyARCameraDistortionFactor();\r
}\r
\r
/**\r
- * ARToolKit形式の透視変換行列を返します。\r
+ * この関数は、ARToolKit形式の透視変換行列を返します。\r
* @return\r
+ * [read only]透視変換行列を返します。\r
*/\r
public NyARPerspectiveProjectionMatrix getPerspectiveProjectionMatrix()\r
{\r
return this._projection_matrix;\r
}\r
/**\r
- * ARToolKit形式の歪み補正パラメータを返します。\r
+ * この関数は、ARToolKit形式の歪み補正パラメータを返します。\r
* @return\r
+ * [read only]歪み補正パラメータオブジェクト\r
*/\r
public NyARCameraDistortionFactor getDistortionFactor()\r
{\r
return this._dist;\r
}\r
/**\r
- * \r
+ * この関数は、配列から値を設定します。\r
* @param i_factor\r
* NyARCameraDistortionFactorにセットする配列を指定する。要素数は4であること。\r
* @param i_projection\r
this._projection_matrix.setValue(i_projection);\r
return;\r
}\r
-\r
- /**\r
- * ARToolKit標準ファイルから1個目の設定をロードする。\r
- * \r
- * @param i_filename\r
- * @throws NyARException\r
- */\r
- public void loadARParamFromFile(String i_filename) throws NyARException\r
- {\r
- try {\r
- loadARParam(new FileInputStream(i_filename));\r
- } catch (Exception e) {\r
- throw new NyARException(e);\r
- }\r
- }\r
-\r
/**\r
- * int arParamChangeSize( ARParam *source, int xsize, int ysize, ARParam *newparam );\r
- * 関数の代替関数 サイズプロパティをi_xsize,i_ysizeに変更します。\r
+ * この関数は、現在のスクリーンサイズを変更します。\r
+ * ARToolKitのarParamChangeSize関数に相当します。\r
* @param i_xsize\r
+ * 新しいサイズ\r
* @param i_ysize\r
- * @param newparam\r
- * @return\r
- * \r
+ * 新しいサイズ\r
*/\r
public void changeScreenSize(int i_xsize, int i_ysize)\r
{\r
return;\r
}\r
/**\r
- * 右手系の視錐台を作ります。\r
- * 計算結果を多用するときは、キャッシュするようにして下さい。\r
+ * この関数は、カメラパラメータから右手系の視錐台を作ります。\r
+ * <p>注意 -\r
+ * この処理は低速です。繰り返しの使用はできるだけ避けてください。\r
+ * </p>\r
* @param i_dist_min\r
+ * 視錐台のnear point(mm指定)\r
* @param i_dist_max\r
+ * 視錐台のfar point(mm指定)\r
* @param o_frustum\r
+ * 視錐台を受け取る配列。\r
+ * @see NyARPerspectiveProjectionMatrix#makeCameraFrustumRH\r
*/\r
public void makeCameraFrustumRH(double i_dist_min,double i_dist_max,NyARDoubleMatrix44 o_frustum)\r
{\r
return;\r
} \r
\r
+ /**\r
+ * この関数は、ARToolKit形式のカメラパラメータファイルから、1個目の設定をロードします。\r
+ * @param i_filename\r
+ * パラメータファイルのファイルパス\r
+ * @throws NyARException\r
+ */\r
+ public void loadARParamFromFile(String i_filename) throws NyARException\r
+ {\r
+ try {\r
+ loadARParam(new FileInputStream(i_filename));\r
+ } catch (Exception e) {\r
+ throw new NyARException(e);\r
+ }\r
+ }\r
+\r
+ \r
+\r
\r
/**\r
- * int arParamLoad( const char *filename, int num, ARParam *param, ...);\r
- * i_streamの入力ストリームからi_num個の設定を読み込み、パラメタを配列にして返します。\r
- * \r
+ * この関数は、ストリームからARToolKit形式のカメラパラメーを1個目の設定をロードします。\r
* @param i_stream\r
+ * 読み込むストリームです。\r
* @throws Exception\r
*/\r
public void loadARParam(InputStream i_stream)throws NyARException\r
}\r
return;\r
}\r
-\r
+ /**\r
+ * この関数は機能しません。\r
+ * @param i_stream\r
+ * 未定義\r
+ * @throws Exception\r
+ */\r
public void saveARParam(OutputStream i_stream)throws Exception\r
{\r
NyARException.trap("未チェックの関数");\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
/**\r
- * 透視変換行列を格納します。\r
- * http://www.hitl.washington.edu/artoolkit/Papers/ART02-Tutorial.pdf\r
- * 7ページを見るといいよ。\r
- *\r
+ * このクラスは、ARToolKit形式の透視変換行列を格納します。\r
+ * 透視変換関数と、射影変換行列の生成関数を提供します。\r
+ * このクラスは{@link NyARParam}に所有されることを前提にしており、単独の仕様は考慮されていません。\r
+ * <p>アルゴリズム -\r
+ * http://www.hitl.washington.edu/artoolkit/Papers/ART02-Tutorial.pdfの7ページを参照。\r
+ * </p>\r
*/\r
final public class NyARPerspectiveProjectionMatrix extends NyARDoubleMatrix44\r
{\r
+ /**\r
+ * コンストラクタです。空の行列を生成します。\r
+ */\r
public NyARPerspectiveProjectionMatrix()\r
{\r
this.m30=this.m31=this.m32=0;\r
{\r
return Math.sqrt(a * a + b * b + c * c);\r
}\r
-\r
/**\r
- * int arParamDecompMat( double source[3][4], double cpara[3][4], double trans[3][4] ); 関数の置き換え Optimize STEP[754->665]\r
- * \r
+ * この関数は、ARToolKitのarParamDecompMatと同じです。\r
+ * 動作はよくわかりません…。\r
* @param o_cpara\r
- * 戻り引数。3x4のマトリクスを指定すること。\r
+ * 詳細不明。3x4のマトリクスを指定すること。\r
* @param o_trans\r
- * 戻り引数。3x4のマトリクスを指定すること。\r
- * @return\r
+ * 詳細不明。3x4のマトリクスを指定すること。\r
*/\r
public void decompMat(NyARMat o_cpara, NyARMat o_trans)\r
{\r
return;\r
}\r
/**\r
- * int arParamChangeSize( ARParam *source, int xsize, int ysize, ARParam *newparam );\r
- * Matrixのスケールを変換します。\r
+ * 行列にスケール値を積算します。\r
* @param i_scale\r
- * \r
+ * スケール値\r
*/\r
public void changeScale(double i_scale)\r
{\r
}\r
\r
/**\r
- * 3次元座標を2次元座標に変換します。\r
+ * 座標値を射影変換します。\r
* @param i_3dvertex\r
+ * 変換元の座標値\r
* @param o_2d\r
+ * 変換後の座標値を受け取るオブジェクト\r
*/\r
public final void project(NyARDoublePoint3d i_3dvertex,NyARDoublePoint2d o_2d)\r
{\r
return;\r
}\r
/**\r
- * 3次元座標を2次元座標に変換します。\r
- * @param i_3dvertex\r
+ * 座標値を射影変換します。\r
+ * @param i_x\r
+ * 変換元の座標値\r
+ * @param i_y\r
+ * 変換元の座標値\r
+ * @param i_z\r
+ * 変換元の座標値\r
* @param o_2d\r
+ * 変換後の座標値を受け取るオブジェクト\r
*/\r
public final void project(double i_x,double i_y,double i_z,NyARDoublePoint2d o_2d)\r
{\r
return;\r
} \r
/**\r
- * 3次元座標を2次元座標に変換します。\r
+ * 座標値を射影変換します。\r
* @param i_3dvertex\r
+ * 変換元の座標値\r
* @param o_2d\r
+ * 変換後の座標値を受け取るオブジェクト\r
*/\r
public final void project(NyARDoublePoint3d i_3dvertex,NyARIntPoint2d o_2d)\r
{\r
return;\r
} \r
/**\r
- * 3次元座標を2次元座標に変換します。\r
- * @param i_3dvertex\r
+ * 座標値を射影変換します。\r
+ * @param i_x\r
+ * 変換元の座標値\r
+ * @param i_y\r
+ * 変換元の座標値\r
+ * @param i_z\r
+ * 変換元の座標値\r
* @param o_2d\r
+ * 変換後の座標値を受け取るオブジェクト\r
*/\r
public final void project(double i_x,double i_y,double i_z,NyARIntPoint2d o_2d)\r
{\r
\r
/**\r
* 右手系の視錐台を作ります。\r
+ * この視錐台は、ARToolKitのarglCameraViewRHの作る視錐台と同じです。\r
* @param i_screen_width\r
+ * スクリーンサイズを指定します。\r
* @param i_screen_height\r
+ * スクリーンサイズを指定します。\r
* @param i_dist_min\r
+ * near pointを指定します(mm単位)\r
* @param i_dist_max\r
+ * far pointを指定します(mm単位)\r
* @param o_frustum\r
+ * 視錐台の格納先オブジェクトを指定します。\r
*/\r
public void makeCameraFrustumRH(double i_screen_width,double i_screen_height,double i_dist_min,double i_dist_max,NyARDoubleMatrix44 o_frustum)\r
{\r
package jp.nyatla.nyartoolkit.core.pca2d;\r
\r
import jp.nyatla.nyartoolkit.NyARException;\r
-import jp.nyatla.nyartoolkit.core.types.NyARDoublePoint2d;\r
import jp.nyatla.nyartoolkit.core.types.matrix.NyARDoubleMatrix22;\r
\r
+/**\r
+ * このクラスは、主成分分析関数のインタフェイスを定義します。\r
+ * 主成分分析関数は、ARToolKitの輪郭線の直線化処理で使う機能です。\r
+ */\r
public interface INyARPca2d\r
{\r
/**\r
- * 通常のPCA\r
+ * この関数は、i_v1とi_v2ペアの値を主成分分析して、o_evec,o_ev,o_meanへ値を返します。\r
+ * 引数の詳細な意味はまだ調べていません。\r
* @param i_v1\r
+ * 修正分析する値の配列（通常X座標）\r
* @param i_v2\r
- * @param i_start\r
+ * 修正分析する値の配列（通常Y座標）\r
* @param i_number_of_point\r
+ * 配列中の有効な値の長さ\r
* @param o_evec\r
- * 要素2の変数を指定してください。\r
+ * 出力値\r
* @param o_ev\r
- * 要素2の変数を指定してください。\r
+ * 出力値\r
* @param o_mean\r
+ * 出力値\r
* @throws NyARException\r
*/\r
public void pca(double[] i_v1,double[] i_v2,int i_number_of_point,NyARDoubleMatrix22 o_evec, double[] o_ev,double[] o_mean) throws NyARException;\r
- /**\r
- * カメラ歪み補正つきのPCA\r
- * @param i_x\r
- * @param i_y\r
- * @param i_start\r
- * @param i_number_of_point\r
- * @param i_factor\r
- * @param o_evec\r
- * @param o_mean\r
- * @throws NyARException\r
- */\r
+// /**\r
+// * カメラ歪み補正つきのPCA\r
+// * @param i_x\r
+// * @param i_y\r
+// * @param i_start\r
+// * @param i_number_of_point\r
+// * @param i_factor\r
+// * @param o_evec\r
+// * @param o_mean\r
+// * @throws NyARException\r
+// */\r
// public void pcaWithDistortionFactor(int[] i_x,int[] i_y,int i_start,int i_number_of_point,INyARCameraDistortionFactor i_factor,NyARDoubleMatrix22 o_evec,NyARDoublePoint2d o_ev, NyARDoublePoint2d o_mean) throws NyARException;\r
}\r
import jp.nyatla.nyartoolkit.core.NyARMat;\r
import jp.nyatla.nyartoolkit.core.NyARVec;\r
import jp.nyatla.nyartoolkit.core.types.matrix.NyARDoubleMatrix22;\r
+\r
/**\r
- * NyARMatrixを利用した主成分分析\r
- * ARToolKitと同じ処理をします。\r
+ * このクラスは、ARToolKitと同じ手順で主成分分析を行います。\r
*/\r
public class NyARPca2d_MatrixPCA implements INyARPca2d\r
{\r
private final NyARMat __pca_evec = new NyARMat(2, 2);\r
private final NyARVec __pca_ev = new NyARVec(2);\r
private final NyARVec __pca_mean = new NyARVec(2); \r
- \r
+ //override\r
public void pca(double[] i_v1,double[] i_v2,int i_number_of_point,NyARDoubleMatrix22 o_evec, double[] o_ev,double[] o_mean) throws NyARException\r
{\r
final NyARMat input = this.__pca_input;// 次処理で初期化される。 \r
package jp.nyatla.nyartoolkit.core.pca2d;\r
\r
import jp.nyatla.nyartoolkit.NyARException;\r
-import jp.nyatla.nyartoolkit.core.types.*;\r
import jp.nyatla.nyartoolkit.core.types.matrix.*;\r
\r
/**\r
- * ARToolkitのPCA関数を二次元に特化させて単純化したもの\r
- *\r
+ * このクラスは、{@link NyARPca2d_MatrixPCA}を展開して高速化したものです。\r
+ * 演算の内容は、{@link NyARPca2d_MatrixPCA}と同一です。\r
*/\r
public class NyARPca2d_MatrixPCA_O2 implements INyARPca2d\r
{\r
// }\r
return;\r
}\r
+ //override\r
public void pca(double[] i_v1,double[] i_v2,int i_number_of_point,NyARDoubleMatrix22 o_evec, double[] o_ev,double[] o_mean) throws NyARException\r
{\r
PCA_PCA(i_v1,i_v2,i_number_of_point,o_evec, o_ev,o_mean);\r
import jp.nyatla.nyartoolkit.core.raster.rgb.*;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
+/**\r
+ * このインタフェイスは、{@link INyARRgbRaster}に、RGBラスタから任意の４頂点で定義した領域を、自由変形して格納する関数を追加します。\r
+ * 元々は、ARToolKitにある、画像からパターンを取得する処理用の関数です。\r
+ */\r
public interface INyARColorPatt extends INyARRgbRaster\r
{\r
/**\r
- * ã\83©ã\82¹ã\82¿ã\82¤ã\83¡ã\83¼ã\82¸ã\81\8bã\82\89i_squareé\83¨å\88\86ã\81®ã\82«ã\83©ã\83¼ã\83\91ã\82¿ã\83¼ã\83³ã\82\92æ\8a½å\87ºã\81\97ã\81¦ã\80\81thisã\83¡ã\83³ã\83\90ã\81«格納します。\r
- * \r
+ * ã\81\93ã\81®é\96¢æ\95°ã\81¯ã\80\81ç\94»å\83\8fã\81®ï¼\94é \82ç\82¹ã\81§ã\81\8bã\81\93ã\81¾ã\82\8cã\82\8bé \98å\9f\9fã\81\8bã\82\89ã\80\81è\87ªç\94±å¤\89å½¢ã\81\97ã\81\9fã\83\91ã\82¿ã\83¼ã\83³ã\82\92å\8f\96å¾\97ã\81\97ã\81¦格納します。\r
+ * 実装クラスでは、imageのi_vertexsで定義される四角形からパターンを取得して、インスタンスのバッファに格納する処理を書いてください。\r
* @param image\r
- * Source raster object.\r
- * ----\r
- * 抽出元のラスタオブジェクト\r
+ * 取得元の画像です。\r
* @param i_vertexs\r
- * Vertexes of the square. Number of element must be 4.\r
- * ----\r
- * 射影変換元の４角形を構成する頂点群頂群。要素数は4であること。\r
+ * 収録元画像上の、４頂点を格納した配列です。要素数は4である必要があります。\r
* @return\r
- * True if sucessfull; otherwise false.\r
- * ----\r
- * ラスターの取得に成功するとTRUE/失敗するとFALSE\r
+ * 取得に成功すると、trueを返します。\r
* @throws NyARException\r
*/\r
public boolean pickFromRaster(INyARRgbRaster image, NyARIntPoint2d[] i_vertexs) throws NyARException;\r
import jp.nyatla.nyartoolkit.core.raster.rgb.*;\r
import jp.nyatla.nyartoolkit.core.rasterreader.*;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
-import jp.nyatla.nyartoolkit.core.raster.*;\r
\r
/**\r
- * 24ビットカラーのマーカーを保持するために使うクラスです。 このクラスは、ARToolkitのパターンと、ラスタから取得したパターンを保持します。\r
- * 演算順序以外の最適化をしたもの\r
- * \r
+ * このクラスは、画像からパターンを取得する機能を備えたRGBラスタです。\r
+ * ARToolKit由来のアルゴリズムで画像からパターン取得する機能を提供します。\r
+ * この関数は可読性を重視しているため低速です。高速な{@link NyARColorPatt_O3}を使ってください。\r
*/\r
public class NyARColorPatt_O1 implements INyARColorPatt\r
{\r
private NyARRgbPixelReader_INT1D_X8R8G8B8_32 _pixelreader;\r
\r
private NyARIntSize _size;\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * 解像度を指定して、インスタンスを生成します。\r
+ * @param i_width\r
+ * ラスタのサイズ\r
+ * @param i_height\r
+ * ラスタのサイズ\r
+ */\r
public NyARColorPatt_O1(int i_width, int i_height)\r
{\r
//入力制限\r
this._pixelreader=new NyARRgbPixelReader_INT1D_X8R8G8B8_32(this._patdata,this._size);\r
return;\r
}\r
-\r
+ /**\r
+ * この関数はラスタの幅を返します。\r
+ */\r
public final int getWidth()\r
{\r
return this._size.w;\r
}\r
+ /**\r
+ * この関数はラスタの高さを返します。\r
+ */\r
public final int getHeight()\r
{\r
return this._size.h;\r
}\r
+ /**\r
+ * この関数はラスタのサイズの参照値を返します。\r
+ */\r
public final NyARIntSize getSize()\r
{\r
return this._size;\r
}\r
+ /**\r
+ * この関数は、ラスタの画素読み取りオブジェクトの参照値を返します。\r
+ */\r
public final INyARRgbPixelReader getRgbPixelReader()\r
{\r
return this._pixelreader;\r
}\r
+ /**\r
+ * この関数は、ラスタ画像のバッファを返します。\r
+ * バッファ形式は、{@link NyARBufferType#INT1D_X8R8G8B8_32}(int[])です。\r
+ */\r
public Object getBuffer()\r
{\r
return this._patdata;\r
}\r
+ /**\r
+ * この関数は、インスタンスがバッファを所有しているかを返します。基本的にtrueです。\r
+ */\r
public boolean hasBuffer()\r
{\r
return this._patdata!=null;\r
}\r
+ /**\r
+ * この関数は使用不可能です。\r
+ */\r
public void wrapBuffer(Object i_ref_buf) throws NyARException\r
{\r
NyARException.notImplement();\r
}\r
- final public int getBufferType()\r
+ /**\r
+ * この関数は、バッファタイプの定数を返します。\r
+ */\r
+ public final int getBufferType()\r
{\r
return BUFFER_FORMAT;\r
}\r
- final public boolean isEqualBufferType(int i_type_value)\r
+ /**\r
+ * この関数は、インスタンスのバッファタイプが引数のものと一致しているか判定します。\r
+ */\r
+ public final boolean isEqualBufferType(int i_type_value)\r
{\r
return BUFFER_FORMAT==i_type_value;\r
}\r
private final NyARMat __get_cpara_a = new NyARMat(8, 8);\r
private final NyARMat __get_cpara_b = new NyARMat(8, 1);\r
private final static double[][] __get__cpara_world = {{ 100.0, 100.0 }, { 100.0 + 10.0, 100.0 }, { 100.0 + 10.0, 100.0 + 10.0 },{ 100.0, 100.0 + 10.0 } };\r
- \r
- final protected boolean get_cpara(final NyARIntPoint2d[] i_vertex, NyARMat o_para)throws NyARException\r
+ /**\r
+ * この関数は、射影変換パラメータを計算します。\r
+ * @param i_vertex\r
+ * 変換元の４角系を定義する頂点配列。４頂点である必要がある。\r
+ * @param o_para\r
+ * 計算したパラメータの出力先配列\r
+ * @return\r
+ * 計算に成功するとtrueです。\r
+ * @throws NyARException\r
+ */\r
+ protected final boolean get_cpara(final NyARIntPoint2d[] i_vertex, NyARMat o_para)throws NyARException\r
{\r
double[][] world = __get__cpara_world;\r
NyARMat a = __get_cpara_a;// 次処理で値を設定するので、初期化不要// new NyARMat( 8, 8 );\r
private final NyARMat __pickFromRaster_cpara_c = new NyARMat(8, 1);\r
\r
/**\r
- * @see INyARColorPatt#pickFromRaster\r
+ * この関数は、ラスタのi_vertexsで定義される四角形からパターンを取得して、インスタンスに格納します。\r
*/\r
public boolean pickFromRaster(INyARRgbRaster image,NyARIntPoint2d[] i_vertexs)throws NyARException\r
{\r
\r
\r
/**\r
- * 24ビットカラーのマーカーを保持するために使うクラスです。 このクラスは、ARToolkitのパターンと、ラスタから取得したパターンを保持します。\r
- * 演算順序を含む最適化をしたもの\r
- * \r
+ * このクラスは、{@link NyARColorPatt_O1}を展開して高速化したクラスです。\r
*/\r
public class NyARColorPatt_O3 implements INyARColorPatt\r
{\r
private int[] _patdata;\r
private NyARIntSize _size;\r
private NyARRgbPixelReader_INT1D_X8R8G8B8_32 _pixelreader;\r
- \r
+ /**\r
+ * コンストラクタです。\r
+ * 解像度を指定して、インスタンスを生成します。\r
+ * @param i_width\r
+ * ラスタのサイズ\r
+ * @param i_height\r
+ * ラスタのサイズ\r
+ */ \r
public NyARColorPatt_O3(int i_width, int i_height)\r
{\r
this._size=new NyARIntSize(i_width,i_height);\r
this._patdata = new int[i_height*i_width];\r
this._pixelreader=new NyARRgbPixelReader_INT1D_X8R8G8B8_32(this._patdata,this._size);\r
}\r
+ /**\r
+ * この関数はラスタの幅を返します。\r
+ */\r
public int getWidth()\r
{\r
return this._size.w;\r
}\r
+ /**\r
+ * この関数はラスタの高さを返します。\r
+ */ \r
public int getHeight()\r
{\r
return this._size.h;\r
}\r
+ /**\r
+ * この関数はラスタのサイズの参照値を返します。\r
+ */\r
public NyARIntSize getSize()\r
{\r
return this._size;\r
}\r
+ /**\r
+ * この関数は、ラスタの画素読み取りオブジェクトの参照値を返します。\r
+ */\r
public INyARRgbPixelReader getRgbPixelReader()\r
{\r
return this._pixelreader;\r
}\r
+ /**\r
+ * この関数は、ラスタ画像のバッファを返します。\r
+ * バッファ形式は、{@link NyARBufferType#INT1D_X8R8G8B8_32}(int[])です。\r
+ */\r
public Object getBuffer()\r
{\r
return this._patdata;\r
}\r
+ /**\r
+ * この関数は、インスタンスがバッファを所有しているかを返します。基本的にtrueです。\r
+ */\r
public boolean hasBuffer()\r
{\r
return this._patdata!=null;\r
}\r
+ /**\r
+ * この関数は使用不可能です。\r
+ */\r
public void wrapBuffer(Object i_ref_buf) throws NyARException\r
{\r
NyARException.notImplement();\r
}\r
+ /**\r
+ * この関数は、バッファタイプの定数を返します。\r
+ */\r
final public int getBufferType()\r
{\r
return BUFFER_FORMAT;\r
}\r
- final public boolean isEqualBufferType(int i_type_value)\r
+ /**\r
+ * この関数は、インスタンスのバッファタイプが引数のものと一致しているか判定します。\r
+ */\r
+ public final boolean isEqualBufferType(int i_type_value)\r
{\r
return BUFFER_FORMAT==i_type_value;\r
}\r
{ 100, 100 }, { 100 + 10, 100 }, { 100 + 10, 100 + 10 }, { 100, 100 + 10 } };\r
\r
\r
-\r
/**\r
- * @see INyARColorPatt#pickFromRaster\r
+ * この関数は、ラスタのi_vertexsで定義される四角形からパターンを取得して、インスタンスに格納します。\r
*/\r
public boolean pickFromRaster(INyARRgbRaster image,NyARIntPoint2d[] i_vertexs)throws NyARException\r
{\r
\r
\r
/**\r
- * 遠近法を使ったパースペクティブ補正をかけて、ラスタ上の四角形から\r
- * 任意解像度の矩形パターンを作成します。\r
- *\r
+ * このクラスは、遠近法を使用して画像からパターンを取得します。\r
+ * 取得領域は、領域を定義する４頂点と、除外する枠線の幅（割合）から定義します。\r
*/\r
public class NyARColorPatt_Perspective implements INyARColorPatt\r
{\r
+ /** パターン格納用のバッファ*/\r
protected int[] _patdata;\r
+ /** 射影変換のLT位置*/\r
protected NyARIntPoint2d _pickup_lt=new NyARIntPoint2d(); \r
+ /** ソースパターンのサイズ*/\r
protected NyARIntSize _pickup_wh=new NyARIntSize(); \r
+ /** サンプリング解像度*/\r
protected int _resolution;\r
+ /** このラスタのサイズ*/\r
protected NyARIntSize _size;\r
+ /** 射影変換パラメータ計算オブジェクト*/\r
protected NyARPerspectiveParamGenerator _perspective_gen;\r
private NyARRgbPixelReader_INT1D_X8R8G8B8_32 _pixelreader;\r
private static final int LOCAL_LT=1;\r
return; \r
}\r
/**\r
- * コンストラクタです。サンプリングサイズを指定して、\r
+ * コンストラクタです。\r
+ * このラスタのサイズと、サンプリング定数を指定して、インスタンスを生成します。\r
* @param i_width\r
- * 取得画像の解像度幅\r
+ * このラスタの幅\r
* @param i_height\r
- * 取得画像の解像度高さ\r
+ * このラスタの高さ\r
* @param i_point_per_pix\r
* 1ピクセルあたりの縦横サンプリング数。2なら2x2=4ポイントをサンプリングする。\r
*/\r
return;\r
}\r
/**\r
- * 例えば、64\r
+ * コンストラクタです。\r
+ * このラスタのサイズと、サンプリング定数、エッジ幅を指定して、インスタンスを生成します。\r
* @param i_width\r
- * 取得画像の解像度幅\r
+ * このラスタの幅\r
* @param i_height\r
- * 取得画像の解像度高さ\r
+ * このラスタの高さ\r
+ * @param i_point_per_pix\r
+ * 1ピクセルあたりの縦横サンプリング数。2なら2x2=4ポイントをサンプリングする。\r
* @param i_edge_percentage\r
- * エッジ幅の割合(ARToolKit標準と同じなら、25)\r
+ * エッジの割合。ARToolKitと同じなら25を指定してください。\r
*/\r
public NyARColorPatt_Perspective(int i_width, int i_height,int i_point_per_pix,int i_edge_percentage)\r
{\r
return;\r
} \r
/**\r
- * 矩形領域のエッジサイズを指定します。\r
+ * 矩形領域のエッジ（枠）サイズをドット数で指定します。\r
* エッジの計算方法は以下の通りです。\r
- * 1.マーカ全体を(i_x_edge*2+width)x(i_y_edge*2+height)の解像度でパラメタを計算します。\r
- * 2.ピクセルの取得開始位置を(i_x_edge/2,i_y_edge/2)へ移動します。\r
- * 3.開始位置から、width x height個のピクセルを取得します。\r
- * \r
+ * <ol>\r
+ * <li>マーカ全体を(i_x_edge*2+width)x(i_y_edge*2+height)の解像度でパラメタを計算します。\r
+ * <li>ピクセルの取得開始位置を(i_x_edge/2,i_y_edge/2)へ移動します。\r
+ * <li>開始位置から、width x height個のピクセルを取得します。\r
+ * </ol>\r
* ARToolKit標準マーカの場合は、width/2,height/2を指定してください。\r
* @param i_x_edge\r
+ * X方向のエッジのサイズ。\r
* @param i_y_edge\r
+ * Y方向のエッジのサイズ。\r
+ * @param i_resolution\r
+ * 1ピクセルあたりの縦横サンプリング数。2なら2x2=4ポイントをサンプリングする。\r
*/\r
public void setEdgeSize(int i_x_edge,int i_y_edge,int i_resolution)\r
{\r
this._resolution=i_resolution; \r
return;\r
}\r
+ /**\r
+ * 矩形領域のエッジ（枠）サイズを、割合で指定します。\r
+ * @param i_x_percent\r
+ * 左右のエッジの割合です。0から50の間の数で指定します。\r
+ * @param i_y_percent\r
+ * 上下のエッジの割合です。0から50の間の数で指定します。\r
+ * @param i_resolution\r
+ * 1ピクセルあたりの縦横サンプリング数。2なら2x2=4ポイントをサンプリングする。\r
+ */\r
public void setEdgeSizeByPercent(int i_x_percent,int i_y_percent,int i_resolution)\r
{\r
assert(i_x_percent>=0);\r
setEdgeSize(this._size.w*i_x_percent/50,this._size.h*i_y_percent/50,i_resolution);\r
return;\r
}\r
-\r
- \r
+ /**\r
+ * この関数はラスタの幅を返します。\r
+ */\r
public final int getWidth()\r
{\r
return this._size.w;\r
}\r
+ /**\r
+ * この関数はラスタの高さを返します。\r
+ */ \r
public final int getHeight()\r
{\r
return this._size.h;\r
}\r
+ /**\r
+ * この関数はラスタのサイズの参照値を返します。\r
+ */\r
public final NyARIntSize getSize()\r
{\r
return this._size;\r
}\r
+ /**\r
+ * この関数は、ラスタの画素読み取りオブジェクトの参照値を返します。\r
+ */\r
public final INyARRgbPixelReader getRgbPixelReader()\r
{\r
return this._pixelreader;\r
}\r
+ /**\r
+ * この関数は、ラスタ画像のバッファを返します。\r
+ * バッファ形式は、{@link NyARBufferType#INT1D_X8R8G8B8_32}(int[])です。\r
+ */\r
public Object getBuffer()\r
{\r
return this._patdata;\r
}\r
+ /**\r
+ * この関数は、インスタンスがバッファを所有しているかを返します。基本的にtrueです。\r
+ */\r
public boolean hasBuffer()\r
{\r
return this._patdata!=null;\r
}\r
+ /**\r
+ * この関数は使用不可能です。\r
+ */\r
public void wrapBuffer(Object i_ref_buf) throws NyARException\r
{\r
NyARException.notImplement();\r
}\r
- final public int getBufferType()\r
+ /**\r
+ * この関数は、バッファタイプの定数を返します。\r
+ */\r
+ public final int getBufferType()\r
{\r
return BUFFER_FORMAT;\r
}\r
- final public boolean isEqualBufferType(int i_type_value)\r
+ /**\r
+ * この関数は、インスタンスのバッファタイプが引数のものと一致しているか判定します。\r
+ */ \r
+ public final boolean isEqualBufferType(int i_type_value)\r
{\r
return BUFFER_FORMAT==i_type_value;\r
}\r
private final int[] __pickFromRaster_rgb_tmp = new int[3];\r
+ /** ワーク変数*/\r
protected final double[] __pickFromRaster_cpara=new double[8];\r
\r
/**\r
- * @see INyARColorPatt#pickFromRaster\r
+ * この関数は、ラスタのi_vertexsで定義される四角形からパターンを取得して、インスタンスに格納します。\r
*/\r
public boolean pickFromRaster(INyARRgbRaster image,NyARIntPoint2d[] i_vertexs)throws NyARException\r
{\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
/**\r
- * 遠近法を使ったパースペクティブ補正をかけて、ラスタ上の四角形から\r
- * 任意解像度の矩形パターンを作成します。\r
- *\r
+ * このクラスは、高速化した{@link NyARColorPatt_Perspective}です。\r
+ * 入力ラスタを制限することで、高速なパターン取得ができます。\r
*/\r
public class NyARColorPatt_Perspective_O2 implements INyARColorPatt\r
{\r
private NyARIntPoint2d _edge=new NyARIntPoint2d();\r
+ /** パターン格納用のバッファ*/\r
protected int[] _patdata;\r
+ /** サンプリング解像度*/\r
protected int _resolution;\r
+ /** このラスタのサイズ*/ \r
protected NyARIntSize _size;\r
private NyARRgbPixelReader_INT1D_X8R8G8B8_32 _pixelreader;\r
private static final int BUFFER_FORMAT=NyARBufferType.INT1D_X8R8G8B8_32;\r
return; \r
}\r
/**\r
- * コンストラクタです。エッジサイズ0,InputRaster=ANYでインスタンスを作成します。\r
+ * コンストラクタです。\r
+ * エッジサイズ0,入力ラスタタイプの制限無しでインスタンスを作成します。\r
+ * 高速化が必要な時は、入力ラスタタイプを制限するコンストラクタを使ってください。\r
* @param i_width\r
* 取得画像の解像度幅\r
* @param i_height\r
return;\r
}\r
/**\r
- * コンストラクタです。エッジサイズ,InputRasterTypeを指定してインスタンスを作成します。\r
+ * コンストラクタです。\r
+ * エッジサイズ,入力ラスタタイプの制限を指定してインスタンスを作成します。\r
* @param i_width\r
* 取得画像の解像度幅\r
* @param i_height\r
* @param i_edge_percentage\r
* エッジ幅の割合(ARToolKit標準と同じなら、25)\r
* @param i_input_raster_type\r
- * 入力ラスタの種類\r
+ * 入力ラスタのバッファタイプ。高速化が期待できるバッファタイプについては、{@link NyARPerspectiveRasterReader#NyARPerspectiveRasterReader}\r
+ * を参照してください。\r
*/\r
public NyARColorPatt_Perspective_O2(int i_width, int i_height,int i_point_per_pix,int i_edge_percentage,int i_input_raster_type)\r
{\r
initializeInstance(i_width,i_height,i_point_per_pix,i_input_raster_type);\r
this._edge.setValue(i_edge_percentage, i_edge_percentage);\r
return;\r
- } \r
+ }\r
+ /**\r
+ * 矩形領域のエッジ（枠）サイズを、割合で指定します。\r
+ * @param i_x_percent\r
+ * 左右のエッジの割合です。0から50の間の数で指定します。\r
+ * @param i_y_percent\r
+ * 上下のエッジの割合です。0から50の間の数で指定します。\r
+ * @param i_resolution\r
+ * 1ピクセルあたりの縦横サンプリング数。2なら2x2=4ポイントをサンプリングする。\r
+ */\r
public void setEdgeSizeByPercent(int i_x_percent,int i_y_percent,int i_resolution)\r
{\r
assert(i_x_percent>=0);\r
this._resolution=i_resolution;\r
return;\r
}\r
-\r
- \r
+ /**\r
+ * この関数はラスタの幅を返します。\r
+ */\r
public final int getWidth()\r
{\r
return this._size.w;\r
}\r
+ /**\r
+ * この関数はラスタの高さを返します。\r
+ */\r
public final int getHeight()\r
{\r
return this._size.h;\r
}\r
+ /**\r
+ * この関数はラスタのサイズの参照値を返します。\r
+ */\r
public final NyARIntSize getSize()\r
{\r
return this._size;\r
}\r
+ /**\r
+ * この関数は、ラスタの画素読み取りオブジェクトの参照値を返します。\r
+ */ \r
public final INyARRgbPixelReader getRgbPixelReader()\r
{\r
return this._pixelreader;\r
}\r
+ /**\r
+ * この関数は、ラスタ画像のバッファを返します。\r
+ * バッファ形式は、{@link NyARBufferType#INT1D_X8R8G8B8_32}(int[])です。\r
+ */ \r
public Object getBuffer()\r
{\r
return this._patdata;\r
}\r
+ /**\r
+ * この関数は、インスタンスがバッファを所有しているかを返します。基本的にtrueです。\r
+ */ \r
public boolean hasBuffer()\r
{\r
return this._patdata!=null;\r
}\r
+ /**\r
+ * この関数は使用不可能です。\r
+ */\r
public void wrapBuffer(Object i_ref_buf) throws NyARException\r
{\r
NyARException.notImplement();\r
}\r
- final public int getBufferType()\r
+ /**\r
+ * この関数は、バッファタイプの定数を返します。\r
+ */\r
+ public final int getBufferType()\r
{\r
return BUFFER_FORMAT;\r
}\r
- final public boolean isEqualBufferType(int i_type_value)\r
+ /**\r
+ * この関数は、インスタンスのバッファタイプが引数のものと一致しているか判定します。\r
+ */ \r
+ public final boolean isEqualBufferType(int i_type_value)\r
{\r
return BUFFER_FORMAT==i_type_value;\r
}\r
/**\r
- * @see INyARColorPatt#pickFromRaster\r
+ * この関数は、ラスタのi_vertexsで定義される四角形からパターンを取得して、インスタンスに格納します。\r
*/\r
public boolean pickFromRaster(INyARRgbRaster image,NyARIntPoint2d[] i_vertexs)throws NyARException\r
{\r
import jp.nyatla.nyartoolkit.core.rasterreader.*;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
import jp.nyatla.nyartoolkit.core.types.matrix.*;\r
-import jp.nyatla.nyartoolkit.core.raster.*;\r
-\r
\r
\r
/**\r
- * 疑似アフィン変換を使用して、ラスタ上の四角形から任意解像度\r
- * の矩形パターンを作成します。\r
- *\r
+ * このクラスは、疑似アフィン変換を使用して画像からパターンを取得します。\r
+ * 取得領域は、領域を定義する４頂点と、除外する枠線の幅（割合）から定義します。\r
*/\r
public class NyARColorPatt_PseudoAffine implements INyARColorPatt\r
{\r
private NyARRgbPixelReader_INT1D_X8R8G8B8_32 _pixelreader;\r
private NyARIntSize _size;\r
private static final int BUFFER_FORMAT=NyARBufferType.INT1D_X8R8G8B8_32;\r
- \r
+ /**\r
+ * この関数はラスタの幅を返します。\r
+ */ \r
public final int getWidth()\r
{\r
return this._size.w;\r
}\r
- \r
+ /**\r
+ * この関数はラスタの高さを返します。\r
+ */ \r
public final int getHeight()\r
{\r
return this._size.h;\r
}\r
- \r
+ /**\r
+ * この関数はラスタのサイズの参照値を返します。\r
+ */ \r
public final NyARIntSize getSize()\r
{\r
return this._size;\r
}\r
+ /**\r
+ * この関数は、ラスタの画素読み取りオブジェクトの参照値を返します。\r
+ */ \r
public final INyARRgbPixelReader getRgbPixelReader()\r
{\r
return this._pixelreader;\r
}\r
+ /**\r
+ * この関数は、ラスタ画像のバッファを返します。\r
+ * バッファ形式は、{@link NyARBufferType#INT1D_X8R8G8B8_32}(int[])です。\r
+ */ \r
public Object getBuffer()\r
{\r
return this._patdata;\r
}\r
+ /**\r
+ * この関数は、インスタンスがバッファを所有しているかを返します。基本的にtrueです。\r
+ */ \r
public boolean hasBuffer()\r
{\r
return this._patdata!=null;\r
}\r
+ /**\r
+ * この関数は使用不可能です。\r
+ */ \r
public void wrapBuffer(Object i_ref_buf) throws NyARException\r
{\r
NyARException.notImplement();\r
}\r
- final public int getBufferType()\r
+ /**\r
+ * この関数は、バッファタイプの定数を返します。\r
+ */ \r
+ public final int getBufferType()\r
{\r
return BUFFER_FORMAT;\r
}\r
- final public boolean isEqualBufferType(int i_type_value)\r
+ /**\r
+ * この関数は、インスタンスのバッファタイプが引数のものと一致しているか判定します。\r
+ */ \r
+ public final boolean isEqualBufferType(int i_type_value)\r
{\r
return BUFFER_FORMAT==i_type_value;\r
} \r
- NyARDoubleMatrix44 _invmat=new NyARDoubleMatrix44();\r
+ private NyARDoubleMatrix44 _invmat=new NyARDoubleMatrix44();\r
+\r
/**\r
+ * コンストラクタです。\r
* @param i_width\r
+ * このラスタの幅\r
* @param i_height\r
+ * このラスタの高さ\r
*/\r
public NyARColorPatt_PseudoAffine(int i_width, int i_height)\r
{ \r
private double[] _convparam=new double[8];\r
\r
/**\r
- * @see INyARColorPatt#pickFromRaster\r
+ * この関数は、ラスタのi_vertexsで定義される四角形からパターンを取得して、インスタンスに格納します。\r
*/\r
public boolean pickFromRaster(INyARRgbRaster image,NyARIntPoint2d[] i_vertexs)throws NyARException\r
{\r
import jp.nyatla.nyartoolkit.NyARException;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
-\r
+/**\r
+ * このインタフェイスは、２次元ラスタにアクセスする関数を定義します。\r
+ * 二次元ラスタは、任意形式のバッファと、サイズ、バッファ形式を持つオブジェクトです。\r
+ */\r
public interface INyARRaster\r
{\r
+ /**\r
+ * この関数は、ラスタの幅を返します。\r
+ * 実装クラスでは、ラスタの幅を返す処理を実装してください。\r
+ * @return\r
+ * ラスタの幅\r
+ */\r
public int getWidth();\r
+ /**\r
+ * この関数は、ラスタの高さを返します。\r
+ * 実装クラスでは、ラスタの幅を返す処理を実装してください。\r
+ * @return\r
+ * ラスタの高さ\r
+ */\r
public int getHeight();\r
+ /**\r
+ * この関数は、ラスタのサイズを格納したオブジェクトの参照値を返します。\r
+ * 実装クラスでは、サイズオブジェクトの参照値を返す処理を実装してください。\r
+ * @return\r
+ * [read only]ラスタサイズの参照値\r
+ */\r
public NyARIntSize getSize();\r
/**\r
- * バッファオブジェクトを返します。\r
+ * この関数は、バッファオブジェクトを返します。\r
+ * 実装クラスでは、バッファを格納したオブジェクトを返してください。\r
* @return\r
+ * バッファを格納したオブジェクト。\r
*/\r
public Object getBuffer();\r
/**\r
* バッファオブジェクトのタイプを返します。\r
+ * 実装クラスでは、{@link #getBuffer}の返すバッファの形式を返してください。\r
* @return\r
+ * バッファの形式。{@link NyARBufferType}の定義値です。\r
*/\r
public int getBufferType();\r
/**\r
- * バッファのタイプがi_type_valueであるか、チェックします。\r
- * この値は、NyARBufferTypeに定義された定数値です。\r
+ * ã\81\93ã\81®é\96¢æ\95°ã\81¯ã\80\81ã\83\90ã\83\83ã\83\95ã\82¡ã\81®ã\82¿ã\82¤ã\83\97ã\81\8ci_type_valueã\81§ã\81\82ã\82\8bã\81\8bã\80\81ã\83\81ã\82§ã\83\83ã\82¯ã\81\97ã\81¾ã\81\99ã\80\82\r
+ * 実装クラスでは、格納しているバッファタイプがi_type_valueと等しいかを確認してください。\r
* @param i_type_value\r
+ * バッファタイプ値。{@link NyARBufferType}の定義値です。\r
* @return\r
+ * 真偽値。\r
*/\r
public boolean isEqualBufferType(int i_type_value);\r
/**\r
- * getBufferがオブジェクトを返せるかの真偽値です。\r
+ * この関数は、{@link #getBuffer}がオブジェクトを返せるかを真偽値返します。\r
+ * 外部参照バッファを使用できるクラスで使います。\r
+ * 実装クラスでは、{@link #getBuffer}がオブジェクトを返せるかの判定値を返してください。\r
* @return\r
+ * 真偽値。\r
*/\r
public boolean hasBuffer();\r
/**\r
- * i_ref_bufをラップします。できる限り整合性チェックを行います。\r
- * バッファの再ラッピングが可能な関数のみ、この関数を実装してください。\r
+ * この関数は、外部参照バッファをラップして、ラスタのバッファにします。\r
+ * 実装クラスでは、できる限り整合性チェックをしたうえで、バッファを切り替える処理を実装してください。\r
+ * この関数は、実装しなくともかまいません。その場合は、{@link NyARException}例外を発生させてください。\r
* @param i_ref_buf\r
+ * 切り替える外部参照バッファオブジェクト。\r
*/\r
public void wrapBuffer(Object i_ref_buf) throws NyARException;\r
}
\ No newline at end of file
import jp.nyatla.nyartoolkit.core.types.*;\r
import jp.nyatla.nyartoolkit.*;\r
\r
+/**\r
+ * このクラスは、２値画像を格納するラスタクラスです。\r
+ * 外部バッファ、内部バッファの両方に対応します。\r
+ */\r
public class NyARBinRaster extends NyARRaster_BasicClass\r
{\r
+ /** バッファオブジェクト。*/\r
protected Object _buf;\r
- /**\r
- * バッファオブジェクトがアタッチされていればtrue\r
- */\r
+ /** バッファオブジェクトがアタッチされていればtrue*/\r
protected boolean _is_attached_buffer;\r
/**\r
- * \r
+ * コンストラクタです。\r
+ * 画像のサイズパラメータとバッファ形式を指定して、インスタンスを生成します。\r
* @param i_width\r
+ * ラスタのサイズ\r
* @param i_height\r
+ * ラスタのサイズ\r
* @param i_raster_type\r
- * NyARBufferTypeに定義された定数値を指定してください。\r
+ * ラスタのバッファ形式。\r
+ * {@link NyARBufferType}に定義された定数値を指定してください。指定できる値は、以下の通りです。\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#INT2D_BIN_8}\r
+ * <ul>\r
* @param i_is_alloc\r
+ * バッファを外部参照にするかのフラグ値。\r
+ * trueなら内部バッファ、falseなら外部バッファを使用します。\r
+ * falseの場合、初期のバッファはnullになります。インスタンスを生成したのちに、{@link #wrapBuffer}を使って割り当ててください。\r
* @throws NyARException\r
*/\r
public NyARBinRaster(int i_width, int i_height,int i_raster_type,boolean i_is_alloc) throws NyARException\r
throw new NyARException();\r
}\r
}\r
+ /**\r
+ * コンストラクタです。\r
+ * 画像のサイズパラメータを指定して、{@link NyARBufferType#INT2D_BIN_8}形式のバッファを持つインスタンスを生成します。\r
+ * @param i_width\r
+ * ラスタのサイズ\r
+ * @param i_height\r
+ * ラスタのサイズ\r
+ * @param i_is_alloc\r
+ * バッファを外部参照にするかのフラグ値。\r
+ * trueなら内部バッファ、falseなら外部バッファを使用します。\r
+ * falseの場合、初期のバッファはnullになります。インスタンスを生成したのちに、{@link #wrapBuffer}を使って割り当ててください。\r
+ * @throws NyARException\r
+ */\r
public NyARBinRaster(int i_width, int i_height,boolean i_is_alloc) throws NyARException\r
{\r
super(i_width,i_height,NyARBufferType.INT1D_BIN_8);\r
throw new NyARException();\r
}\r
}\r
+ /**\r
+ * コンストラクタです。\r
+ * 画像のサイズパラメータを指定して、{@link NyARBufferType#INT2D_BIN_8}形式のバッファを持つインスタンスを生成します。\r
+ * このラスタは、内部参照バッファを持ちます。\r
+ * @param i_width\r
+ * ラスタのサイズ\r
+ * @param i_height\r
+ * ラスタのサイズ\r
+ * @throws NyARException\r
+ */\r
public NyARBinRaster(int i_width, int i_height) throws NyARException\r
{\r
super(i_width,i_height,NyARBufferType.INT1D_BIN_8);\r
if(!initInstance(this._size,NyARBufferType.INT1D_BIN_8,true)){\r
throw new NyARException();\r
}\r
- } \r
+ }\r
+ /**\r
+ * この関数は、インスタンスの初期化シーケンスを実装します。\r
+ * コンストラクタから呼び出します。\r
+ * @param i_size\r
+ * ラスタのサイズ\r
+ * @param i_buf_type\r
+ * バッファ形式定数\r
+ * @param i_is_alloc\r
+ * 内部バッファ/外部バッファのフラグ\r
+ * @return\r
+ * 初期化に成功するとtrue\r
+ */\r
protected boolean initInstance(NyARIntSize i_size,int i_buf_type,boolean i_is_alloc)\r
{\r
switch(i_buf_type)\r
this._is_attached_buffer=i_is_alloc;\r
return true;\r
}\r
+ /**\r
+ * この関数は、ラスタのバッファへの参照値を返します。\r
+ * バッファの形式は、コンストラクタに指定した形式と同じです。\r
+ */\r
public Object getBuffer()\r
{\r
return this._buf;\r
}\r
/**\r
- * インスタンスがバッファを所有するかを返します。\r
- * コンストラクタでi_is_allocをfalseにしてラスタを作成した場合、\r
- * バッファにアクセスするまえに、バッファの有無をこの関数でチェックしてください。\r
- * @return\r
+ * この関数は、インスタンスがバッファを所有するかを返します。\r
+ * 内部参照バッファの場合は、常にtrueです。\r
+ * 外部参照バッファの場合は、バッファにアクセスする前に、このパラメタを確認してください。\r
*/ \r
public boolean hasBuffer()\r
{\r
return this._buf!=null;\r
}\r
+ /**\r
+ * この関数は、ラスタに外部参照バッファをセットします。\r
+ * 外部参照バッファを持つインスタンスでのみ使用できます。内部参照バッファを持つインスタンスでは使用できません。\r
+ */\r
public void wrapBuffer(Object i_ref_buf)\r
{\r
assert(!this._is_attached_buffer);//バッファがアタッチされていたら機能しない。\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
/**\r
- * 1枚のグレースケール画像を定義するクラスです。画像データは内部保持/外部保持が選択可能です。\r
+ * このクラスは、グレースケース画像を格納するラスタクラスです。\r
+ * 外部バッファ、内部バッファの両方に対応します。\r
*/\r
public class NyARGrayscaleRaster extends NyARRaster_BasicClass\r
{\r
private IdoFilterImpl _impl;\r
+ /** バッファオブジェクト*/\r
protected Object _buf;\r
+ /** バッファオブジェクトがアタッチされていればtrue*/\r
+ protected boolean _is_attached_buffer;\r
/**\r
- * バッファオブジェクトがアタッチされていればtrue\r
+ * コンストラクタです。\r
+ * 内部参照のバッファ（{@link NyARBufferType#INT1D_GRAY_8}形式）を持つインスタンスを生成します。\r
+ * @param i_width\r
+ * ラスタのサイズ\r
+ * @param i_height\r
+ * ラスタのサイズ\r
+ * @throws NyARException\r
*/\r
- protected boolean _is_attached_buffer;\r
-\r
public NyARGrayscaleRaster(int i_width, int i_height) throws NyARException\r
{\r
super(i_width, i_height, NyARBufferType.INT1D_GRAY_8);\r
}\r
}\r
/**\r
- * \r
+ * コンストラクタです。\r
+ * 画像のサイズパラメータとバッファ参照方式を指定して、インスタンスを生成します。\r
+ * バッファの形式は、{@link NyARBufferType#INT1D_GRAY_8}です。\r
* @param i_width\r
+ * ラスタのサイズ\r
* @param i_height\r
+ * ラスタのサイズ\r
* @param i_is_alloc\r
- * 画像バッファを内部保持にするかのフラグ値。trueなら、インスタンスがバッファを確保します。falseなら、\r
- * 画像バッファは外部参照になり、wrapBuffer関数を使用できます。\r
+ * バッファを外部参照にするかのフラグ値。\r
+ * trueなら内部バッファ、falseなら外部バッファを使用します。\r
+ * falseの場合、初期のバッファはnullになります。インスタンスを生成したのちに、{@link #wrapBuffer}を使って割り当ててください。\r
* @throws NyARException\r
*/\r
public NyARGrayscaleRaster(int i_width, int i_height, boolean i_is_alloc)\r
}\r
\r
/**\r
+ * コンストラクタです。\r
+ * 画像のサイズパラメータとバッファ形式を指定して、インスタンスを生成します。\r
* @param i_width\r
+ * ラスタのサイズ\r
* @param i_height\r
+ * ラスタのサイズ\r
* @param i_raster_type\r
- * NyARBufferTypeに定義された定数値を指定してください。\r
+ * ラスタのバッファ形式。\r
+ * {@link NyARBufferType}に定義された定数値を指定してください。指定できる値は、以下の通りです。\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#INT1D_GRAY_8}\r
+ * <ul>\r
* @param i_is_alloc\r
+ * バッファを外部参照にするかのフラグ値。\r
+ * trueなら内部バッファ、falseなら外部バッファを使用します。\r
+ * falseの場合、初期のバッファはnullになります。インスタンスを生成したのちに、{@link #wrapBuffer}を使って割り当ててください。\r
* @throws NyARException\r
*/\r
public NyARGrayscaleRaster(int i_width, int i_height, int i_raster_type,boolean i_is_alloc) throws NyARException\r
/**\r
* このクラスの初期化シーケンスです。コンストラクタから呼び出します。\r
* @param i_size\r
+ * ラスタサイズ\r
* @param i_buf_type\r
+ * バッファ形式\r
* @param i_is_alloc\r
+ * バッファ参照方法値\r
* @return\r
*/\r
protected boolean initInstance(NyARIntSize i_size, int i_buf_type,boolean i_is_alloc)\r
this._is_attached_buffer = i_is_alloc;\r
return true;\r
}\r
+ /**\r
+ * この関数は、ラスタのバッファへの参照値を返します。\r
+ * バッファの形式は、コンストラクタに指定した形式と同じです。\r
+ */ \r
public Object getBuffer()\r
{\r
return this._buf;\r
}\r
\r
/**\r
- * ã\82¤ã\83³ã\82¹ã\82¿ã\83³ã\82¹ã\81\8cã\83\90ã\83\83ã\83\95ã\82¡ã\82\92æ\89\80æ\9c\89ã\81\99ã\82\8bã\81\8bã\82\92è¿\94ã\81\97ã\81¾ã\81\99ã\80\82 ã\82³ã\83³ã\82¹ã\83\88ã\83©ã\82¯ã\82¿ã\81§i_is_allocã\82\92falseã\81«ã\81\97ã\81¦ã\83©ã\82¹ã\82¿ã\82\92ä½\9cæ\88\90ã\81\97ã\81\9få ´å\90\88ã\80\81\r
- * バッファにアクセスするまえに、バッファの有無をこの関数でチェックしてください。\r
- * @return\r
+ * ã\81\93ã\81®é\96¢æ\95°ã\81¯ã\80\81ã\82¤ã\83³ã\82¹ã\82¿ã\83³ã\82¹ã\81\8cã\83\90ã\83\83ã\83\95ã\82¡ã\82\92æ\89\80æ\9c\89ã\81\99ã\82\8bã\81\8bã\82\92è¿\94ã\81\97ã\81¾ã\81\99ã\80\82\r
+ * 内部参照バッファの場合は、常にtrueです。\r
+ * 外部参照バッファの場合は、バッファにアクセスする前に、このパラメタを確認してください。\r
*/\r
public boolean hasBuffer()\r
{\r
return this._buf != null;\r
}\r
/**\r
- * 追加機能-無し。\r
- * @throws NyARException \r
+ * この関数は、ラスタに外部参照バッファをセットします。\r
+ * 外部参照バッファを持つインスタンスでのみ使用できます。内部参照バッファを持つインスタンスでは使用できません。\r
*/\r
public void wrapBuffer(Object i_ref_buf) throws NyARException\r
{\r
}\r
\r
/**\r
- * 指定した数値でラスタを埋めます。\r
+ * この関数は、指定した数値でラスタを埋めます。\r
* この関数は高速化していません。\r
* @param i_value\r
+ * 埋める数値を指定します。0から255の数値を指定して下さい。\r
*/\r
public void fill(int i_value)\r
{\r
- assert (this.isEqualBufferType(this.getBufferType()));\r
this._impl.fill(this,i_value);\r
}\r
\r
/**\r
- * ラスタの異解像度間コピーをします。\r
+ * この関数は、指定ラスタに、このインスタンスの内容をコピーをします。\r
+ * 異解像度間コピーもできますが、入力範囲とラスタサイズの間には、一定の関係が成立する必要があります。\r
* @param i_input\r
* 入力ラスタ\r
* @param i_top\r
////////////////////////////////////////////////////////////////////////////////\r
//ここからラスタドライバ\r
\r
- interface IdoFilterImpl\r
+ /** ラスタドライバの関数を定義します。*/\r
+ protected interface IdoFilterImpl\r
{\r
public void fill(NyARGrayscaleRaster i_raster,int i_value);\r
public void copyTo(NyARGrayscaleRaster i_input, int i_left,int i_top,int i_skip, NyARGrayscaleRaster o_output);\r
}\r
- \r
- final class IdoFilterImpl_INT1D_GRAY_8 implements IdoFilterImpl\r
+ /** {@link NyARBufferType#INT1D_GRAY_8}形式のラスタドライバです。*/\r
+ protected final class IdoFilterImpl_INT1D_GRAY_8 implements IdoFilterImpl\r
{\r
public void fill(NyARGrayscaleRaster i_raster,int i_value)\r
{\r
import jp.nyatla.nyartoolkit.NyARException;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
+/**\r
+ * このクラスは、HSV画像を格納するラスタクラスです。\r
+ * 内部バッファのみに対応します。\r
+ */\r
public final class NyARHsvRaster extends NyARRaster_BasicClass\r
{\r
\r
private int[] _ref_buf;\r
- \r
+ /**\r
+ * コンストラクタです。ラスタのサイズを指定して、インスタンスを生成します。\r
+ * @param i_width\r
+ * ラスタのサイズです。\r
+ * @param i_height\r
+ * ラスタのサイズです。\r
+ */\r
public NyARHsvRaster(int i_width, int i_height)\r
{\r
//このクラスは外部参照バッファ/形式多重化が使えない簡易実装です。\r
super(i_width,i_height,NyARBufferType.INT1D_X7H9S8V8_32);\r
this._ref_buf = new int[i_height*i_width];\r
}\r
+ /**\r
+ * この関数は、ラスタのバッファへの参照値を返します。\r
+ * バッファの形式{@link NyARBufferType.INT1D_X7H9S8V8_32}です。\r
+ */\r
public Object getBuffer()\r
{\r
return this._ref_buf;\r
}\r
+ /**\r
+ * この関数は、インスタンスがバッファを所有するかを返します。\r
+ * このクラスでは内部参照バッファのみをサポートするため、常にtrueです。\r
+ */ \r
public boolean hasBuffer()\r
{\r
return true;\r
}\r
+ /**\r
+ * この関数は、ラスタに外部参照バッファをセットします。\r
+ * 外部参照バッファを持つインスタンスでのみ使用できます。内部参照バッファを持つインスタンスでは使用できません。\r
+ */ \r
public void wrapBuffer(Object i_ref_buf) throws NyARException\r
{\r
NyARException.notImplement();\r
import jp.nyatla.nyartoolkit.NyARException;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
-/**このクラスは、単機能のNyARRasterです。\r
+/**\r
+ * このクラスは、指定形式のバッファを持つインスタンスを生成します。\r
+ * <p>対応しているバッファ形式は以下の通りです。\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#INT1D}\r
+ * <li>{@link NyARBufferType#INT1D_X8R8G8B8_32}\r
+ * <ul>\r
+ * </p>\r
*\r
*/\r
public class NyARRaster extends NyARRaster_BasicClass\r
{\r
+ /** バッファオブジェクトの変数*/\r
protected Object _buf;\r
- /**\r
- * バッファオブジェクトがアタッチされていればtrue\r
- */\r
+ /** バッファオブジェクトがアタッチされていればtrue*/\r
protected boolean _is_attached_buffer;\r
/**\r
- * 指定したバッファタイプのラスタを作成します。\r
+ * コンストラクタです。\r
+ * 画像のサイズパラメータとバッファ形式を指定して、インスタンスを生成します。\r
* @param i_width\r
+ * ラスタのサイズ\r
* @param i_height\r
- * @param i_buffer_type\r
- * NyARBufferTypeに定義された定数値を指定してください。\r
+ * ラスタのサイズ\r
+ * @param i_raster_type\r
+ * ラスタのバッファ形式。\r
+ * {@link NyARBufferType}に定義された定数値を指定してください。\r
+ * 指定できる値は、クラスの説明を見てください。\r
* @param i_is_alloc\r
+ * バッファを外部参照にするかのフラグ値。\r
+ * trueなら内部バッファ、falseなら外部バッファを使用します。\r
+ * falseの場合、初期のバッファはnullになります。インスタンスを生成したのちに、{@link #wrapBuffer}を使って割り当ててください。\r
* @throws NyARException\r
*/\r
public NyARRaster(int i_width, int i_height,int i_buffer_type,boolean i_is_alloc) throws NyARException\r
}\r
return;\r
} \r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * 画像のサイズパラメータとバッファ形式を指定して、インスタンスを生成します。\r
+ * @param i_width\r
+ * ラスタのサイズ\r
+ * @param i_height\r
+ * ラスタのサイズ\r
+ * @param i_raster_type\r
+ * ラスタのバッファ形式。\r
+ * {@link NyARBufferType}に定義された定数値を指定してください。\r
+ * 指定できる値は、クラスの説明を見てください。\r
+ * @throws NyARException\r
+ */\r
public NyARRaster(int i_width, int i_height,int i_buffer_type) throws NyARException\r
{\r
super(i_width,i_height,i_buffer_type);\r
throw new NyARException();\r
}\r
return;\r
- } \r
+ }\r
+ /**\r
+ * このクラスの初期化シーケンスです。コンストラクタから呼び出します。\r
+ * @param i_size\r
+ * ラスタサイズ\r
+ * @param i_buf_type\r
+ * バッファ形式\r
+ * @param i_is_alloc\r
+ * バッファ参照方法値\r
+ * @return\r
+ */\r
protected boolean initInstance(NyARIntSize i_size,int i_buf_type,boolean i_is_alloc)\r
{\r
switch(i_buf_type)\r
this._is_attached_buffer=i_is_alloc;\r
return true;\r
}\r
+ /**\r
+ * この関数は、ラスタのバッファへの参照値を返します。\r
+ * バッファの形式は、コンストラクタに指定した形式と同じです。\r
+ */ \r
public Object getBuffer()\r
{\r
return this._buf;\r
{\r
return this._buf!=null;\r
}\r
+ /**\r
+ * この関数は、ラスタに外部参照バッファをセットします。\r
+ * 外部参照バッファを持つインスタンスでのみ使用できます。内部参照バッファを持つインスタンスでは使用できません。\r
+ */ \r
public void wrapBuffer(Object i_ref_buf) throws NyARException\r
{\r
assert(!this._is_attached_buffer);//バッファがアタッチされていたら機能しない。\r
\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
+/**\r
+ * このクラスは、ラスタクラスの基本処理を実装します。\r
+ */\r
public abstract class NyARRaster_BasicClass implements INyARRaster\r
{\r
- protected NyARIntSize _size;\r
+ protected final NyARIntSize _size;\r
protected int _buffer_type;\r
+ /**\r
+ * コンストラクタです。\r
+ * メンバ変数を初期化して、インスタンスを生成します。\r
+ * @param i_width\r
+ * ラスタの幅に設定する値\r
+ * @param i_height\r
+ * ラスタの高さに設定する値\r
+ * @param i_buffer_type\r
+ * バッファタイプ値に設定する値\r
+ */\r
protected NyARRaster_BasicClass(int i_width,int i_height,int i_buffer_type)\r
{\r
this._size= new NyARIntSize(i_width,i_height);\r
this._buffer_type=i_buffer_type;\r
}\r
-\r
- final public int getWidth()\r
+ /**\r
+ * この関数は、ラスタの幅を返します。\r
+ */\r
+ public final int getWidth()\r
{\r
return this._size.w;\r
}\r
-\r
+ /**\r
+ * この関数は、ラスタの高さを返します。\r
+ */\r
final public int getHeight()\r
{\r
return this._size.h;\r
}\r
-\r
+ /**\r
+ * この関数は、ラスタのサイズを格納したオブジェクトを返します。\r
+ */\r
final public NyARIntSize getSize()\r
{\r
return this._size;\r
}\r
+ /**\r
+ * この関数は、ラスタのバッファへの参照値を返します。\r
+ * バッファの形式は、コンストラクタに指定した形式と同じです。\r
+ */ \r
final public int getBufferType()\r
{\r
return _buffer_type;\r
}\r
+ /**\r
+ * この関数は、ラスタの幅を返します。\r
+ */\r
final public boolean isEqualBufferType(int i_type_value)\r
{\r
return this._buffer_type==i_type_value;\r
import jp.nyatla.nyartoolkit.core.rasterreader.*;\r
\r
/**\r
- * 8bitRGBを表現できるラスタ\r
- * \r
+ * このインタフェイスは、{@link INyARRaster}に、カラー画像へアクセスする機能を追加します。\r
*/\r
public interface INyARRgbRaster extends INyARRaster\r
{\r
+ /**\r
+ * この関数は、画素フォーマットによらない画素アクセスを行うオブジェクトへの参照値を返します。\r
+ * 実装クラスでは、所有するバッファに関連したラスタ読出しオブジェクトを返す処理を実装してください。\r
+ * @return\r
+ * オブジェクトの参照値\r
+ * @throws NyARException\r
+ */\r
public INyARRgbPixelReader getRgbPixelReader() throws NyARException;\r
}
\ No newline at end of file
import jp.nyatla.nyartoolkit.core.types.*;\r
import jp.nyatla.nyartoolkit.*;\r
\r
+/**\r
+ * このクラスは、指定形式のバッファを持つRGBラスタです。\r
+ * 外部参照バッファ、内部バッファの両方に対応します。\r
+ * <p>\r
+ * 対応しているバッファタイプ-\r
+ * <ul>{@link NyARBufferType#INT1D_X8R8G8B8_32}\r
+ * <li>{@link NyARBufferType#BYTE1D_B8G8R8X8_32}\r
+ * <li>{@link NyARBufferType#BYTE1D_R8G8B8_24}\r
+ * <li>{@link NyARBufferType#BYTE1D_B8G8R8_24}\r
+ * <li>{@link NyARBufferType#BYTE1D_X8R8G8B8_32}\r
+ * <li>{@link NyARBufferType#WORD1D_R5G6B5_16LE}\r
+ * </ul>\r
+ * </p>\r
+ */\r
public class NyARRgbRaster extends NyARRgbRaster_BasicClass\r
{\r
+ /** バッファオブジェクト*/\r
protected Object _buf;\r
+ /** ピクセルリーダ*/\r
protected INyARRgbPixelReader _reader;\r
- /**\r
- * バッファオブジェクトがアタッチされていればtrue\r
- */\r
+ /** バッファオブジェクトがアタッチされていればtrue*/\r
protected boolean _is_attached_buffer;\r
\r
/**\r
- * \r
+ * コンストラクタです。\r
+ * 画像のサイズパラメータとバッファ形式を指定して、インスタンスを生成します。\r
* @param i_width\r
+ * ラスタのサイズ\r
* @param i_height\r
+ * ラスタのサイズ\r
* @param i_raster_type\r
- * NyARBufferTypeに定義された定数値を指定してください。\r
+ * ラスタのバッファ形式。\r
+ * {@link NyARBufferType}に定義された定数値を指定してください。\r
+ * 指定できる値は、クラスの説明を見てください。\r
* @param i_is_alloc\r
+ * バッファを外部参照にするかのフラグ値。\r
+ * trueなら内部バッファ、falseなら外部バッファを使用します。\r
+ * falseの場合、初期のバッファはnullになります。インスタンスを生成したのちに、{@link #wrapBuffer}を使って割り当ててください。\r
* @throws NyARException\r
*/\r
public NyARRgbRaster(int i_width, int i_height,int i_raster_type,boolean i_is_alloc) throws NyARException\r
}\r
}\r
/**\r
- * \r
+ * コンストラクタです。\r
+ * 画像のサイズパラメータとバッファ形式を指定して、インスタンスを生成します。\r
* @param i_width\r
+ * ラスタのサイズ\r
* @param i_height\r
+ * ラスタのサイズ\r
* @param i_raster_type\r
- * NyARBufferTypeに定義された定数値を指定してください。\r
+ * ラスタのバッファ形式。\r
+ * {@link NyARBufferType}に定義された定数値を指定してください。\r
+ * 指定できる値は、クラスの説明を見てください。\r
* @throws NyARException\r
*/\r
public NyARRgbRaster(int i_width, int i_height,int i_raster_type) throws NyARException\r
* Readerとbufferを初期化する関数です。コンストラクタから呼び出します。\r
* 継承クラスでこの関数を拡張することで、対応するバッファタイプの種類を増やせます。\r
* @param i_size\r
+ * ラスタのサイズ\r
* @param i_raster_type\r
+ * バッファタイプ\r
* @param i_is_alloc\r
+ * 外部参照/内部バッファのフラグ\r
* @return\r
*/\r
protected boolean initInstance(NyARIntSize i_size,int i_raster_type,boolean i_is_alloc)\r
this._is_attached_buffer=i_is_alloc;\r
return true;\r
}\r
+ /**\r
+ * この関数は、画素フォーマットによらない画素アクセスを行うオブジェクトへの参照値を返します。\r
+ * @return\r
+ * オブジェクトの参照値\r
+ * @throws NyARException\r
+ */ \r
public INyARRgbPixelReader getRgbPixelReader() throws NyARException\r
{\r
return this._reader;\r
}\r
+ /**\r
+ * この関数は、ラスタのバッファへの参照値を返します。\r
+ * バッファの形式は、コンストラクタに指定した形式と同じです。\r
+ */ \r
public Object getBuffer()\r
{\r
return this._buf;\r
}\r
+ /**\r
+ * インスタンスがバッファを所有するかを返します。\r
+ * コンストラクタでi_is_allocをfalseにしてラスタを作成した場合、\r
+ * バッファにアクセスするまえに、バッファの有無をこの関数でチェックしてください。\r
+ * @return\r
+ */ \r
public boolean hasBuffer()\r
{\r
return this._buf!=null;\r
}\r
+ /**\r
+ * この関数は、ラスタに外部参照バッファをセットします。\r
+ * 外部参照バッファの時にだけ使えます。\r
+ */\r
public void wrapBuffer(Object i_ref_buf) throws NyARException\r
{\r
assert(!this._is_attached_buffer);//バッファがアタッチされていたら機能しない。\r
package jp.nyatla.nyartoolkit.core.raster.rgb;\r
\r
import jp.nyatla.nyartoolkit.NyARException;\r
-import jp.nyatla.nyartoolkit.core.raster.*;\r
import jp.nyatla.nyartoolkit.core.types.NyARBufferType;\r
-\r
+/**\r
+ * このクラスは、{@link NyARBufferType#BYTE1D_B8G8R8X8_32}形式のバッファを持つラスタです。\r
+ * 外部参照バッファ、内部参照バッファの両方に対応します。\r
+ */\r
public class NyARRgbRaster_BGRA extends NyARRgbRaster\r
{\r
+ /**\r
+ * コンストラクタです。\r
+ * バッファの参照方法とラスタのサイズを指定して、インスタンスを生成します。\r
+ * @param i_width\r
+ * ラスタサイズ\r
+ * @param i_height\r
+ * ラスタサイズ\r
+ * @param i_is_alloc\r
+ * バッファ参照方法値。trueなら内部バッファ、falseなら外部参照バッファです。\r
+ */\r
public NyARRgbRaster_BGRA(int i_width, int i_height,boolean i_is_alloc) throws NyARException\r
{\r
super(i_width,i_height,NyARBufferType.BYTE1D_B8G8R8X8_32,i_is_alloc);\r
- } \r
+ }\r
+ /**\r
+ * コンストラクタです。\r
+ * ラスタのサイズを指定して、インスタンスを生成します。\r
+ * @param i_width\r
+ * ラスタサイズ\r
+ * @param i_height\r
+ * ラスタサイズ\r
+ */\r
public NyARRgbRaster_BGRA(int i_width, int i_height) throws NyARException\r
{\r
super(i_width,i_height,NyARBufferType.BYTE1D_B8G8R8X8_32);\r
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
\r
/**\r
- * NyARRasterインタフェイスの基本関数/メンバを実装したクラス\r
- * \r
- * \r
+ * このクラスは、RGBラスタクラスの基本処理を実装します。\r
*/\r
public abstract class NyARRgbRaster_BasicClass implements INyARRgbRaster\r
{\r
- final protected NyARIntSize _size;\r
+ /** ラスタのサイズを格納します。*/\r
+ protected final NyARIntSize _size;\r
private int _buffer_type;\r
+ /**\r
+ * コンストラクタです。\r
+ * @param i_width\r
+ * ラスタの幅に設定する値\r
+ * @param i_height\r
+ * ラスタの高さに設定する値\r
+ * @param i_buffer_type\r
+ * バッファタイプ値に設定する値\r
+ */\r
protected NyARRgbRaster_BasicClass(int i_width,int i_height,int i_buffer_type)\r
{\r
this._size= new NyARIntSize(i_width,i_height);\r
this._buffer_type=i_buffer_type;\r
}\r
+ /**\r
+ * この関数は、ラスタの幅を返します。\r
+ */ \r
final public int getWidth()\r
{\r
return this._size.w;\r
}\r
+ /**\r
+ * この関数は、ラスタの高さを返します。\r
+ */ \r
final public int getHeight()\r
{\r
return this._size.h;\r
}\r
-\r
+ /**\r
+ * この関数は、ラスタのサイズを格納したオブジェクトを返します。\r
+ */\r
final public NyARIntSize getSize()\r
{\r
return this._size;\r
}\r
+ /**\r
+ * この関数は、ラスタのバッファへの参照値を返します。\r
+ * バッファの形式は、コンストラクタに指定した形式と同じです。\r
+ */ \r
final public int getBufferType()\r
{\r
return _buffer_type;\r
}\r
+ /**\r
+ * この関数は、ラスタの幅を返します。\r
+ */ \r
final public boolean isEqualBufferType(int i_type_value)\r
{\r
return this._buffer_type==i_type_value;\r
import jp.nyatla.nyartoolkit.core.rasterreader.INyARRgbPixelReader;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
-/*\r
- * 真っ黒の矩形を定義する。\r
- * \r
+/**\r
+ * このクラスは、空のラスタを定義します。\r
+ * 空のラスタは、バッファを持たないサイズのみのラスタです。デバックなどに使います。\r
*/\r
public class NyARRgbRaster_Blank extends NyARRgbRaster_BasicClass\r
{\r
}\r
\r
private INyARRgbPixelReader _reader;\r
- \r
+ /**\r
+ * コンストラクタです。\r
+ * バッファの参照方法を指定して、インスタンスを生成します。\r
+ * @param i_width\r
+ * ラスタサイズ\r
+ * @param i_height\r
+ * ラスタサイズ\r
+ */\r
public NyARRgbRaster_Blank(int i_width, int i_height)\r
{\r
super(i_width,i_height,NyARBufferType.NULL_ALLZERO);\r
this._reader = new PixelReader();\r
return;\r
}\r
+ /**\r
+ * この関数は、画素フォーマットによらない画素アクセスを行うオブジェクトへの参照値を返します。\r
+ * @return\r
+ * オブジェクトの参照値\r
+ * @throws NyARException\r
+ */ \r
public INyARRgbPixelReader getRgbPixelReader() throws NyARException\r
{\r
return this._reader;\r
}\r
+ /**\r
+ * この関数は、ラスタのバッファへの参照値を返します。\r
+ * 常にNULLです。\r
+ */ \r
public Object getBuffer()\r
{\r
return null;\r
}\r
+ /**\r
+ * この関数は、インスタンスがバッファを所有するかを返します。\r
+ * 内部参照バッファの場合は、常にfalseです。\r
+ */ \r
public boolean hasBuffer()\r
{\r
return false;\r
}\r
+ /**\r
+ * この関数は、ラスタに外部参照バッファをセットします。\r
+ * このクラスでは使用できません。\r
+ */ \r
public void wrapBuffer(Object i_ref_buf) throws NyARException\r
{\r
NyARException.notImplement();\r
package jp.nyatla.nyartoolkit.core.raster.rgb;\r
\r
import jp.nyatla.nyartoolkit.NyARException;\r
-import jp.nyatla.nyartoolkit.core.raster.*;\r
import jp.nyatla.nyartoolkit.core.types.NyARBufferType;\r
\r
+/**\r
+ * このクラスは、{NyARBufferType#BYTE1D_R8G8B8_24}形式のバッファを持つラスタです。\r
+ * 内部参照バッファ、外部参照バッファの両方に対応します。\r
+ *\r
+ */\r
public class NyARRgbRaster_RGB extends NyARRgbRaster\r
{\r
+ /**\r
+ * コンストラクタです。\r
+ * バッファの参照方法とラスタのサイズを指定して、インスタンスを生成します。\r
+ * @param i_width\r
+ * ラスタサイズ\r
+ * @param i_height\r
+ * ラスタサイズ\r
+ * @param i_is_alloc\r
+ * バッファ参照方法値。trueなら内部バッファ、falseなら外部参照バッファです。\r
+ */ \r
public NyARRgbRaster_RGB(int i_width, int i_height,boolean i_is_alloc) throws NyARException\r
{\r
super(i_width,i_height,NyARBufferType.BYTE1D_R8G8B8_24,i_is_alloc);\r
}\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * ラスタのサイズを指定して、インスタンスを生成します。\r
+ * @param i_width\r
+ * ラスタサイズ\r
+ * @param i_height\r
+ * ラスタサイズ\r
+ */ \r
public NyARRgbRaster_RGB(int i_width, int i_height) throws NyARException\r
{\r
super(i_width,i_height,NyARBufferType.BYTE1D_R8G8B8_24);\r
\r
import jp.nyatla.nyartoolkit.NyARException;\r
import jp.nyatla.nyartoolkit.core.raster.*;\r
-\r
+/**\r
+ * このインタフェイスは、ラスタのフィルタ処理をする関数の関数を定義します。\r
+ */\r
public interface INyARRasterFilter\r
{\r
+ /**\r
+ * この関数は、入力画像にフィルタをかけて、出力画像へ書込みます。\r
+ * 実装クラスでは、i_inputのラスタにフィルタをかけて、i_outputへ値を出力してください。\r
+ * @param i_input\r
+ * 入力画像。\r
+ * @param i_output\r
+ * 出力画像\r
+ * @throws NyARException\r
+ */\r
public void doFilter(INyARRaster i_input, INyARRaster i_output) throws NyARException;\r
}
\ No newline at end of file
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
\r
/**\r
- * 色調テーブルを使用したフィルターです。\r
- * 色調テーブルクラスのベースクラスです。\r
+ * このクラスは、色調フィルタのベースクラスです。\r
+ * 継承クラスで{@link #table}に変換ルールを書き込む処理を実装します。 \r
+ * <p>対応している画素形式は以下の通りです。\r
+ * <li>{@link NyARBufferType#INT1D_GRAY_8}\r
+ * </p>\r
*/\r
public class NyARRasterFilter_CustomToneTable implements INyARRasterFilter\r
{\r
protected final int[] table=new int[256];\r
private IdoFilterImpl _dofilterimpl;\r
+ /**\r
+ * コンストラクタです。\r
+ * 入力/出力ラスタのバッファフォーマットを指定して、インスタンスを生成します。\r
+ * @param i_raster_type\r
+ * ラスタ形式。\r
+ * @throws NyARException\r
+ */\r
protected NyARRasterFilter_CustomToneTable(int i_raster_type) throws NyARException\r
{\r
switch (i_raster_type) {\r
}\r
this._dofilterimpl._table_ref=this.table;\r
}\r
+ /**\r
+ * 変換テーブルに従って、画素値を交換した画像を出力します。\r
+ * 画素形式は、コンストラクタに指定した形式に合せてください。\r
+ */\r
public void doFilter(INyARRaster i_input, INyARRaster i_output) throws NyARException\r
{\r
assert (i_input.getSize().isEqualSize(i_output.getSize()) == true);\r
import jp.nyatla.nyartoolkit.NyARException;\r
import jp.nyatla.nyartoolkit.core.analyzer.raster.NyARRasterAnalyzer_Histogram;\r
import jp.nyatla.nyartoolkit.core.raster.INyARRaster;\r
+import jp.nyatla.nyartoolkit.core.types.NyARBufferType;\r
import jp.nyatla.nyartoolkit.core.types.NyARHistogram;\r
+\r
/**\r
- * ヒストグラムを平滑化します。\r
- *\r
+ * このクラスは、ヒストグラムの平滑化フィルタです。\r
+ * <p>対応している画素形式は以下の通りです。\r
+ * <li>{@link NyARBufferType#INT1D_GRAY_8}\r
+ * </p>\r
*/\r
public class NyARRasterFilter_EqualizeHist extends NyARRasterFilter_CustomToneTable\r
{\r
private NyARRasterAnalyzer_Histogram _hist_analyzer;\r
private NyARHistogram _histogram=new NyARHistogram(256);\r
+ /**\r
+ * コンストラクタです。\r
+ * 入出力ラスタの形式と、ヒストグラムのサンプリングパラメータを入力して、インスタンスを生成します。\r
+ * @param i_raster_type\r
+ * 入出力ラスタの画素形式。\r
+ * @param i_sample_interval\r
+ * ヒストグラム分析の間引き値。何ラインおきに画素のスキャンを行うかを指定します。\r
+ * 1以上の数値を指定してください。\r
+ * @throws NyARException\r
+ */\r
public NyARRasterFilter_EqualizeHist(int i_raster_type,int i_sample_interval) throws NyARException\r
{\r
super(i_raster_type);\r
this._hist_analyzer=new NyARRasterAnalyzer_Histogram(i_raster_type,i_sample_interval);\r
}\r
+ /**\r
+ * 入力ラスタにトーンフィルタを適応した画素を出力ラスタへ書込みます。\r
+ * 画素形式は、コンストラクタに指定した形式に合せてください。\r
+ */\r
public void doFilter(INyARRaster i_input, INyARRaster i_output) throws NyARException\r
{\r
//ヒストグラムを得る\r
import jp.nyatla.nyartoolkit.core.types.NyARBufferType;\r
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
\r
-\r
/**\r
- * 平滑化フィルタ\r
- * Gaussianフィルタで画像を平滑化します。\r
+ * このクラスは、Gaussianフィルタで画像を平滑化します。\r
* カーネルサイズは3x3です。\r
+ * <p>対応している画素形式は以下の通りです。\r
+ * <li>{@link NyARBufferType#INT1D_GRAY_8}\r
+ * </p>\r
*/\r
public class NyARRasterFilter_GaussianSmooth implements INyARRasterFilter\r
{\r
- private IdoFilterImpl _do_filter_impl; \r
+ private IdoFilterImpl _do_filter_impl;\r
+ /**\r
+ * コンストラクタです。\r
+ * 入出力ラスタの形式を入力して、インスタンスを生成します。\r
+ * @param i_raster_type\r
+ * 入出力ラスタの画素形式。\r
+ * @throws NyARException\r
+ */ \r
public NyARRasterFilter_GaussianSmooth(int i_raster_type) throws NyARException\r
{\r
switch (i_raster_type) {\r
throw new NyARException();\r
}\r
}\r
+ /**\r
+ * 入力ラスタにGaussianフィルタを適応した画素を出力ラスタへ書込みます。\r
+ * 画素形式は、コンストラクタに指定した形式に合せてください。\r
+ */ \r
public void doFilter(INyARRaster i_input, INyARRaster i_output) throws NyARException\r
{\r
assert (i_input!=i_output);\r
this._do_filter_impl.doFilter(i_input,i_output,i_input.getSize());\r
}\r
- \r
- interface IdoFilterImpl\r
+ /** 変換用ドライバのインタフェイス*/\r
+ protected interface IdoFilterImpl\r
{\r
public void doFilter(INyARRaster i_input, INyARRaster i_output,NyARIntSize i_size) throws NyARException;\r
}\r
- class IdoFilterImpl_GRAY_8 implements IdoFilterImpl\r
+ private class IdoFilterImpl_GRAY_8 implements IdoFilterImpl\r
{\r
public void doFilter(INyARRaster i_input, INyARRaster i_output,NyARIntSize i_size) throws NyARException\r
{\r
\r
\r
/**\r
- * ネガポジ反転フィルタ。\r
- * 画像の明暗を反転します。\r
- *\r
+ * このクラスは、ネガポジ反転フィルタです。\r
+ * <p>対応している画素形式は以下の通りです。\r
+ * <li>{@link NyARBufferType#INT1D_GRAY_8}\r
+ * </p>\r
*/\r
public class NyARRasterFilter_Reverse implements INyARRasterFilter\r
{\r
- private IdoFilterImpl _do_filter_impl; \r
+ private IdoFilterImpl _do_filter_impl;\r
+ /**\r
+ * コンストラクタです。\r
+ * 入出力ラスタの形式を入力して、インスタンスを生成します。\r
+ * @param i_raster_type\r
+ * 入出力ラスタの画素形式。\r
+ * @throws NyARException\r
+ */ \r
public NyARRasterFilter_Reverse(int i_raster_type) throws NyARException\r
{\r
switch (i_raster_type) {\r
throw new NyARException();\r
}\r
}\r
+ /**\r
+ * 入力ラスタを反転して、画素を出力ラスタへ書込みます。\r
+ * 画素形式は、コンストラクタに指定した形式に合せてください。\r
+ */ \r
public void doFilter(INyARRaster i_input, INyARRaster i_output) throws NyARException\r
{\r
this._do_filter_impl.doFilter(i_input,i_output,i_input.getSize());\r
}\r
- \r
- interface IdoFilterImpl\r
+ /** 変換用ドライバのインタフェイス*/ \r
+ protected interface IdoFilterImpl\r
{\r
public void doFilter(INyARRaster i_input, INyARRaster i_output,NyARIntSize i_size) throws NyARException;\r
}\r
- class IdoFilterImpl_GRAY_8 implements IdoFilterImpl\r
+ private class IdoFilterImpl_GRAY_8 implements IdoFilterImpl\r
{\r
public void doFilter(INyARRaster i_input, INyARRaster i_output,NyARIntSize i_size) throws NyARException\r
{\r
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
\r
/**\r
- * RGB画像をHSV画像に変換します。\r
+ * このクラスは、RGB画像をHSV画像に変換するフィルタです。\r
+ * 対応している入力画素形式は以下の通りです。\r
+ * <p>入力画素形式\r
+ * <ul>\r
+ * <li>NyARBufferType.BYTE1D_B8G8R8_24\r
+ * </ul>\r
+ * </p>\r
+ * 出力画素形式は、{@link NyARBufferType#INT1D_X7H9S8V8_32}形式のHSVラスタに限られます。\r
*\r
*/\r
public class NyARRasterFilter_Rgb2Hsv implements INyARRasterFilter\r
{\r
private IdoFilterImpl _dofilterimpl;\r
+ /**\r
+ * コンストラクタです。\r
+ * 入力ラスタの形式を入力して、インスタンスを生成します。\r
+ * @param i_raster_type\r
+ * 入力ラスタの画素形式。\r
+ * @throws NyARException\r
+ */\r
public NyARRasterFilter_Rgb2Hsv(int i_raster_type) throws NyARException\r
{\r
switch (i_raster_type) {\r
throw new NyARException();\r
}\r
}\r
+ /**\r
+ * 入力ラスタをHSV形式に変換して、出力ラスタへ書込みます。\r
+ * 画素形式は、コンストラクタに指定した形式に合せてください。\r
+ */ \r
public void doFilter(INyARRaster i_input, INyARRaster i_output) throws NyARException\r
{\r
assert (i_input.getSize().isEqualSize(i_output.getSize()) == true);\r
this._dofilterimpl.doFilter(i_input,i_output,i_input.getSize());\r
}\r
- \r
- abstract class IdoFilterImpl\r
+ /** 変換用ドライバのインタフェイス*/ \r
+ protected abstract class IdoFilterImpl\r
{\r
public abstract void doFilter(INyARRaster i_input, INyARRaster i_output,NyARIntSize i_size) throws NyARException;\r
\r
}\r
- class IdoFilterImpl_BYTE1D_B8G8R8_24 extends IdoFilterImpl\r
+ private class IdoFilterImpl_BYTE1D_B8G8R8_24 extends IdoFilterImpl\r
{\r
public void doFilter(INyARRaster i_input, INyARRaster i_output,NyARIntSize i_size) throws NyARException\r
{\r
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
\r
/**\r
- * Roberts法で勾配を計算します。\r
+ * このクラスは、Roberts法で勾配画像を作ります。\r
* 右端と左端の1ピクセルは、常に0が入ります。\r
+ * <p>対応している画素形式は以下の通りです。\r
+ * <li>{@link NyARBufferType#INT1D_GRAY_8}\r
+ * </p>\r
+ * <pre>\r
* X=|-1, 0| Y=|0,-1|\r
* | 0, 1| |1, 0|\r
* V=sqrt(X^2+Y+2)/2\r
+ * </pre>\r
*/\r
public class NyARRasterFilter_Roberts implements INyARRasterFilter\r
{\r
- private IdoFilterImpl _do_filter_impl; \r
+ private IdoFilterImpl _do_filter_impl;\r
+ /**\r
+ * コンストラクタです。\r
+ * 入力/出力ラスタの形式を入力して、インスタンスを生成します。\r
+ * @param i_raster_type\r
+ * 入力/出力ラスタの画素形式。\r
+ * @throws NyARException\r
+ */ \r
public NyARRasterFilter_Roberts(int i_raster_type) throws NyARException\r
{\r
switch (i_raster_type) {\r
throw new NyARException();\r
}\r
}\r
+ /**\r
+ * 入力ラスタのRoberts勾配を出力ラスタへ書込みます。\r
+ * 画素形式は、コンストラクタに指定した形式に合せてください。\r
+ */ \r
public void doFilter(INyARRaster i_input, INyARRaster i_output) throws NyARException\r
{\r
this._do_filter_impl.doFilter(i_input,i_output,i_input.getSize());\r
}\r
- \r
- interface IdoFilterImpl\r
+ /** 変換用ドライバのインタフェイス*/ \r
+ protected interface IdoFilterImpl\r
{\r
public void doFilter(INyARRaster i_input, INyARRaster i_output,NyARIntSize i_size) throws NyARException;\r
}\r
- class IdoFilterImpl_GRAY_8 implements IdoFilterImpl\r
+ private class IdoFilterImpl_GRAY_8 implements IdoFilterImpl\r
{\r
public void doFilter(INyARRaster i_input, INyARRaster i_output,NyARIntSize i_size) throws NyARException\r
{\r
import jp.nyatla.nyartoolkit.core.types.NyARBufferType;\r
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
\r
-\r
/**\r
- * 平滑化フィルタ\r
- * 画像を平滑化します。\r
+ * このクラスは、単純平滑化フィルタです。\r
* カーネルサイズは3x3です。\r
+ * <p>対応している画素形式は以下の通りです。\r
+ * <li>{@link NyARBufferType#INT1D_GRAY_8}\r
+ * </p>\r
*/\r
public class NyARRasterFilter_SimpleSmooth implements INyARRasterFilter\r
{\r
- private IdoFilterImpl _do_filter_impl; \r
+ private IdoFilterImpl _do_filter_impl;\r
+ /**\r
+ * コンストラクタです。\r
+ * 入力/出力ラスタの形式を入力して、インスタンスを生成します。\r
+ * @param i_raster_type\r
+ * 入力/出力ラスタの画素形式。\r
+ * @throws NyARException\r
+ */ \r
public NyARRasterFilter_SimpleSmooth(int i_raster_type) throws NyARException\r
{\r
switch (i_raster_type) {\r
throw new NyARException();\r
}\r
}\r
+ /**\r
+ * 入力ラスタを平滑化して、出力ラスタへ書込みます。\r
+ * 画素形式は、コンストラクタに指定した形式に合せてください。\r
+ */ \r
public void doFilter(INyARRaster i_input, INyARRaster i_output) throws NyARException\r
{\r
assert (i_input!=i_output);\r
this._do_filter_impl.doFilter(i_input,i_output,i_input.getSize());\r
}\r
- \r
- interface IdoFilterImpl\r
+ /** 変換用ドライバのインタフェイス*/ \r
+ protected interface IdoFilterImpl\r
{\r
public void doFilter(INyARRaster i_input, INyARRaster i_output,NyARIntSize i_size) throws NyARException;\r
}\r
- class IdoFilterImpl_GRAY_8 implements IdoFilterImpl\r
+ private class IdoFilterImpl_GRAY_8 implements IdoFilterImpl\r
{\r
public void doFilter(INyARRaster i_input, INyARRaster i_output,NyARIntSize i_size) throws NyARException\r
{\r
package jp.nyatla.nyartoolkit.core.rasterfilter;\r
\r
import jp.nyatla.nyartoolkit.NyARException;\r
+import jp.nyatla.nyartoolkit.core.types.NyARBufferType;\r
\r
/**\r
- * 色調テーブルを使用したフィルターです。\r
- * 基本的な関数テーブルで色調テーブルを作成できます。\r
+ * このクラスは、色調テーブルフィルタです。\r
+ * トーンテーブルの内容に従って、画素を置換します。\r
+ * <p>対応している画素形式は以下の通りです。\r
+ * <li>{@link NyARBufferType#INT1D_GRAY_8} - \r
+ * x,y平面は0を原点とした、256×256の平面です。\r
+ * xの値が入力値、yの値が出力値に対応します。\r
+ * 0未満、256以上の数値はクリッピングされます。\r
+ * </p>\r
*/\r
public class NyARRasterFilter_ToneTable extends NyARRasterFilter_CustomToneTable\r
{\r
+ /**\r
+ * コンストラクタです。\r
+ * 入力/出力ラスタの形式を入力して、インスタンスを生成します。\r
+ * @param i_raster_type\r
+ * 入力/出力ラスタの画素形式。\r
+ * @throws NyARException\r
+ */ \r
public NyARRasterFilter_ToneTable(int i_raster_type) throws NyARException\r
{\r
super(i_raster_type);\r
}\r
/**\r
- * 点x,yを通過する、傾きi_aの直線をテーブルに書き込みます。\r
+ * トーンテーブルに、点x,yを通過する、傾きi_aの直線を定義します。\r
* @param i_x\r
+ * 直線の通過点\r
* @param i_y\r
+ * 直線の通過点\r
* @param i_a\r
+ * 直線の傾きです。\r
*/\r
public void setLine(int i_x,int i_y,double i_a)\r
{\r
}\r
}\r
/**\r
- * 点0,0を通過する、傾きaの直線をテーブルに書き込みます。\r
+ * トーンテーブルに、点0,0を通過する、傾きi_aの直線を定義します。\r
+ * <p>設定例-\r
* i_aの値をvとしたとき、以下のようになります。\r
- * v<=0 黒色\r
- * 0<v<1 暗くする。\r
- * v=0 変化しない\r
- * 1<v<255 明るくする。\r
- * 255<=v 白色\r
- * @param i_ax\r
- * @param i_ay\r
+ * <ul>\r
+ * <li>v<=0 黒色\r
+ * <li>0<v<1 暗くする。\r
+ * <li>v=0 変化しない\r
+ * <li>1<v<255 明るくする。\r
+ * <li>255<=v 白色\r
+ * </ul>\r
+ * </p>\r
+ * @param i_a\r
+ * 直線の傾きです。\r
*/\r
public void setLine(double i_a)\r
{\r
setLine(0,0,i_a);\r
}\r
/**\r
- * 点 i_x,i_yを中心とする、ゲインi_gainのシグモイド関数をテーブルに書き込みます。\r
+ * ç\82¹ i_x,i_yã\82\92ä¸å¿\83ã\81¨ã\81\99ã\82\8bã\80\81ã\82²ã\82¤ã\83³i_gainã\81®ã\82·ã\82°ã\83¢ã\82¤ã\83\89é\96¢æ\95°ã\82\92ã\83\88ã\83¼ã\83³ã\83\86ã\83¼ã\83\96ã\83«ã\81«æ\9b¸ã\81\8dè¾¼ã\81¿ã\81¾ã\81\99ã\80\82\r
* @param i_x\r
+ * 直線の通過点\r
* @param i_y\r
+ * 直線の通過点\r
* @param i_gain\r
+ * シグモイド関数のゲイン値\r
*/\r
public void setSigmoid(int i_x,int i_y,double i_gain)\r
{\r
}\r
}\r
/**\r
- * ガンマ補正値をテーブルに書き込みます。\r
+ * ã\82¬ã\83³ã\83\9eè£\9cæ£å\80¤ã\82\92ã\83\88ã\83¼ã\83³ã\83\86ã\83¼ã\83\96ã\83«ã\81«æ\9b¸ã\81\8dè¾¼ã\81¿ã\81¾ã\81\99ã\80\82\r
* @param i_gamma\r
+ * ガンマ値\r
*/\r
public void setGamma(double i_gamma)\r
{\r
import jp.nyatla.nyartoolkit.core.raster.NyARBinRaster;\r
import jp.nyatla.nyartoolkit.core.raster.NyARGrayscaleRaster;\r
\r
+/**\r
+ * このインタフェイスは、グレースケール画像から２値画像を生成する関数を定義します。\r
+ */\r
public interface INyARRasterFilter_Gs2Bin\r
{\r
+ /**\r
+ * この関数は、入力画像を２値化して、出力画像へ書込みます。\r
+ * 実装クラスでは、i_inputのラスタを２値化して、i_outputへ値を出力してください。\r
+ * @param i_input\r
+ * 入力画像。\r
+ * @param i_output\r
+ * 出力画像\r
+ * @throws NyARException\r
+ */ \r
public void doFilter(NyARGrayscaleRaster i_input, NyARBinRaster i_output) throws NyARException;\r
-\r
}\r
import jp.nyatla.nyartoolkit.core.types.NyARBufferType;\r
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
\r
+/**\r
+ * このクラスは、固定敷居値を用いて、画像を２値化します。\r
+ * 入力できるラスタ、出力できるラスタの形式は以下の通りです。\r
+ * <ul>\r
+ * <li> 入力形式 - {@link NyARBufferType#INT1D_GRAY_8}\r
+ * <li> 出力形式 - {@link NyARBufferType#INT1D_BIN_8}\r
+ * </ul>\r
+ */\r
public class NyARRasterFilter_ConstantThreshold implements INyARRasterFilter_Gs2Bin\r
{\r
- public int _threshold;\r
+ /** 敷居値。*/\r
+ protected int _threshold;\r
+ /**\r
+ * コンストラクタです。\r
+ * 固定式位置の初期値、入力、出力ラスタの画素形式を指定して、フィルタを作成します。\r
+ * @param i_initial_threshold\r
+ * 敷居値の初期値です。0<n<256の値を指定します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの形式です。\r
+ * @param i_out_raster_type\r
+ * 出力ラスタの形式です。\r
+ * @throws NyARException\r
+ */\r
public NyARRasterFilter_ConstantThreshold(int i_initial_threshold,int i_in_raster_type,int i_out_raster_type) throws NyARException\r
{\r
assert(i_in_raster_type==NyARBufferType.INT1D_GRAY_8);\r
\r
}\r
/**\r
- * ２値化の閾値を設定する。\r
- * 暗点<=th<明点となります。\r
+ * コンストラクタです。\r
+ * 入力ラスタ形式={@link NyARBufferType#INT1D_GRAY_8},出力ラスタ形式={@link NyARBufferType#INT1D_BIN_8},\r
+ * 初期敷居値=0でインスタンスを生成します。\r
* @throws NyARException\r
*/\r
public NyARRasterFilter_ConstantThreshold() throws NyARException\r
this._threshold=0;\r
}\r
\r
- \r
+ /**\r
+ * この関数は、敷居値をセットします。\r
+ * @param i_threshold\r
+ * セットする敷居値。0以上、256未満である事。\r
+ */\r
public void setThreshold(int i_threshold)\r
{\r
this._threshold = i_threshold;\r
}\r
+ /**\r
+ * この関数は、固定敷居値で画像を２値化します。\r
+ * 現在の敷居値以下の画素が0になり、その他の画素は1になります。\r
+ */\r
public void doFilter(NyARGrayscaleRaster i_input, NyARBinRaster i_output) throws NyARException\r
{\r
assert(i_input.getBufferType()==NyARBufferType.INT1D_GRAY_8);\r
*/\r
public interface INyARRasterFilter_Rgb2Bin\r
{\r
+ /**\r
+ * この関数は、入力したRGBラスタを２値ラスタへ変換します。\r
+ * 実装クラスでは、i_inputのラスタを2値化した画像をi_outputへ出力する処理を書いてください。\r
+ * @param i_input\r
+ * 入力画像\r
+ * @param i_output\r
+ * 出力画像\r
+ * @throws NyARException\r
+ */\r
public void doFilter(INyARRgbRaster i_input, NyARBinRaster i_output) throws NyARException;\r
}\r
\r
\r
/**\r
- * 定数閾値による2値化をする。\r
- * \r
+ * この関数は、ARToolKit互換のアルゴリズムでRGBラスタを2値画像へ変換します。\r
+ * <p>ARToolKitのアルゴリズム -\r
+ * ARToolKitでは、敷居値thと、RGB成分 R,G,Bから、次の式で２値画素を求めます。\r
+ * <pre>A=th*3<(R+G+B)?0:1</pre>\r
+ * </p>\r
+ * <p>入力可能な画素形式\r
+ * 入力可能な画素形式は以下の通りです。\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#BYTE1D_B8G8R8_24}\r
+ * <li>{@link NyARBufferType#BYTE1D_R8G8B8_24}\r
+ * <li>{@link NyARBufferType#BYTE1D_B8G8R8X8_32}\r
+ * <li>{@link NyARBufferType#BYTE1D_X8R8G8B8_32}\r
+ * <li>{@link NyARBufferType#INT1D_X8R8G8B8_32}\r
+ * <li>{@link NyARBufferType#WORD1D_R5G6B5_16LE}\r
+ * </ul>\r
+ * </p>\r
+ * <p>出力可能な画素形式\r
+ * 出力可能な画素形式は1種類です。\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#INT1D_BIN_8}\r
+ * </ul>\r
+ * </p>\r
*/\r
public class NyARRasterFilter_ARToolkitThreshold implements INyARRasterFilter_Rgb2Bin\r
{\r
+ /** 敷居値*/\r
protected int _threshold;\r
private IdoThFilterImpl _do_threshold_impl;\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * 固定式位置の初期値、入力ラスタの画素形式を指定して、フィルタを作成します。\r
+ * 出力ラスタの形式は、{@link NyARBufferType#INT1D_BIN_8}を選択します。\r
+ * @param i_initial_threshold\r
+ * 敷居値の初期値です。0<n<256の値を指定します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの形式です。\r
+ * @throws NyARException\r
+ */\r
public NyARRasterFilter_ARToolkitThreshold(int i_threshold,int i_in_raster_type) throws NyARException\r
{\r
if(!initInstance(i_threshold,i_in_raster_type,NyARBufferType.INT1D_BIN_8)){\r
throw new NyARException();\r
}\r
}\r
+ /**\r
+ * コンストラクタです。\r
+ * 固定式位置の初期値、入力、出力ラスタの画素形式を指定して、フィルタを作成します。\r
+ * @param i_threshold\r
+ * 敷居値の初期値です。0<n<256の値を指定します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの形式です。\r
+ * @param i_out_raster_type\r
+ * 出力ラスタの形式です。\r
+ * @throws NyARException\r
+ */\r
public NyARRasterFilter_ARToolkitThreshold(int i_threshold,int i_in_raster_type,int i_out_raster_type) throws NyARException\r
{\r
if(!initInstance(i_threshold,i_in_raster_type,i_out_raster_type)){\r
throw new NyARException();\r
}\r
}\r
+ /**\r
+ * この関数は、クラスを初期化します。\r
+ * コンストラクタから呼び出します。\r
+ * @param i_threshold\r
+ * 敷居値の初期値です。0以上、256未満の数値を指定します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの画素形式を指定します。\r
+ * @param i_out_raster_type\r
+ * 出力ラスタの画素形式を指定します。\r
+ * @return\r
+ * 初期化に成功すると、trueを返します。\r
+ */\r
protected boolean initInstance(int i_threshold,int i_in_raster_type,int i_out_raster_type)\r
{\r
switch(i_out_raster_type){\r
} \r
\r
/**\r
- * 画像を２値化するための閾値。暗点<=th<明点となります。\r
+ * この関数は、敷居値を設定します。\r
+ * 0以上、256未満の数値を指定してください。\r
* @param i_threshold\r
+ * 設定する敷居値\r
*/\r
public void setThreshold(int i_threshold)\r
{\r
this._threshold = i_threshold;\r
}\r
-\r
+ /**\r
+ * この関数は、入力画像を２値化した画像を出力画像へ書込みます。\r
+ * 入力画像と出力画像のサイズは同じである必要があります。\r
+ */\r
public void doFilter(INyARRgbRaster i_input, NyARBinRaster i_output) throws NyARException\r
{\r
assert (i_input.getSize().isEqualSize(i_output.getSize()) == true);\r
this._do_threshold_impl.doThFilter(i_input,0,0,s.w,s.h,this._threshold,i_output);\r
return;\r
}\r
+ /**\r
+ * この関数は、入力画像の一部分だけを２値化して、出力画像の該当位置へ書込みます。\r
+ * 入力画像と出力画像のサイズは同じである必要があります。\r
+ * @param i_input\r
+ * 入力画像\r
+ * @param i_area\r
+ * ２値化する矩形範囲。入力画像の範囲内である必要があります。\r
+ * @param i_output\r
+ * 出力画像\r
+ * @throws NyARException\r
+ */\r
public void doFilter(INyARRgbRaster i_input,NyARIntRect i_area, NyARBinRaster i_output) throws NyARException\r
{\r
assert (i_input.getSize().isEqualSize(i_output.getSize()) == true);\r
}\r
\r
\r
-\r
+ /** フィルタ関数の定義*/\r
protected interface IdoThFilterImpl\r
{\r
public void doThFilter(INyARRaster i_raster,int i_l,int i_t,int i_w,int i_h,int i_th,INyARRaster o_raster);\r
}\r
\r
- class doThFilterImpl_BUFFERFORMAT_BYTE1D_RGB_24 implements IdoThFilterImpl\r
+ private class doThFilterImpl_BUFFERFORMAT_BYTE1D_RGB_24 implements IdoThFilterImpl\r
{\r
public void doThFilter(INyARRaster i_raster,int i_l,int i_t,int i_w,int i_h,int i_th,INyARRaster o_raster)\r
{\r
return; \r
}\r
}\r
- class doThFilterImpl_BUFFERFORMAT_INT1D_X8R8G8B8_32 implements IdoThFilterImpl\r
+ private class doThFilterImpl_BUFFERFORMAT_INT1D_X8R8G8B8_32 implements IdoThFilterImpl\r
{\r
public void doThFilter(INyARRaster i_raster,int i_l,int i_t,int i_w,int i_h,int i_th,INyARRaster o_raster)\r
{\r
\r
\r
\r
- class doThFilterImpl_BUFFERFORMAT_BYTE1D_B8G8R8X8_32 implements IdoThFilterImpl\r
+ private class doThFilterImpl_BUFFERFORMAT_BYTE1D_B8G8R8X8_32 implements IdoThFilterImpl\r
{\r
public void doThFilter(INyARRaster i_raster,int i_l,int i_t,int i_w,int i_h,int i_th,INyARRaster o_raster)\r
{\r
}\r
}\r
\r
- class doThFilterImpl_BUFFERFORMAT_BYTE1D_X8R8G8B8_32 implements IdoThFilterImpl\r
+ private class doThFilterImpl_BUFFERFORMAT_BYTE1D_X8R8G8B8_32 implements IdoThFilterImpl\r
{\r
public void doThFilter(INyARRaster i_raster,int i_l,int i_t,int i_w,int i_h,int i_th,INyARRaster o_raster)\r
{\r
}\r
}\r
\r
- class doThFilterImpl_BUFFERFORMAT_WORD1D_R5G6B5_16LE implements IdoThFilterImpl\r
+ private class doThFilterImpl_BUFFERFORMAT_WORD1D_R5G6B5_16LE implements IdoThFilterImpl\r
{\r
public void doThFilter(INyARRaster i_raster,int i_l,int i_t,int i_w,int i_h,int i_th,INyARRaster o_raster)\r
{\r
import jp.nyatla.nyartoolkit.core.raster.rgb.INyARRgbRaster;\r
\r
/**\r
- * このインタフェイスは、RGBラスタをグレースケールラスタに変換します。\r
+ * ã\81\93ã\81®ã\82¤ã\83³ã\82¿ã\83\95ã\82§ã\82¤ã\82¹ã\81¯ã\80\81RGBã\83©ã\82¹ã\82¿ã\82\92ã\82°ã\83¬ã\83¼ã\82¹ã\82±ã\83¼ã\83«ã\83©ã\82¹ã\82¿ã\81«å¤\89æ\8f\9bã\81\99ã\82\8bé\96¢æ\95°ã\82\92å®\9a義ã\81\97ã\81¾ã\81\99ã\80\82\r
*\r
*/\r
public interface INyARRasterFilter_Rgb2Gs\r
{\r
/**\r
- * 同一サイズのラスタi_inputとi_outputの間で、フィルタ処理を実行します。\r
+ * この関数は、入力画像をグレースケールにして出力画像へ書込みます。\r
+ * 実装クラスでは、RGB画像をグレースケール画像に変換する処理を書いてください。\r
* @param i_input\r
+ * 入力画像\r
* @param i_output\r
+ * 出力画像\r
* @throws NyARException\r
*/\r
public void doFilter(INyARRgbRaster i_input, NyARGrayscaleRaster i_output) throws NyARException;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
/**\r
- * RGBラスタをGrayScaleに変換するフィルタを作成します。\r
- * このフィルタは、RGB値の平均値を、(R+G+B)>>4で算出します。(スケールは、192>=n>=0になります。)\r
- *\r
+ * このクラスは、RGBラスタをGrayScaleに変換するフィルタを作成します。\r
+ * このクラスが出力するグレースケール値の範囲は、元画像の3/4（0-191）になります。\r
+ * <p>アルゴリズム\r
+ * このフィルタは、RGB値の平均値を、(R+G+B)>>4で算出します。(スケールは、191>=n>=0になります。)\r
+ * これは、低速な除算をシフトに置き換え、変換速度を向上させるためです。\r
+ * </p>\r
+ * <p>入力可能な画素形式\r
+ * 入力可能な画素形式は以下の通りです。\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#BYTE1D_B8G8R8_24}\r
+ * <li>{@link NyARBufferType#BYTE1D_R8G8B8_24}\r
+ * <li>{@link NyARBufferType#BYTE1D_B8G8R8X8_32}\r
+ * <li>{@link NyARBufferType#BYTE1D_X8R8G8B8_32}\r
+ * <li>{@link NyARBufferType#INT1D_X8R8G8B8_32}\r
+ * </ul>\r
+ * </p>\r
+ * <p>出力可能な画素形式\r
+ * 出力可能な画素形式は1種類です。\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#INT1D_GRAY_8}\r
+ * </ul>\r
+ * </p>\r
*/\r
public class NyARRasterFilter_Rgb2Gs_RgbAve192 implements INyARRasterFilter_Rgb2Gs\r
{\r
- IdoThFilterImpl _do_filter_impl;\r
+ /** 変換フィルタのインスタンス*/\r
+ protected IdoThFilterImpl _do_filter_impl;\r
+ /**\r
+ * コンストラクタです。\r
+ * 入力、出力ラスタの画素形式を指定して、フィルタを作成します。\r
+ * @param i_threshold\r
+ * 敷居値の初期値です。0<n<256の値を指定します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの形式です。\r
+ * @param i_out_raster_type\r
+ * 出力ラスタの形式です。\r
+ * @throws NyARException\r
+ */ \r
public NyARRasterFilter_Rgb2Gs_RgbAve192(int i_in_raster_type,int i_out_raster_type) throws NyARException\r
{\r
if(!initInstance(i_in_raster_type,i_out_raster_type))\r
throw new NyARException();\r
}\r
}\r
+ /**\r
+ * コンストラクタです。\r
+ * 入力ラスタの画素形式を指定して、フィルタを作成します。\r
+ * 出力ラスタの形式は、{@link NyARBufferType#INT1D_GRAY_8}を選択します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの形式です。\r
+ * @throws NyARException\r
+ */ \r
public NyARRasterFilter_Rgb2Gs_RgbAve192(int i_in_raster_type) throws NyARException\r
{\r
if(!initInstance(i_in_raster_type,NyARBufferType.INT1D_GRAY_8))\r
throw new NyARException();\r
}\r
}\r
+ /**\r
+ * この関数は、クラスを初期化します。\r
+ * コンストラクタから呼び出します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの画素形式を指定します。\r
+ * @param i_out_raster_type\r
+ * 出力ラスタの画素形式を指定します。\r
+ * @return\r
+ * 初期化に成功すると、trueを返します。\r
+ */\r
protected boolean initInstance(int i_in_raster_type,int i_out_raster_type)\r
{\r
switch(i_out_raster_type){\r
}\r
return true;\r
}\r
+ /**\r
+ * この関数は、入力画像をグレースケール化して出力画像へ書込みます。\r
+ * 入力画像と出力画像のサイズは同じである必要があります。\r
+ */ \r
public void doFilter(INyARRgbRaster i_input, NyARGrayscaleRaster i_output) throws NyARException\r
{\r
assert (i_input.getSize().isEqualSize(i_output.getSize()) == true);\r
return;\r
}\r
/**\r
- * 同一サイズのラスタi_inputとi_outputの間で、一部の領域だけにラスタ処理を実行します。\r
+ * この関数は、入力画像の一部分だけをグレースケール化して、出力画像の該当位置へ書込みます。\r
+ * 入力画像と出力画像のサイズは同じである必要があります。\r
* @param i_input\r
- * @param i_rect\r
+ * 入力画像\r
+ * @param i_area\r
+ * ２値化する矩形範囲。入力画像の範囲内である必要があります。\r
* @param i_output\r
+ * 出力画像\r
* @throws NyARException\r
*/\r
public void doFilter(INyARRgbRaster i_input,NyARIntRect i_rect, NyARGrayscaleRaster i_output) throws NyARException\r
this._do_filter_impl.doFilter(i_input,(int[])i_output.getBuffer(),i_rect.x,i_rect.y,i_rect.w,i_rect.h);\r
\r
}\r
+ \r
+ \r
+ \r
/**\r
- * 異サイズのラスタi_inputとi_outputの間で、一部の領域をi_outputへ転送します。\r
- * 関数は、i_outputのサイズをi_skip倍した領域を、i_inputのi_left,i_topの位置から切り出し、フィルタ処理をしてi_outputへ格納します。\r
+ * この関数は、入力画像の一部分をサンプリングしてからグレースケール化して、出力画像へ書込みます。\r
+ * 入力ラスタと出力ラスタのサイズは、以下の関係式を満たす必要があります。\r
+ * <ul>\r
+ * <li>入力画像の幅 =出力画像の幅*i_skip+i_top\r
+ * <li>入力画像の高さ=出力画像の幅*i_skip+i_left\r
+ * </ul>\r
* @param i_input\r
+ * 入力画像です。\r
* @param i_left\r
+ * 入力画像のサンプリング開始位置です。\r
* @param i_top\r
+ * 入力画像のサンプリング開始位置です。\r
* @param i_skip\r
+ * 入力画像のサンプリング値です。1ならば等倍、2なら2ドット,3なら3ドットおきに、画素をサンプリングします。\r
* @param i_output\r
+ * 出力画像です。\r
*/\r
public void doCutFilter(INyARRgbRaster i_input,int i_left,int i_top,int i_skip,NyARGrayscaleRaster i_output) throws NyARException\r
{\r
this._do_filter_impl.doCutFilter(i_input,i_left,i_top,i_skip,i_output); \r
}\r
- /*\r
- * ここから各種ラスタ向けのフィルタ実装\r
- *\r
- */\r
- interface IdoThFilterImpl\r
+\r
+ /** 変換関数のインタフェイス*/\r
+ protected interface IdoThFilterImpl\r
{\r
/**\r
* 同一サイズのラスタ間での転送\r
public void doCutFilter(INyARRaster i_input, int l,int t,int i_st,NyARGrayscaleRaster o_output) throws NyARException;\r
}\r
\r
- class doThFilterImpl_BUFFERFORMAT_INT1D_X8R8G8B8_32 implements IdoThFilterImpl\r
+ private class doThFilterImpl_BUFFERFORMAT_INT1D_X8R8G8B8_32 implements IdoThFilterImpl\r
{\r
public void doCutFilter(INyARRaster i_input, int l,int t,int i_st,NyARGrayscaleRaster o_output) throws NyARException\r
{\r
\r
\r
\r
- class doThFilterImpl_BYTE1D_B8G8R8_24 implements IdoThFilterImpl\r
+ private class doThFilterImpl_BYTE1D_B8G8R8_24 implements IdoThFilterImpl\r
{\r
public void doCutFilter(INyARRaster i_input, int l,int t,int i_st,NyARGrayscaleRaster o_output) throws NyARException\r
{\r
return;\r
} \r
}\r
- class doThFilterImpl_BYTE1D_B8G8R8X8_32 implements IdoThFilterImpl\r
+ private class doThFilterImpl_BYTE1D_B8G8R8X8_32 implements IdoThFilterImpl\r
{\r
public void doCutFilter(INyARRaster i_input, int l,int t,int i_st,NyARGrayscaleRaster o_output) throws NyARException\r
{\r
import jp.nyatla.nyartoolkit.core.types.NyARBufferType;\r
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
\r
-\r
/**\r
- * RGBラスタをGrayScaleに変換するフィルタを作成します。\r
- * このフィルタは、RGB値の平均値を、(R*G*B)/(255*255)で算出します。\r
- * \r
- * この値は、RGB成分の作る立方体の体積を0-255スケールにした値です。\r
- *\r
+ * このクラスは、RGBラスタをGrayScaleに変換するフィルタを作成します。\r
+ * <p>アルゴリズム\r
+ * このフィルタは、RGB値の平均値を、(R*G*B)/(255*255)で算出します。(スケールは、255>=n>=0になります。)\r
+ * 三乗根ではないことに注意してください。\r
+ * </p>\r
+ * <p>入力可能な画素形式\r
+ * 入力可能な画素形式は以下の通りです。\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#BYTE1D_B8G8R8_24}\r
+ * <li>{@link NyARBufferType#BYTE1D_R8G8B8_24}\r
+ * </ul>\r
+ * </p>\r
+ * <p>出力可能な画素形式\r
+ * 出力可能な画素形式は1種類です。\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#INT1D_GRAY_8}\r
+ * </ul>\r
+ * </p>\r
*/\r
public class NyARRasterFilter_Rgb2Gs_RgbCube implements INyARRasterFilter_Rgb2Gs\r
{\r
private IdoFilterImpl _dofilterimpl;\r
+ /**\r
+ * コンストラクタです。\r
+ * 入力ラスタの画素形式を指定して、フィルタを作成します。\r
+ * 出力ラスタの形式は、{@link NyARBufferType#INT1D_GRAY_8}を選択します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの形式です。\r
+ * @throws NyARException\r
+ */ \r
public NyARRasterFilter_Rgb2Gs_RgbCube(int i_in_raster_type) throws NyARException\r
{\r
if(!initInstance(i_in_raster_type,NyARBufferType.INT1D_GRAY_8))\r
throw new NyARException();\r
}\r
}\r
+ /**\r
+ * コンストラクタです。\r
+ * 入力、出力ラスタの画素形式を指定して、フィルタを作成します。\r
+ * @param i_threshold\r
+ * 敷居値の初期値です。0<n<256の値を指定します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの形式です。\r
+ * @param i_out_raster_type\r
+ * 出力ラスタの形式です。\r
+ * @throws NyARException\r
+ */ \r
public NyARRasterFilter_Rgb2Gs_RgbCube(int i_in_raster_type,int i_out_raster) throws NyARException\r
{\r
if(!initInstance(i_in_raster_type,i_out_raster))\r
{\r
throw new NyARException();\r
}\r
- } \r
+ }\r
+ /**\r
+ * この関数は、クラスを初期化します。\r
+ * コンストラクタから呼び出します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの画素形式を指定します。\r
+ * @param i_out_raster_type\r
+ * 出力ラスタの画素形式を指定します。\r
+ * @return\r
+ * 初期化に成功すると、trueを返します。\r
+ */ \r
protected boolean initInstance(int i_in_raster_type,int i_out_raster_type)\r
{\r
switch(i_out_raster_type){\r
return true;\r
} \r
\r
- \r
+ /**\r
+ * この関数は、入力画像をグレースケール化して出力画像へ書込みます。\r
+ * 入力画像と出力画像のサイズは同じである必要があります。\r
+ */ \r
public void doFilter(INyARRgbRaster i_input, NyARGrayscaleRaster i_output) throws NyARException\r
{\r
assert (i_input.getSize().isEqualSize(i_output.getSize()) == true);\r
this._dofilterimpl.doFilter(i_input,i_output,i_input.getSize());\r
}\r
\r
- interface IdoFilterImpl\r
+ /** 変換関数のインタフェイス*/\r
+ protected interface IdoFilterImpl\r
{\r
public void doFilter(INyARRaster i_input, INyARRaster i_output,NyARIntSize i_size) throws NyARException;\r
}\r
- class IdoFilterImpl_BYTE1D_B8G8R8_24 implements IdoFilterImpl\r
+ private class IdoFilterImpl_BYTE1D_B8G8R8_24 implements IdoFilterImpl\r
{\r
/**\r
* This function is not optimized.\r
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
\r
/**\r
- * YCbCr変換して、Y成分のグレースケールの値を計算します。\r
+ * このクラスは、RGBラスタをGrayScaleに変換するフィルタを作成します。\r
+ * <p>アルゴリズム\r
+ * このフィルタは、YCbCr変換して、Y成分のグレースケールの値を計算します。(スケールは、255>=n>=0になります。)\r
* 変換式は、http://www.tyre.gotdns.org/を参考にしました。\r
+ * </p>\r
+ * <p>入力可能な画素形式\r
+ * 入力可能な画素形式は以下の通りです。\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#BYTE1D_B8G8R8_24}\r
+ * </ul>\r
+ * </p>\r
+ * <p>出力可能な画素形式\r
+ * 出力可能な画素形式は1種類です。\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#INT1D_GRAY_8}\r
+ * </ul>\r
+ * </p>\r
*/\r
public class NyARRasterFilter_Rgb2Gs_YCbCr implements INyARRasterFilter_Rgb2Gs\r
{\r
private IdoFilterImpl _dofilterimpl;\r
+ /**\r
+ * コンストラクタです。\r
+ * 入力ラスタの画素形式を指定して、フィルタを作成します。\r
+ * 出力ラスタの形式は、{@link NyARBufferType#INT1D_GRAY_8}を選択します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの形式です。\r
+ * @throws NyARException\r
+ */ \r
public NyARRasterFilter_Rgb2Gs_YCbCr(int i_in_raster_type) throws NyARException\r
{\r
if(!initInstance(i_in_raster_type,NyARBufferType.INT1D_GRAY_8))\r
throw new NyARException();\r
}\r
}\r
+ /**\r
+ * コンストラクタです。\r
+ * 入力、出力ラスタの画素形式を指定して、フィルタを作成します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの形式です。\r
+ * @param i_out_raster_type\r
+ * 出力ラスタの形式です。\r
+ * @throws NyARException\r
+ */ \r
public NyARRasterFilter_Rgb2Gs_YCbCr(int i_in_raster_type,int i_out_raster) throws NyARException\r
{\r
if(!initInstance(i_in_raster_type,i_out_raster))\r
{\r
throw new NyARException();\r
}\r
- } \r
+ }\r
+ /**\r
+ * この関数は、クラスを初期化します。\r
+ * コンストラクタから呼び出します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの画素形式を指定します。\r
+ * @param i_out_raster_type\r
+ * 出力ラスタの画素形式を指定します。\r
+ * @return\r
+ * 初期化に成功すると、trueを返します。\r
+ */ \r
protected boolean initInstance(int i_in_raster_type,int i_out_raster_type)\r
{\r
switch(i_out_raster_type){\r
}\r
return true;\r
} \r
- \r
+ /**\r
+ * この関数は、クラスを初期化します。\r
+ * コンストラクタから呼び出します。\r
+ * @param i_in_raster_type\r
+ * 入力ラスタの画素形式を指定します。\r
+ * @param i_out_raster_type\r
+ * 出力ラスタの画素形式を指定します。\r
+ * @return\r
+ * 初期化に成功すると、trueを返します。\r
+ */ \r
public void doFilter(INyARRgbRaster i_input, NyARGrayscaleRaster i_output) throws NyARException\r
{\r
assert (i_input.getSize().isEqualSize(i_output.getSize()) == true);\r
this._dofilterimpl.doFilter(i_input,i_output,i_input.getSize());\r
}\r
- \r
- interface IdoFilterImpl\r
+ /** 変換関数のインタフェイス*/ \r
+ protected interface IdoFilterImpl\r
{\r
public void doFilter(INyARRaster i_input, INyARRaster i_output,NyARIntSize i_size) throws NyARException;\r
}\r
- class IdoFilterImpl_BYTE1D_B8G8R8_24 implements IdoFilterImpl\r
+ private class IdoFilterImpl_BYTE1D_B8G8R8_24 implements IdoFilterImpl\r
{\r
/**\r
* This function is not optimized.\r
import jp.nyatla.nyartoolkit.NyARException;\r
\r
/**\r
- * R8G8B8でピクセルを読み出すインタフェイス\r
- * \r
+ * このインタフェイスは、ラスタからRGBピクセル値を読みだす関数を定義します。\r
+ * {@link INyARRgbRaster}インタフェイスを実装したクラスで使うことを想定しています。\r
+ * RGBデータは、0から255までの範囲を持ちます。\r
*/\r
public interface INyARRgbPixelReader\r
{\r
/**\r
- * 1ピクセルをint配列にして返します。\r
- * \r
+ * この関数は、指定した座標の1ピクセル分のRGBデータを、配列に格納して返します。\r
+ * 実装クラスでは、バッファから指定した座標のRGB値を取得する処理を実装してください。\r
* @param i_x\r
+ * 取得するピクセルの座標。画像の範囲内である事。\r
* @param i_y\r
+ * 取得するピクセルの座標。画像の範囲内である事。\r
* @param i_rgb\r
+ * ピクセル値を返却する配列を指定します。3要素以上の配列が必要です。\r
+ * 値は、[R][G][B]の順に格納します。\r
+ * @throws NyARException\r
*/\r
public void getPixel(int i_x, int i_y, int[] i_rgb) throws NyARException;\r
-\r
/**\r
- * 複数のピクセル値をint配列に返します。\r
- * 配列には、[R1][G1][B1][R2][G2][B2]の順でピクセル値が格納されます。\r
- * \r
+ * この関数は、座標群から、ピクセルごとのRGBデータを、配列に格納して返します。\r
+ * 実装クラスでは、バッファから、座標軍のRGB値を取得する処理を実装してください。\r
* @param i_x\r
- * xのインデックス配列\r
+ * 取得するピクセルの座標配列。画像の範囲内である事。\r
* @param i_y\r
- * yのインデックス配列\r
+ * 取得するピクセルの座標配列。画像の範囲内である事。\r
+ * @param i_num\r
+ * 取得するピクセルの数を指定します。\r
+ * @param i_intrgb\r
+ * ピクセル値を返却する配列を指定します。3要素以上の配列が必要です。\r
+ * 値は、[R1][G1][B1][R2][G2][B2]の順に格納します。\r
+ * @throws NyARException\r
*/\r
public void getPixelSet(int[] i_x, int[] i_y, int i_num, int[] i_intrgb) throws NyARException;\r
/**\r
- * 1ピクセルを設定します。\r
+ * この関数は、RGBデータを指定した座標のピクセルにセットします。\r
+ * 実装クラスでは、バッファにRGB値を書込む処理を実装してください。\r
* @param i_x\r
+ * 書込むピクセルの座標。画像の範囲内である事。\r
* @param i_y\r
+ * 書込むピクセルの座標。画像の範囲内である事。\r
* @param i_r\r
+ * R成分のピクセル値。\r
* @param i_g\r
+ * G成分のピクセル値。\r
* @param i_b\r
+ * B成分のピクセル値。\r
* @throws NyARException\r
*/\r
public void setPixel(int i_x, int i_y, int i_r,int i_g,int i_b) throws NyARException;\r
\r
/**\r
- * 1ピクセルを設定します。\r
+ * この関数は、RGBデータを指定した座標のピクセルにセットします。\r
+ * 実装クラスでは、バッファにRGB値を書込む処理を実装してください。\r
* @param i_x\r
+ * 書込むピクセルの座標。画像の範囲内である事。\r
* @param i_y\r
+ * 書込むピクセルの座標。画像の範囲内である事。\r
* @param i_rgb\r
+ * 設定するピクセル値。3要素以上の配列が必要です。\r
+ * 値は、[R][G][B]の順に格納します。\r
* @throws NyARException\r
*/\r
public void setPixel(int i_x, int i_y, int[] i_rgb) throws NyARException;\r
/**\r
- * 複数のピクセル値をint配列から設定します。\r
+ * この関数は、座標群にピクセルごとのRGBデータをセットします。\r
+ * 実装クラスでは、バッファにRGB値を書込む処理を実装してください。\r
* @param i_x\r
+ * 取得するピクセルの座標配列。画像の範囲内である事。\r
* @param i_y\r
+ * 取得するピクセルの座標配列。画像の範囲内である事。\r
* @param i_num\r
+ * 設定するピクセルの数を指定します。\r
* @param i_intrgb\r
+ * 設定するピクセル値を格納する配列を指定します。3×i_num要素以上の配列が必要です。\r
+ * 値は、[R1][G1][B1][R2][G2][B2]の順に格納します。\r
* @throws NyARException\r
*/\r
public void setPixels(int[] i_x, int[] i_y, int i_num, int[] i_intrgb) throws NyARException;\r
/**\r
- * 参照しているバッファをi_ref_bufferへ切り替えます。\r
+ * この関数は、参照しているバッファをi_ref_bufferへ切り替えます。\r
+ * 通常は、このインスタンスを所有するクラスが使います。ユーザが使うことはありません。\r
* 内部パラメータのチェックは、実装依存です。\r
* @param i_ref_buffer\r
+ * 切り替えるバッファ\r
* @throws NyARException\r
*/\r
public void switchBuffer(Object i_ref_buffer) throws NyARException;\r
\r
\r
/**\r
- * 遠近法を使ったパースペクティブ補正をかけて、ラスタ上の四角形から\r
- * 任意解像度の矩形パターンを作成します。\r
- * \r
- * 出力ラスタ形式が、INT1D_X8R8G8B8_32の物については、単体サンプリングモードの時は高速化済み。マルチサンプリングモードのときは高速化なし。\r
- * 入力ラスタ形式がINT1D_X8R8G8B8_32,BYTE1D_B8G8R8_24,BYTE1D_R8G8B8_24については、高速化済み。\r
- * 他の形式のラスタでは、PixelReaderを介した低速転送で対応します。\r
+ * このクラスは、ラスタから任意四角形のパターンを取得します。\r
+ * パターンは、遠近法を使ったパースペクティブ補正をかけて、ラスタ矩形に得られます。\r
+ * <p>サンプリングモード -\r
+ * このクラスは、２種類のサンプリングモードがあります。単体サンプルモードと、マルチサンプルモードです。\r
+ * 単体サンプルモードは、{@link #read4Point}関数の解像度値に1を指定したときのモードです。出力1ピクセルに対して、入力1ピクセルを割り当てます。\r
+ * マルチサンプルモードは、{@link #read4Point}関数の解像度値に2以上を指定したときのモードです。出力1ピクセルに対して、入力nピクセルの平均値を割り当てます。\r
+ * 低解像度の出力を得る場合、マルチサンプルモードの方が良い結果が得られますが、単体サンプルモードと比較して低速になります。\r
+ * </p>\r
+ * <p>入力ラスタについて\r
+ * 基本的には全ての{@link INyARRgbRaster}を実装したクラスを処理できますが、次の３種類のバッファを持つものを推奨します。\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#INT1D_X8R8G8B8_32}\r
+ * <li>{@link NyARBufferType#BYTE1D_B8G8R8_24}\r
+ * <li>{@link NyARBufferType#BYTE1D_R8G8B8_24}\r
+ * </ul>\r
+ * </p>\r
+ * <p>出力ラスタについて\r
+ * 基本的には全ての{@link NyARBufferType.INT1D_X8R8G8B8_32}形式のバッファを持つラスタを使用してください。\r
+ * 他の形式でも動作しますが、低速な場合があります。\r
+ * </p>\r
+ * <p>高速化について - \r
+ * 入力ラスタ形式が、{@link NyARBufferType#INT1D_X8R8G8B8_32},{@link NyARBufferType#BYTE1D_B8G8R8_24)\r
+ * ,{@link NyARBufferType#BYTE1D_R8G8B8_24}のものについては、他の形式よりも高速に動作します。\r
+ * また、出力ラスタ形式が、{@link NyARBufferType#INT1D_X8R8G8B8_32}の物については、単体サンプリングモードの時のみ、さらに高速に動作します。\r
+ * 他の形式のラスタでは、以上のものよりも低速転送で対応します。\r
* <p>メモ-\r
* この関数は、1倍の時はNyARColorPatt_Perspective,\r
* n倍の時はNyARColorPatt_Perspective_O2の関数を元に作ってます。\r
* </p>\r
- *\r
*/\r
public class NyARPerspectiveRasterReader\r
{\r
+ /** 射影変換パラメータ生成器*/\r
protected NyARPerspectiveParamGenerator _perspective_gen;\r
private static final int LOCAL_LT=1;\r
+ /** 射影変換パラメータの記憶配列*/\r
protected final double[] __pickFromRaster_cpara=new double[8];\r
private IPickupRasterImpl _picker; \r
- \r
private void initializeInstance(int i_buffer_type)\r
{\r
//新しいモードに対応したら書いてね。\r
return; \r
}\r
/**\r
- * コンストラクタです。このコンストラクタで作成したインスタンスは、入力ラスタタイプに依存しませんが低速です。\r
- * 入力画像のラスタの形式が既知の場合は、もう一方のコンストラクタを使用してください。\r
+ * コンストラクタです。\r
+ * このコンストラクタで作成したインスタンスは、入力ラスタタイプに依存しませんが低速です。\r
+ * 入力画像の画素形式が既知の場合は、もう一方のコンストラクタを使用してください。\r
*/\r
public NyARPerspectiveRasterReader()\r
{\r
/**\r
* コンストラクタです。入力ラスタの形式を制限してインスタンスを作成します。\r
* @param i_input_raster_type\r
+ * {@link #read4Point}へ入力するラスタの画素形式。値については、クラスの説明を参照してください。\r
*/\r
public NyARPerspectiveRasterReader(int i_input_raster_type)\r
{\r
}\r
\r
/**\r
- * i_in_rasterから4頂点i_vertexsでかこまれた領域の画像を射影変換して、o_outへ格納します。\r
+ * この関数は、入力ラスタの4頂点(i_vertexs)でかこまれた領域の画像を射影変換して、o_outへ格納します。\r
* @param i_in_raster\r
- * このラスタの形式は、コンストラクタで制限したものと一致している必要があります。\r
+ * このラスタの形式は、コンストラクタで制限したものと一致している必要があります。(制限した場合のみ)\r
* @param i_vertex\r
* 4頂点を格納した配列です。\r
* @param i_edge_x\r
* @param o_out\r
* 出力先のラスタです。\r
* @return\r
+ * パターンの取得に成功すると、trueを返します。\r
* @throws NyARException\r
*/\r
public boolean read4Point(INyARRgbRaster i_in_raster,NyARDoublePoint2d[] i_vertex,int i_edge_x,int i_edge_y,int i_resolution,INyARRgbRaster o_out)throws NyARException\r
return true;\r
}\r
/**\r
- * read4Pointの入力型違いです。\r
- */ \r
+ * この関数は、入力ラスタの4頂点(i_vertexs)でかこまれた領域の画像を射影変換して、o_outへ格納します。\r
+ * 2番目の引数型だけが、{@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}と異なります。\r
+ * @param i_in_raster\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}を参照。\r
+ * @param i_vertex\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}を参照。\r
+ * @param i_edge_x\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}を参照。\r
+ * @param i_edge_y\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}を参照。\r
+ * @param i_resolution\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}を参照。\r
+ * @param o_out\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}を参照。\r
+ * @return\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}を参照。\r
+ * @throws NyARException\r
+ */\r
public boolean read4Point(INyARRgbRaster i_in_raster,NyARIntPoint2d[] i_vertex,int i_edge_x,int i_edge_y,int i_resolution,INyARRgbRaster o_out)throws NyARException\r
{\r
NyARIntSize out_size=o_out.getSize();\r
return true;\r
}\r
/**\r
- * read4Pointの入力型違いです。\r
- */ \r
+ * この関数は、入力ラスタの4頂点(i_vertexs)でかこまれた領域の画像を射影変換して、o_outへ格納します。\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}と比較して、\r
+ * 4頂点を直値で指定する違いがあります。\r
+ * @param i_in_raster\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}を参照。\r
+ * @param i_x1\r
+ * 1番目の頂点の座標\r
+ * @param i_y1\r
+ * 1番目の頂点の座標\r
+ * @param i_x2\r
+ * 2番目の頂点の座標\r
+ * @param i_y2\r
+ * 2番目の頂点の座標\r
+ * @param i_x3\r
+ * 3番目の頂点の座標\r
+ * @param i_y3\r
+ * 3番目の頂点の座標\r
+ * @param i_x4\r
+ * 4番目の頂点の座標\r
+ * @param i_y4\r
+ * 4番目の頂点の座標\r
+ * @param i_edge_x\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}を参照。\r
+ * @param i_edge_y\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}を参照。\r
+ * @param i_resolution\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}を参照。\r
+ * @param o_out\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}を参照。\r
+ * @return\r
+ * {@link #read4Point(INyARRgbRaster, NyARDoublePoint2d[], int, int, int, INyARRgbRaster)}を参照。\r
+ * @throws NyARException\r
+ */\r
public boolean read4Point(INyARRgbRaster i_in_raster,double i_x1,double i_y1,double i_x2,double i_y2,double i_x3,double i_y3,double i_x4,double i_y4,int i_edge_x,int i_edge_y,int i_resolution,INyARRgbRaster o_out)throws NyARException\r
{\r
NyARIntSize out_size=o_out.getSize();\r
//ここから先は入力画像毎のラスタドライバ\r
//\r
\r
+/** 画素形式毎のドライバ定義*/\r
interface IPickupRasterImpl\r
{\r
public void onePixel(int pk_l,int pk_t,double[] cpara,INyARRgbRaster i_in_raster,INyARRgbRaster o_out)throws NyARException;\r
public void multiPixel(int pk_l,int pk_t,double[] cpara,int i_resolution,INyARRgbRaster i_in_raster,INyARRgbRaster o_out)throws NyARException;\r
}\r
\r
+/** BYTE1D_R8G8B8_24形式のドライバ*/\r
final class PPickup_Impl_BYTE1D_R8G8B8_24 implements IPickupRasterImpl\r
{\r
public void onePixel(int pk_l,int pk_t,double[] cpara,INyARRgbRaster i_in_raster,INyARRgbRaster o_out)throws NyARException\r
\r
\r
\r
-\r
+/** BYTE1D_B8G8R8_24形式のドライバ*/\r
final class PPickup_Impl_BYTE1D_B8G8R8_24 implements IPickupRasterImpl\r
{\r
public void onePixel(int pk_l,int pk_t,double[] cpara,INyARRgbRaster i_in_raster,INyARRgbRaster o_out)throws NyARException\r
\r
\r
\r
-\r
+/** BYTE1D_B8G8R8X8_32形式のドライバ*/\r
final class PPickup_Impl_BYTE1D_B8G8R8X8_32 implements IPickupRasterImpl\r
{\r
public void onePixel(int pk_l,int pk_t,double[] cpara,INyARRgbRaster i_in_raster,INyARRgbRaster o_out)throws NyARException\r
package jp.nyatla.nyartoolkit.core.rasterreader;\r
\r
import jp.nyatla.nyartoolkit.NyARException;\r
+import jp.nyatla.nyartoolkit.core.types.NyARBufferType;\r
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
\r
+/**\r
+ * このクラスは、{@link NyARBufferType#BYTE1D_B8G8R8X8_32}形式のラスタバッファに対応する、ピクセルリーダです。\r
+ */\r
final public class NyARRgbPixelReader_BYTE1D_B8G8R8X8_32 implements INyARRgbPixelReader\r
{\r
+ /** 参照する外部バッファ*/\r
protected byte[] _ref_buf;\r
private NyARIntSize _ref_size;\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * 参照するラスタのバッファとサイズを指定して、インスタンスを作成します。\r
+ * @param i_buf\r
+ * ラスタのバッファオブジェクトの参照値\r
+ * @param i_size\r
+ * ラスタのサイズオブジェクトの参照値。\r
+ */\r
public NyARRgbPixelReader_BYTE1D_B8G8R8X8_32(byte[] i_ref_buf, NyARIntSize i_size)\r
{\r
this._ref_buf=i_ref_buf;\r
this._ref_size = i_size;\r
}\r
-\r
+ /**\r
+ * この関数は、指定した座標の1ピクセル分のRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixel(int i_x, int i_y, int[] o_rgb)\r
{\r
final byte[] ref_buf =this._ref_buf;\r
o_rgb[2] = (ref_buf[bp + 0] & 0xff);// B\r
return;\r
}\r
-\r
+ /**\r
+ * この関数は、座標群から、ピクセルごとのRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixelSet(int[] i_x, int[] i_y, int i_num, int[] o_rgb)\r
{\r
int bp;\r
}\r
return;\r
}\r
+ /**\r
+ * この関数は、RGBデータを指定した座標のピクセルにセットします。\r
+ */\r
public void setPixel(int i_x, int i_y, int[] i_rgb) throws NyARException\r
{\r
final byte[] ref_buf =this._ref_buf;\r
ref_buf[bp+1] = (byte)i_rgb[1];// G\r
ref_buf[bp+0] = (byte)i_rgb[2];// B \r
}\r
+ /**\r
+ * この関数は、RGBデータを指定した座標のピクセルにセットします。\r
+ */\r
public void setPixel(int i_x, int i_y, int i_r,int i_g,int i_b) throws NyARException\r
{\r
final byte[] ref_buf =this._ref_buf;\r
ref_buf[bp+1] = (byte)i_g;// G\r
ref_buf[bp+0] = (byte)i_b;// B \r
}\r
- \r
+ /**\r
+ * この関数は、機能しません。\r
+ */ \r
public void setPixels(int[] i_x, int[] i_y, int i_num, int[] i_intrgb) throws NyARException\r
{\r
NyARException.notImplement(); \r
}\r
+ /**\r
+ * この関数は、参照しているバッファをi_ref_bufferへ切り替えます。\r
+ * 通常は、このインスタンスを所有するクラスが使います。ユーザが使うことはありません。\r
+ * 関数は、入力値のバッファサイズと、型だけを確認します。\r
+ */ \r
public void switchBuffer(Object i_ref_buffer) throws NyARException\r
{\r
assert(((byte[])i_ref_buffer).length>=this._ref_size.w*this._ref_size.h*4);\r
\r
import jp.nyatla.nyartoolkit.NyARException;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
+\r
/**\r
- * byte[]配列に、パディング無しの8bit画素値が、BGRBGRの順で並んでいる\r
- * バッファに使用できるピクセルリーダー\r
- *\r
+ * このクラスは、{@link NyARBufferType#BYTE1D_B8G8R8_24}形式のラスタバッファに対応する、ピクセルリーダです。\r
*/\r
final public class NyARRgbPixelReader_BYTE1D_B8G8R8_24 implements INyARRgbPixelReader\r
{\r
+ /** 参照する外部バッファ*/\r
protected byte[] _ref_buf;\r
\r
private NyARIntSize _size;\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * 参照するラスタのバッファとサイズを指定して、インスタンスを作成します。\r
+ * @param i_buf\r
+ * ラスタのバッファオブジェクトの参照値\r
+ * @param i_size\r
+ * ラスタのサイズオブジェクトの参照値。\r
+ */\r
public NyARRgbPixelReader_BYTE1D_B8G8R8_24(byte[] i_buf, NyARIntSize i_size)\r
{\r
this._ref_buf = i_buf;\r
this._size = i_size;\r
}\r
-\r
+ /**\r
+ * この関数は、指定した座標の1ピクセル分のRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixel(int i_x, int i_y, int[] o_rgb)\r
{\r
final byte[] ref_buf = this._ref_buf;\r
o_rgb[2] = (ref_buf[bp + 0] & 0xff);// B\r
return;\r
}\r
-\r
+ /**\r
+ * この関数は、座標群から、ピクセルごとのRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixelSet(int[] i_x, int[] i_y, int i_num, int[] o_rgb)\r
{\r
int bp;\r
}\r
return;\r
}\r
+ /**\r
+ * この関数は、RGBデータを指定した座標のピクセルにセットします。\r
+ */\r
public void setPixel(int i_x, int i_y, int[] i_rgb) throws NyARException\r
{\r
final byte[] ref_buf = this._ref_buf;\r
ref_buf[idx + 1] = (byte)i_rgb[1];// G\r
ref_buf[idx + 2] = (byte)i_rgb[0];// R\r
}\r
+ /**\r
+ * この関数は、RGBデータを指定した座標のピクセルにセットします。\r
+ */\r
public void setPixel(int i_x, int i_y, int i_r,int i_g,int i_b) throws NyARException\r
{\r
final byte[] ref_buf = this._ref_buf;\r
ref_buf[idx + 1] = (byte)i_g;// G\r
ref_buf[idx + 2] = (byte)i_r;// R\r
}\r
+ /**\r
+ * この関数は、機能しません。\r
+ */\r
public void setPixels(int[] i_x, int[] i_y, int i_num, int[] i_intrgb) throws NyARException\r
{\r
NyARException.notImplement(); \r
}\r
+ /**\r
+ * この関数は、参照しているバッファをi_ref_bufferへ切り替えます。\r
+ * 通常は、このインスタンスを所有するクラスが使います。ユーザが使うことはありません。\r
+ * 関数は、入力値のバッファサイズと、型だけを確認します。\r
+ */\r
public void switchBuffer(Object i_ref_buffer) throws NyARException\r
{\r
assert(((byte[])i_ref_buffer).length>=this._size.w*this._size.h*3);\r
import jp.nyatla.nyartoolkit.NyARException;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
/**\r
- * byte[]配列に、パディング無しの8bit画素値が、RGBRGBの順で並んでいる\r
- * バッファに使用できるピクセルリーダー\r
- *\r
+ * このクラスは、{@link NyARBufferType#BYTE1D_R8G8B8_24}形式のラスタバッファに対応する、ピクセルリーダです。\r
*/\r
final public class NyARRgbPixelReader_BYTE1D_R8G8B8_24 implements INyARRgbPixelReader\r
{\r
+ /** 参照する外部バッファ*/\r
protected byte[] _ref_buf;\r
\r
private NyARIntSize _size;\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * 参照するラスタのバッファとサイズを指定して、インスタンスを作成します。\r
+ * @param i_buf\r
+ * ラスタのバッファオブジェクトの参照値\r
+ * @param i_size\r
+ * ラスタのサイズオブジェクトの参照値。\r
+ */\r
public NyARRgbPixelReader_BYTE1D_R8G8B8_24(byte[] i_buf, NyARIntSize i_size)\r
{\r
this._ref_buf = i_buf;\r
this._size = i_size;\r
}\r
-\r
+ /**\r
+ * この関数は、指定した座標の1ピクセル分のRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixel(int i_x, int i_y, int[] o_rgb)\r
{\r
final byte[] ref_buf = this._ref_buf;\r
o_rgb[2] = (ref_buf[bp + 2] & 0xff);// B\r
return;\r
}\r
-\r
+ /**\r
+ * この関数は、座標群から、ピクセルごとのRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixelSet(int[] i_x, int[] i_y, int i_num, int[] o_rgb)\r
{\r
int bp;\r
}\r
return;\r
}\r
+ /**\r
+ * この関数は、RGBデータを指定した座標のピクセルにセットします。\r
+ */\r
public void setPixel(int i_x, int i_y, int[] i_rgb) throws NyARException\r
{\r
final byte[] ref_buf = this._ref_buf;\r
ref_buf[idx + 1] = (byte)i_rgb[1];// G\r
ref_buf[idx + 2] = (byte)i_rgb[2];// B\r
}\r
+ /**\r
+ * この関数は、RGBデータを指定した座標のピクセルにセットします。\r
+ */\r
public void setPixel(int i_x, int i_y, int i_r,int i_g,int i_b) throws NyARException\r
{\r
final byte[] ref_buf = this._ref_buf;\r
ref_buf[idx + 1] = (byte)i_g;// G\r
ref_buf[idx + 2] = (byte)i_b;// B\r
}\r
+ /**\r
+ * この関数は、機能しません。\r
+ */ \r
public void setPixels(int[] i_x, int[] i_y, int i_num, int[] i_intrgb) throws NyARException\r
{\r
NyARException.notImplement(); \r
}\r
+ /**\r
+ * この関数は、参照しているバッファをi_ref_bufferへ切り替えます。\r
+ * 通常は、このインスタンスを所有するクラスが使います。ユーザが使うことはありません。\r
+ * 関数は、入力値のバッファサイズと、型だけを確認します。\r
+ */ \r
public void switchBuffer(Object i_ref_buffer) throws NyARException\r
{\r
assert(((byte[])i_ref_buffer).length>=this._size.w*this._size.h*3);\r
import jp.nyatla.nyartoolkit.NyARException;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
/**\r
- * byte[]配列に、パディング無しの8bit画素値が、XRGBXRGBの順で並んでいる\r
- * バッファに使用できるピクセルリーダー\r
- *\r
+ * このクラスは、{@link NyARBufferType#BYTE1D_X8R8G8B8_32}形式のラスタバッファに対応する、ピクセルリーダです。\r
*/\r
final public class NyARRgbPixelReader_BYTE1D_X8R8G8B8_32 implements INyARRgbPixelReader\r
{\r
+ /** 参照する外部バッファ*/\r
protected byte[] _ref_buf;\r
\r
private NyARIntSize _size;\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * 参照するラスタのバッファとサイズを指定して、インスタンスを作成します。\r
+ * @param i_buf\r
+ * ラスタのバッファオブジェクトの参照値\r
+ * @param i_size\r
+ * ラスタのサイズオブジェクトの参照値。\r
+ */\r
public NyARRgbPixelReader_BYTE1D_X8R8G8B8_32(byte[] i_buf, NyARIntSize i_size)\r
{\r
this._ref_buf = i_buf;\r
this._size = i_size;\r
}\r
-\r
+ /**\r
+ * この関数は、指定した座標の1ピクセル分のRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixel(int i_x, int i_y, int[] o_rgb)\r
{\r
final byte[] ref_buf = this._ref_buf;\r
o_rgb[2] = (ref_buf[bp + 3] & 0xff);// B\r
return;\r
}\r
-\r
+ /**\r
+ * この関数は、座標群から、ピクセルごとのRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixelSet(int[] i_x, int[] i_y, int i_num, int[] o_rgb)\r
{\r
int bp;\r
}\r
return;\r
}\r
+ /**\r
+ * この関数は、機能しません。\r
+ */ \r
public void setPixel(int i_x, int i_y, int[] i_rgb) throws NyARException\r
{\r
NyARException.notImplement(); \r
}\r
+ /**\r
+ * この関数は、機能しません。\r
+ */ \r
public void setPixel(int i_x, int i_y, int i_r,int i_g,int i_b) throws NyARException\r
{\r
NyARException.notImplement(); \r
}\r
+ /**\r
+ * この関数は、機能しません。\r
+ */ \r
public void setPixels(int[] i_x, int[] i_y, int i_num, int[] i_intrgb) throws NyARException\r
{\r
NyARException.notImplement(); \r
}\r
+ /**\r
+ * この関数は、参照しているバッファをi_ref_bufferへ切り替えます。\r
+ * 通常は、このインスタンスを所有するクラスが使います。ユーザが使うことはありません。\r
+ * 関数は、入力値のバッファサイズと、型だけを確認します。\r
+ */ \r
public void switchBuffer(Object i_ref_buffer) throws NyARException\r
{\r
assert(((byte[])i_ref_buffer).length>=this._size.w*this._size.h*4);\r
package jp.nyatla.nyartoolkit.core.rasterreader;\r
\r
import jp.nyatla.nyartoolkit.NyARException;\r
+import jp.nyatla.nyartoolkit.core.types.NyARBufferType;\r
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
-\r
+/**\r
+ * このクラスは、{@link NyARBufferType#INT1D_GRAY_8}形式のラスタバッファに対応する、ピクセルリーダです。\r
+ */\r
final public class NyARRgbPixelReader_INT1D_GRAY_8 implements INyARRgbPixelReader\r
{\r
+ /** 参照する外部バッファ*/\r
protected int[] _ref_buf;\r
\r
private NyARIntSize _size;\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * 参照するラスタのバッファとサイズを指定して、インスタンスを作成します。\r
+ * @param i_buf\r
+ * ラスタのバッファオブジェクトの参照値\r
+ * @param i_size\r
+ * ラスタのサイズオブジェクトの参照値。\r
+ */\r
public NyARRgbPixelReader_INT1D_GRAY_8(int[] i_buf, NyARIntSize i_size)\r
{\r
this._ref_buf = i_buf;\r
this._size = i_size;\r
}\r
-\r
+ /**\r
+ * この関数は、指定した座標の1ピクセル分のRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixel(int i_x, int i_y, int[] o_rgb)\r
{\r
o_rgb[0] = o_rgb[1]=o_rgb[2]=this._ref_buf[i_x + i_y * this._size.w];\r
return;\r
}\r
-\r
+ /**\r
+ * この関数は、座標群から、ピクセルごとのRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixelSet(int[] i_x, int[] i_y, int i_num, int[] o_rgb)\r
{\r
final int width = this._size.w;\r
}\r
return;\r
}\r
+ /**\r
+ * この関数は、機能しません。\r
+ */\r
public void setPixel(int i_x, int i_y, int[] i_rgb) throws NyARException\r
{\r
NyARException.notImplement(); \r
}\r
+ /**\r
+ * この関数は、機能しません。\r
+ */\r
public void setPixel(int i_x, int i_y, int i_r,int i_g,int i_b) throws NyARException\r
{\r
NyARException.notImplement(); \r
}\r
+ /**\r
+ * この関数は、機能しません。\r
+ */\r
public void setPixels(int[] i_x, int[] i_y, int i_num, int[] i_intrgb) throws NyARException\r
{\r
NyARException.notImplement(); \r
}\r
+ /**\r
+ * この関数は、参照しているバッファをi_ref_bufferへ切り替えます。\r
+ * 通常は、このインスタンスを所有するクラスが使います。ユーザが使うことはありません。\r
+ * 関数は、入力値のバッファサイズと、型だけを確認します。\r
+ */ \r
public void switchBuffer(Object i_ref_buffer) throws NyARException\r
{\r
assert(((int[])i_ref_buffer).length>=this._size.w*this._size.h);\r
package jp.nyatla.nyartoolkit.core.rasterreader;\r
\r
import jp.nyatla.nyartoolkit.NyARException;\r
+import jp.nyatla.nyartoolkit.core.types.NyARBufferType;\r
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
-\r
+/**\r
+ * このクラスは、{@link NyARBufferType#INT1D_X8R8G8B8_32}形式のラスタバッファに対応する、ピクセルリーダです。\r
+ */\r
final public class NyARRgbPixelReader_INT1D_X8R8G8B8_32 implements INyARRgbPixelReader\r
{\r
+ /** 参照する外部バッファ*/\r
protected int[] _ref_buf;\r
\r
private NyARIntSize _size;\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * 参照するラスタのバッファとサイズを指定して、インスタンスを作成します。\r
+ * @param i_buf\r
+ * ラスタのバッファオブジェクトの参照値\r
+ * @param i_size\r
+ * ラスタのサイズオブジェクトの参照値。\r
+ */\r
public NyARRgbPixelReader_INT1D_X8R8G8B8_32(int[] i_buf, NyARIntSize i_size)\r
{\r
this._ref_buf = i_buf;\r
this._size = i_size;\r
}\r
-\r
+ /**\r
+ * この関数は、指定した座標の1ピクセル分のRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixel(int i_x, int i_y, int[] o_rgb)\r
{\r
final int rgb= this._ref_buf[i_x + i_y * this._size.w];\r
o_rgb[2] = rgb&0xff;// B\r
return;\r
}\r
-\r
+ /**\r
+ * この関数は、座標群から、ピクセルごとのRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixelSet(int[] i_x, int[] i_y, int i_num, int[] o_rgb)\r
{\r
final int width = this._size.w;\r
}\r
return;\r
}\r
+ /**\r
+ * この関数は、RGBデータを指定した座標のピクセルにセットします。\r
+ */ \r
public void setPixel(int i_x, int i_y, int[] i_rgb) throws NyARException\r
{\r
this._ref_buf[i_x + i_y * this._size.w]=(i_rgb[0]<<16)|(i_rgb[1]<<8)|(i_rgb[2]);\r
}\r
+ /**\r
+ * この関数は、RGBデータを指定した座標のピクセルにセットします。\r
+ */ \r
public void setPixel(int i_x, int i_y, int i_r,int i_g,int i_b) throws NyARException\r
{\r
this._ref_buf[i_x + i_y * this._size.w]=(i_r<<16)|(i_g<<8)|(i_b);\r
}\r
- \r
+ /**\r
+ * この関数は、機能しません。\r
+ */\r
public void setPixels(int[] i_x, int[] i_y, int i_num, int[] i_intrgb) throws NyARException\r
{\r
NyARException.notImplement(); \r
}\r
+ /**\r
+ * この関数は、参照しているバッファをi_ref_bufferへ切り替えます。\r
+ * 通常は、このインスタンスを所有するクラスが使います。ユーザが使うことはありません。\r
+ * 関数は、入力値のバッファサイズと、型だけを確認します。\r
+ */ \r
public void switchBuffer(Object i_ref_buffer) throws NyARException\r
{\r
assert(((int[])i_ref_buffer).length>=this._size.w*this._size.h);\r
import jp.nyatla.nyartoolkit.NyARException;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
/**\r
- * 主にWindowsMobileのRGB565フォーマット読み出し用\r
+ * このクラスは、{@link NyARBufferType#WORD1D_R5G6B5_16LE}形式のラスタバッファに対応する、ピクセルリーダです。\r
+ * この形式は、WindowsMobile等のモバイルデバイスで使われる形式です。\r
*/\r
final public class NyARRgbPixelReader_WORD1D_R5G6B5_16LE implements INyARRgbPixelReader\r
{\r
+ /** 参照する外部バッファ*/\r
protected short[] _ref_buf;\r
\r
private NyARIntSize _size;\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * 参照するラスタのバッファとサイズを指定して、インスタンスを作成します。\r
+ * @param i_buf\r
+ * ラスタのバッファオブジェクトの参照値\r
+ * @param i_size\r
+ * ラスタのサイズオブジェクトの参照値。\r
+ */\r
public NyARRgbPixelReader_WORD1D_R5G6B5_16LE(short[] i_buf, NyARIntSize i_size)\r
{\r
this._ref_buf = i_buf;\r
this._size = i_size;\r
}\r
-\r
+ /**\r
+ * この関数は、指定した座標の1ピクセル分のRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixel(int i_x, int i_y, int[] o_rgb)\r
{\r
short[] buf = this._ref_buf;\r
o_rgb[2] = (int)((pixcel & 0x001f) << 3);//B\r
return;\r
}\r
-\r
+ /**\r
+ * この関数は、座標群から、ピクセルごとのRGBデータを、配列に格納して返します。\r
+ */\r
public void getPixelSet(int[] i_x, int[] i_y, int i_num, int[] o_rgb)\r
{\r
int stride = this._size.w;\r
} \r
return;\r
}\r
+ /**\r
+ * この関数は、機能しません。\r
+ */\r
public void setPixel(int i_x, int i_y, int[] i_rgb) throws NyARException\r
{\r
NyARException.notImplement(); \r
}\r
+ /**\r
+ * この関数は、機能しません。\r
+ */\r
public void setPixel(int i_x, int i_y, int i_r,int i_g,int i_b) throws NyARException\r
{\r
NyARException.notImplement(); \r
}\r
- \r
+ /**\r
+ * この関数は、機能しません。\r
+ */\r
public void setPixels(int[] i_x, int[] i_y, int i_num, int[] i_intrgb) throws NyARException\r
{\r
NyARException.notImplement(); \r
}\r
+ /**\r
+ * この関数は、参照しているバッファをi_ref_bufferへ切り替えます。\r
+ * 通常は、このインスタンスを所有するクラスが使います。ユーザが使うことはありません。\r
+ * 関数は、入力値のバッファサイズと、型だけを確認します。\r
+ */ \r
public void switchBuffer(Object i_ref_buffer) throws NyARException\r
{\r
assert(((short[])i_ref_buffer).length>=this._size.w*this._size.h);\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
/**\r
- * 輪郭線を取得するクラスです。\r
- *\r
+ * このクラスは、輪郭線の抽出クラスです。\r
+ * 画像中の１点を開始点として、８方位探索で輪郭線を抽出します。出力は輪郭点の配列です。\r
+ * <p>入力できる画素フォーマット - {@link #getContour}に入力できる画素フォーマットに制限があります。<br/>\r
+ * {@link NyARBinRaster}\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#INT1D_BIN_8}\r
+ * </ul>\r
+ * {@link NyARGrayscaleRaster}\r
+ * <ul>\r
+ * <li>{@link NyARBufferType#INT1D_GRAY_8}\r
+ * </ul>\r
+ * </p>\r
*/\r
public class NyARContourPickup\r
{\r
//巡回参照できるように、テーブルを二重化\r
// 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6\r
+ /** 8方位探索の座標マップ*/\r
protected final static int[] _getContour_xdir = { 0, 1, 1, 1, 0,-1,-1,-1 , 0, 1, 1, 1, 0,-1,-1};\r
+ /** 8方位探索の座標マップ*/\r
protected final static int[] _getContour_ydir = {-1,-1, 0, 1, 1, 1, 0,-1 ,-1,-1, 0, 1, 1, 1, 0};\r
+\r
+ /**\r
+ * この関数は、ラスタの指定点を基点に、輪郭線を抽出します。\r
+ * 開始点は、輪郭の一部である必要があります。\r
+ * 通常は、ラべリングの結果の上辺クリップとX軸エントリポイントを開始点として入力します。\r
+ * @param i_raster\r
+ * 輪郭線を抽出するラスタを指定します。\r
+ * @param i_entry_x\r
+ * 輪郭抽出の開始点です。\r
+ * @param i_entry_y\r
+ * 輪郭抽出の開始点です。\r
+ * @param o_coord\r
+ * 輪郭点を格納するオブジェクトを指定します。\r
+ * @return\r
+ * 輪郭線がo_coordの長さを超えた場合、falseを返します。\r
+ * @throws NyARException\r
+ */\r
public boolean getContour(NyARBinRaster i_raster,int i_entry_x,int i_entry_y,NyARIntCoordinates o_coord) throws NyARException\r
{\r
assert(i_raster.isEqualBufferType(NyARBufferType.INT1D_BIN_8));\r
NyARIntSize s=i_raster.getSize();\r
return impl_getContour(i_raster,0,0,s.w-1,s.h-1,0,i_entry_x,i_entry_y,o_coord);\r
}\r
+ /**\r
+ * この関数は、ラスタの指定点を基点に、画像の特定の範囲内から輪郭線を抽出します。\r
+ * 開始点は、輪郭の一部である必要があります。\r
+ * 通常は、ラべリングの結果の上辺クリップとX軸エントリポイントを開始点として入力します。\r
+ * @param i_raster\r
+ * 輪郭線を抽出するラスタを指定します。\r
+ * @param i_area\r
+ * 輪郭線の抽出範囲を指定する矩形。i_rasterのサイズ内である必要があります。\r
+ * @param i_entry_x\r
+ * 輪郭抽出の開始点です。\r
+ * @param i_entry_y\r
+ * 輪郭抽出の開始点です。\r
+ * @param o_coord\r
+ * 輪郭点を格納するオブジェクトを指定します。\r
+ * @return\r
+ * 輪郭線がo_coordの長さを超えた場合、falseを返します。\r
+ * @throws NyARException\r
+ */ \r
public boolean getContour(NyARBinRaster i_raster,NyARIntRect i_area,int i_entry_x,int i_entry_y,NyARIntCoordinates o_coord) throws NyARException\r
{\r
assert(i_raster.isEqualBufferType(NyARBufferType.INT1D_BIN_8));\r
return impl_getContour(i_raster,i_area.x,i_area.y,i_area.x+i_area.w-1,i_area.h+i_area.y-1,0,i_entry_x,i_entry_y,o_coord);\r
}\r
/**\r
- * ラスタの指定点を基点に、輪郭線を抽出します。開始点は、輪郭の一部、かつ左上のエッジで有る必要があります。\r
+ * この関数は、ラスタの指定点を基点に、輪郭線を抽出します。\r
+ * 開始点は、輪郭の一部である必要があります。\r
+ * 通常は、ラべリングの結果の上辺クリップとX軸エントリポイントを開始点として入力します。\r
* @param i_raster\r
* 輪郭線を抽出するラスタを指定します。\r
* @param i_th\r
NyARIntSize s=i_raster.getSize();\r
return impl_getContour(i_raster,0,0,s.w-1,s.h-1,i_th,i_entry_x,i_entry_y,o_coord);\r
}\r
+ /**\r
+ * この関数は、ラスタの指定点を基点に、画像の特定の範囲内から輪郭線を抽出します。\r
+ * 開始点は、輪郭の一部である必要があります。\r
+ * 通常は、ラべリングの結果の上辺クリップとX軸エントリポイントを開始点として入力します。\r
+ * @param i_raster\r
+ * 輪郭線を抽出するラスタを指定します。\r
+ * @param i_area\r
+ * 輪郭線の抽出範囲を指定する矩形。i_rasterのサイズ内である必要があります。\r
+ * @param i_th\r
+ * 輪郭とみなす暗点の敷居値を指定します。\r
+ * @param i_entry_x\r
+ * 輪郭抽出の開始点です。\r
+ * @param i_entry_y\r
+ * 輪郭抽出の開始点です。\r
+ * @param o_coord\r
+ * 輪郭点を格納するオブジェクトを指定します。\r
+ * @return\r
+ * 輪郭線がo_coordの長さを超えた場合、falseを返します。\r
+ * @throws NyARException\r
+ */\r
public boolean getContour(NyARGrayscaleRaster i_raster,NyARIntRect i_area,int i_th,int i_entry_x,int i_entry_y,NyARIntCoordinates o_coord) throws NyARException\r
{\r
assert(i_raster.isEqualBufferType(NyARBufferType.INT1D_GRAY_8));\r
import jp.nyatla.nyartoolkit.core.types.NyARIntPoint2d;\r
\r
/**\r
- * NyARLabelingImageから、輪郭線を抽出します。\r
- * @bug\r
- * この輪郭線抽出は、1ドット幅の輪郭を正しく抽出できません。ARToolKit互換の画像処理では問題になることは少ないので、\r
- * 大きな影響はありませんが、必要に応じてNyARContourPickupを参考に直してください。\r
+ * このクラスは、{@link NyARContourPickup}に、{@link NyARLabelingImage}の処理機能を追加したクラスです。\r
+ * <p>@bug\r
+ * この輪郭線抽出は、特定のパターンで1ドット幅の輪郭を正しく抽出できません。ARToolKit互換の画像処理では\r
+ * 問題になることは少ないので、大きな影響はありませんが、必要に応じて{@link NyARContourPickup}を参考に直してください。\r
+ * </p>\r
*/\r
public class NyARContourPickup_ARToolKit extends NyARContourPickup\r
{\r
/**\r
- * ラスタの指定点を基点に、輪郭線を抽出します。開始点は、輪郭の一部、かつ左上のエッジで有る必要があります。\r
+ * この関数は、ラスタの指定点を基点に、輪郭線を抽出します。\r
+ * 開始点は、輪郭の一部である必要があります。\r
+ * 通常は、ラべリングの結果の上辺クリップとX軸エントリポイントを開始点として入力します。\r
* @param i_raster\r
* 輪郭線を抽出するラスタを指定します。\r
* @param i_entry_x\r
\r
\r
/**\r
- * 頂点集合を一次方程式のパラメータに変換します。\r
- * \r
- *\r
+ * このクラスは、座標配列を直線式に変換します。\r
+ * 座標配列の連続する要素を主成分分析にかけて、直線式にします。\r
*/\r
public class NyARCoord2Linear\r
{\r
private final double[] __getSquareLine_ev=new double[2];\r
private final NyARObserv2IdealMap _dist_factor;\r
/**\r
+ * コンストラクタです。\r
+ * 輪郭取得元画像の歪み矯正オブジェクトとサイズを指定して、インスタンスを生成します。\r
* @param i_size\r
+ * 入力画像のサイズ\r
* @param i_distfactor_ref\r
- * カメラ歪みを補正する場合のパラメータを指定します。\r
- * nullã\81®å ´å\90\88ã\80\81è£\9cæ£ã\83\9eã\83\83ã\83\97ã\82\92使ç\94¨ã\81\97ません。\r
+ * 樽型歪みを補正する場合に、オブジェクトを指定します。\r
+ * nullã\81®å ´å\90\88ã\80\81è£\9cæ£ã\82\92è¡\8cã\81\84ません。\r
*/\r
public NyARCoord2Linear(NyARIntSize i_size,NyARCameraDistortionFactor i_distfactor)\r
{\r
\r
\r
/**\r
- * 輪郭点集合からay+bx+c=0の直線式を計算します。\r
+ * この関数は、輪郭点集合からay+bx+c=0の直線式を計算します。\r
* @param i_st\r
+ * 直線計算の対象とする、輪郭点の開始インデックス\r
* @param i_ed\r
+ * 直線計算の対象とする、輪郭点の終了インデックス\r
* @param i_coord\r
+ * 輪郭点集合のオブジェクト。\r
* @param o_line\r
+ * 直線式を受け取るオブジェクト\r
* @return\r
+ * 直線式の計算に成功すると、trueを返します。\r
* @throws NyARException\r
*/\r
public boolean coord2Line(int i_st,int i_ed,NyARIntCoordinates i_coord, NyARLinear o_line) throws NyARException\r
package jp.nyatla.nyartoolkit.core.squaredetect;\r
\r
import jp.nyatla.nyartoolkit.core.types.*;\r
+\r
/**\r
- * 座標店集合（輪郭線）から、四角系の頂点候補点を計算します。\r
- *\r
+ * このクラスは、輪郭線を四角形と仮定して、その頂点位置を計算します。\r
+ * ARToolKitの四角形検出処理の一部です。\r
*/\r
public class NyARCoord2SquareVertexIndexes\r
{\r
private static final double VERTEX_FACTOR = 1.0;// 線検出のファクタ \r
private final NyARVertexCounter __getSquareVertex_wv1 = new NyARVertexCounter();\r
private final NyARVertexCounter __getSquareVertex_wv2 = new NyARVertexCounter();\r
+ /**\r
+ * コンストラクタです。\r
+ * インスタンスを生成します。\r
+ */\r
public NyARCoord2SquareVertexIndexes()\r
{\r
return;\r
}\r
/**\r
- * 座標集合から、頂点候補になりそうな場所を４箇所探して、そのインデクス番号を返します。\r
+ * この関数は、座標集合から頂点候補になりそうな場所を４箇所探して、そのインデクス番号を返します。\r
* @param i_coord\r
- * 輪郭を格納した配列です。\r
+ * 輪郭点集合を格納したオブジェクト。\r
* @param i_area\r
+ * 矩形判定のヒント値。矩形の大きさを、そのラベルを構成するピクセルの数で指定します。\r
+ * (注)このパラメータは、マーカノデザイン、枠の大きさが影響等、ラベルの大きさに影響を受けます。\r
* @param o_vertex\r
+ * 4頂点のインデクスを受け取る配列です。4要素以上の配列を指定してください。\r
* @return\r
+ * 頂点が見つかるとtrueを返します。\r
*/\r
public boolean getVertexIndexes(NyARIntCoordinates i_coord, int i_area, int[] o_vertex)\r
{\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
/**\r
- * ARMarkerInfoに相当するクラス。 矩形情報を保持します。\r
- * \r
- * directionは方角を表します。\r
- * 決定しないときはDIRECTION_UNKNOWNを設定してください。\r
- * \r
+ * このクラスは、矩形情報を格納します。\r
+ * ARToolKitのARMarkerInfoに相当しますが、このクラスは理想座標のみを取り扱います。\r
*/\r
public class NyARSquare\r
{\r
+ /** 矩形の辺の直線式です。*/\r
public NyARLinear[] line = NyARLinear.createArray(4);\r
+ /** 矩形の頂点です。 line[n]と、line[(n+3)%4]の交点でもあります。*/\r
public NyARDoublePoint2d[] sqvertex = NyARDoublePoint2d.createArray(4);\r
\r
/**\r
- * 中心点を計算します。\r
+ * この関数は、矩形の中心点を計算します。\r
* @param o_out\r
* 結果を格納するバッファ。\r
*/\r
return;\r
}\r
/**\r
- * 頂点同士の距離から、頂点のシフト量を返します。この関数は、よく似た２つの矩形の頂点同士の対応を取るために使用します。\r
+ * この関数は、頂点同士の距離から、頂点のシフト量（回転量）を返します。\r
+ * よく似た２つの矩形の頂点同士の、頂点の対応を取るために使用します。\r
* @param i_square\r
* 比較対象の矩形\r
* @return\r
}\r
return min_index;\r
}\r
- \r
- \r
\r
- /**\r
- * 4とnの最大公約数テーブル\r
- */\r
+ /** 4とnの最大公約数テーブル*/\r
private final static int[] _gcd_table4={-1,1,2,1};\r
/**\r
- * 頂点を左回転して、矩形を回転させます。\r
+ * この関数は、頂点を左回転して、矩形を回転させます。\r
* @param i_shift\r
+ * シフト量。4未満、0以上である事。\r
*/\r
public void rotateVertexL(int i_shift)\r
{\r
import jp.nyatla.nyartoolkit.core.raster.NyARBinRaster;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
+/**\r
+ * このクラスは、矩形検出器のベースクラスです。\r
+ * 矩形検出機能を提供する関数を定義します。\r
+ */\r
public abstract class NyARSquareContourDetector\r
{\r
/**\r
+ * この関数は、ラスタから矩形を検出して、自己コールバック関数{@link #onSquareDetect}で通知します。\r
+ * 実装クラスでは、矩形検出処理をして、結果を通知する処理を実装してください。\r
* @param i_raster\r
- * @param o_square_stack\r
+ * 検出元のラスタ画像\r
* @throws NyARException\r
*/\r
public abstract void detectMarker(NyARBinRaster i_raster) throws NyARException;\r
/**\r
- * 通知ハンドラです。\r
- * この関数は、detectMarker関数のコールバック関数として機能します。\r
- * 継承先のクラスで、矩形の発見時の処理をここに記述してください。\r
+ * この関数は、自己コールバック関数です。{@link #detectMarker}が検出矩形を通知するために使います。\r
+ * 実装クラスでは、ここに矩形の発見時の処理を記述してください。\r
* @param i_coord\r
- * @param i_coor_num\r
+ * 輪郭線オブジェクト\r
* @param i_vertex_index\r
+ * 矩形の４頂点に対応する、輪郭線オブジェクトのインデクス番号。\r
* @throws NyARException\r
*/\r
protected abstract void onSquareDetect(NyARIntCoordinates i_coord,int[] i_vertex_index) throws NyARException;\r
import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
\r
\r
-\r
+/**\r
+ * このクラスは、{@link NyARLabeling_ARToolKit}クラスを用いた矩形検出器です。\r
+ * 検出した矩形を、自己コールバック関数{@link #onSquareDetect}へ通知します。\r
+ * 継承クラスで自己コールバック関数{@link #onSquareDetect}を実装する必要があります。\r
+ */\r
public abstract class NyARSquareContourDetector_ARToolKit extends NyARSquareContourDetector\r
{\r
private static final int AR_AREA_MAX = 100000;// #define AR_AREA_MAX 100000\r
private final NyARIntCoordinates _coord;\r
private final int[] __detectMarker_mkvertex = new int[4];\r
/**\r
- * 最大i_squre_max個のマーカーを検出するクラスを作成する。\r
- * \r
- * @param i_param\r
+ * コンストラクタです。\r
+ * 入力画像のサイズを指定して、インスタンスを生成します。\r
+ * @param i_size\r
+ * 入力画像のサイズ\r
*/\r
public NyARSquareContourDetector_ARToolKit(NyARIntSize i_size) throws NyARException\r
{\r
this._coord=new NyARIntCoordinates(number_of_coord);\r
return;\r
}\r
-\r
/**\r
- * arDetectMarker2を基にした関数\r
- * この関数はNyARSquare要素のうち、directionを除くパラメータを取得して返します。\r
- * directionの確定は行いません。\r
- * @param i_raster\r
- * 解析する２値ラスタイメージを指定します。\r
- * @throws NyARException\r
+ * この関数は、ラスタから矩形を検出して、自己コールバック関数{@link #onSquareDetect}で通知します。\r
+ * ARToolKitのarDetectMarker2を基にしています。\r
*/\r
public final void detectMarker(NyARBinRaster i_raster) throws NyARException\r
{\r
import jp.nyatla.nyartoolkit.core.raster.NyARGrayscaleRaster;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
-\r
+/**\r
+ * このクラスは、{@link NyARLabeling_Rle}クラスを用いた矩形検出器です。\r
+ * 検出した矩形を、自己コールバック関数{@link #onSquareDetect}へ通知します。\r
+ * 継承クラスで自己コールバック関数{@link #onSquareDetect}を実装する必要があります。\r
+ */\r
public abstract class NyARSquareContourDetector_Rle extends NyARSquareContourDetector\r
{\r
- /**\r
- * label_stackにソート後の結果を蓄積するクラス\r
- */\r
- class Labeling extends NyARLabeling_Rle\r
+ /** label_stackにソート後の結果を蓄積するクラス*/\r
+ private class Labeling extends NyARLabeling_Rle\r
{\r
public NyARRleLabelFragmentInfoPtrStack label_stack;\r
int _right;\r
\r
private final NyARIntCoordinates _coord;\r
/**\r
- * コンストラクタ\r
+ * コンストラクタです。\r
+ * 入力画像のサイズを指定して、インスタンスを生成します。\r
* @param i_size\r
* 入力画像のサイズ\r
*/\r
}\r
\r
private final int[] __detectMarker_mkvertex = new int[4];\r
+ /**\r
+ * この関数は、ラスタから矩形を検出して、自己コールバック関数{@link #onSquareDetect}で通知します。\r
+ * @param i_raster\r
+ * 検出元のラスタ画像\r
+ * 入力できるラスタの画素形式は、{@link NyARLabeling_Rle#labeling(NyARGrayscaleRaster, int)}と同じです。\r
+ * @param i_area\r
+ * 検出する範囲。検出元のラスタの内側である必要があります。\r
+ * @param i_th\r
+ * ラベルと判定する敷居値\r
+ * @throws NyARException\r
+ */\r
public void detectMarker(NyARGrayscaleRaster i_raster,NyARIntRect i_area,int i_th) throws NyARException\r
{\r
assert(i_area.w*i_area.h>0);\r
return;\r
}\r
/**\r
- * @override\r
+ * この関数は、ラスタから矩形を検出して、自己コールバック関数{@link #onSquareDetect}で通知します。\r
+ * ARToolKitのarDetectMarker2を基にしています。\r
*/\r
public void detectMarker(NyARBinRaster i_raster) throws NyARException\r
{\r
/**\r
* デバック用API\r
* @return\r
+ * オブジェクト配列\r
*/\r
public Object[] _probe()\r
{\r
\r
import jp.nyatla.nyartoolkit.NyARException;\r
import jp.nyatla.nyartoolkit.core.types.stack.NyARObjectStack;\r
-\r
+/**\r
+ * このクラスは、{@link NyARSquare}の動的配列御定義します。\r
+ */\r
public class NyARSquareStack extends NyARObjectStack<NyARSquare>\r
{\r
+ /**\r
+ * コンストラクタ。\r
+ * サイズを指定して、配列を作成します。\r
+ * @param i_length\r
+ * 配列の最大長さ\r
+ * @throws NyARException\r
+ */\r
public NyARSquareStack(int i_length) throws NyARException\r
{\r
super.initInstance(i_length,NyARSquare.class);\r
\r
}\r
+ /**\r
+ * 要素のオブジェクトを生成します。\r
+ */\r
protected NyARSquare createElement()\r
{\r
return new NyARSquare();\r
\r
\r
/**\r
- * This class calculates ARMatrix from square information. -- 変換行列を計算するクラス。\r
- * \r
+ * このインタフェイスは、二次元矩形から３次元位置姿勢を推定する関数を定義します。\r
+ * ARToolKitの３次元推定処理の一部です。\r
*/\r
public interface INyARTransMat\r
{\r
/**\r
- * 理想座標系の四角系から、i_offsetのパラメタで示される矩形を(0,0,0)の点から移動するための行列式を計算し、o_resultへ格納します。\r
+ * この関数は、理想座標系の四角系を元に、位置姿勢変換行列を求めます。\r
+ * 位置姿勢変換行列は、オフセット位置を基準とした変換行列です。\r
+ * 実装クラスでは、マーカの二次元座標から、位置姿勢行列を計算する処理を実装します。\r
* @param i_square\r
+ * 矩形情報を格納したオブジェクトです。\r
* @param i_offset\r
+ * カメラ座標系での、矩形のオフセット位置です。通常、原点中心のマーカ座標になります。\r
* @param o_result\r
+ * 結果を格納するオブジェクトです。\r
* @throws NyARException\r
*/\r
public void transMat(NyARSquare i_square,NyARRectOffset i_offset, NyARTransMatResult o_result) throws NyARException;\r
/**\r
- * 理想座標系の四角系から、i_offsetのパラメタで示される矩形を(0,0,0)の点から移動するための行列式を計算し、o_resultへ格納します。\r
- * i_prev_resultにある過去の情報を参照するため、変移が少ない場合はより高精度な値を返します。\r
+ * この関数は、理想座標系の四角系を元に、位置姿勢変換行列を求めます。\r
+ * 位置姿勢変換行列は、オフセット位置を基準とした変換行列です。\r
+ * 実装クラスでは、マーカの二次元座標から、位置姿勢行列を計算する処理を実装します。\r
+ * 姿勢推定にi_prev_resultにある過去の情報を参照するため、変移が少ない場合は、{@link #transMat}と比較して高品質な値を返します。\r
+ * <p>使い方 -\r
+ * この関数は、連続して同じ対象（マーカ）の姿勢行列を求めるときに、効果を発揮します。フレーム毎に、そのマーカの前回求めた姿勢変換行列を繰り返し\r
+ * 入力してください。\r
+ * </p>\r
* @param i_square\r
+ * 矩形情報を格納したオブジェクトです。\r
* @param i_offset\r
+ * カメラ座標系での、矩形のオフセット位置です。通常、原点中心のマーカ座標になります。\r
* @param i_prev_result\r
* 参照する過去のオブジェクトです。このオブジェクトとo_resultには同じものを指定できます。\r
* @param o_result\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
/**\r
- * 矩形の頂点情報を格納します。\r
+ * このクラスは、３次元空間での矩形位置を格納します。\r
+ * ARToolKitの３次元オフセット位置として使います。\r
*/\r
final public class NyARRectOffset\r
{\r
+ /**\r
+ * 3次元座標系での、4頂点のオフセット位置を格納します。\r
+ * 基本的には読み取り専用です。\r
+ */\r
public final NyARDoublePoint3d[] vertex=NyARDoublePoint3d.createArray(4);\r
+ /**\r
+ * この関数は、{@link NyARRectOffset}の配列を生成します。\r
+ * @param i_number\r
+ * 配列の長さ\r
+ * @return\r
+ * 割り当てた配列\r
+ */\r
public static NyARRectOffset[] createArray(int i_number)\r
{\r
NyARRectOffset[] ret=new NyARRectOffset[i_number];\r
return ret;\r
} \r
/**\r
- * 辺長から、オフセット情報を作成して設定します。\r
- * 作成するオフセット情報は、マーカ中心を0,0としたi_width*i_widthのマーカです。\r
+ * この関数は、原点(0,0,0)位置に、XY平面に平行な正方形マーカのオフセット情報をセットします。\r
* @param i_width\r
* マーカの縦横サイズ(mm単位)\r
*/\r
return;\r
}\r
/**\r
- * 辺長から、オフセット情報を作成して設定します。\r
- * 作成するオフセット情報は、マーカ中心を0,0としたi_width*i_heightのマーカです。\r
+ * この関数は、原点(0,0,0)位置に、XY平面に平行な矩形マーカのオフセット情報をセットします。\r
* @param i_width\r
* マーカの横サイズ(mm単位)\r
* @param i_height\r
import jp.nyatla.nyartoolkit.core.types.matrix.*;\r
\r
/**\r
- * This class calculates ARMatrix from square information and holds it. --\r
- * 変換行列を計算して、結果を保持するクラス。\r
- * \r
+ * このクラスは、NyARToolkitの計算式で、二次元矩形から３次元位置姿勢を推定します。\r
*/\r
public class NyARTransMat implements INyARTransMat\r
{ \r
private NyARCameraDistortionFactor _ref_dist_factor;\r
\r
/**\r
- * 派生クラスで自分でメンバオブジェクトを指定したい場合はこちらを使う。\r
- *\r
+ * コンストラクタです。\r
+ * 派生クラスで自分でメンバオブジェクトを指定したい場合はこちらを使います。\r
*/\r
protected NyARTransMat()\r
{\r
this._ref_projection_mat=i_projmat;\r
return;\r
}\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * 座標計算に必要なオブジェクトの参照値を元に、インスタンスを生成します。\r
+ * @param i_ref_distfactor\r
+ * 樽型歪み矯正オブジェクトの参照値です。歪み矯正が不要な時は、nullを指定します。\r
+ * @param i_ref_projmat\r
+ * 射影変換オブジェクトの参照値です。\r
+ * @throws NyARException\r
+ */\r
public NyARTransMat(NyARCameraDistortionFactor i_ref_distfactor,NyARPerspectiveProjectionMatrix i_ref_projmat) throws NyARException\r
{\r
initInstance(i_ref_distfactor,i_ref_projmat);\r
return;\r
}\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * 座標計算に必要なカメラパラメータの参照値を元に、インスタンスを生成します。\r
+ * @param i_param\r
+ * ARToolKit形式のカメラパラメータです。\r
+ * インスタンスは、この中から樽型歪み矯正オブジェクト、射影変換オブジェクトを参照します。\r
+ * @throws NyARException\r
+ */\r
public NyARTransMat(NyARParam i_param) throws NyARException\r
{\r
initInstance(i_param.getDistortionFactor(),i_param.getPerspectiveProjectionMatrix());\r
}\r
\r
/**\r
- * double arGetTransMat( ARMarkerInfo *marker_info,double center[2], double width, double conv[3][4] )\r
- * \r
- * @param i_square\r
- * 計算対象のNyARSquareオブジェクト\r
- * @param i_direction\r
- * @param i_width\r
- * @return\r
- * @throws NyARException\r
+ * この関数は、理想座標系の四角系を元に、位置姿勢変換行列を求めます。\r
+ * ARToolKitのarGetTransMatに該当します。\r
+ * @see INyARTransMat#transMatContinue\r
*/\r
public void transMat(NyARSquare i_square,NyARRectOffset i_offset, NyARTransMatResult o_result_conv) throws NyARException\r
{\r
return;\r
}\r
\r
- /*\r
- * (non-Javadoc)\r
- * @see jp.nyatla.nyartoolkit.core.transmat.INyARTransMat#transMatContinue(jp.nyatla.nyartoolkit.core.NyARSquare, int, double, jp.nyatla.nyartoolkit.core.transmat.NyARTransMatResult)\r
+ /**\r
+ * この関数は、理想座標系の四角系を元に、位置姿勢変換行列を求めます。\r
+ * 計算に過去の履歴を使う点が、{@link #transMat}と異なります。\r
+ * @see INyARTransMat#transMatContinue\r
*/\r
public final void transMatContinue(NyARSquare i_square,NyARRectOffset i_offset,NyARTransMatResult i_prev_result,NyARTransMatResult o_result) throws NyARException\r
{\r
}\r
return;\r
}\r
- /**\r
- * \r
- * @param i_square\r
- * @param i_offset\r
- * @param i_prev_error\r
- * 前回のエラーレート値をしていします。\r
- * @param io_angle\r
- * @param io_trans\r
- * @return\r
- * エラーレート値を返します。\r
- * @throws NyARException\r
- * \r
- */\r
+\r
/* public double transMatContinue(NyARSquare i_square,NyARRectOffset i_offset,double i_prev_error,NyARDoublePoint3d io_angle,NyARDoublePoint3d io_trans) throws NyARException\r
{\r
final NyARDoublePoint3d trans=this.__transMat_trans;\r
return;\r
}\r
\r
- //エラーレート計算機\r
+ /**\r
+ * この関数は、姿勢行列のエラーレートを計算します。\r
+ * エラーレートは、回転行列、平行移動量、オフセット、観察座標から計算します。\r
+ * 通常、ユーザが使うことはありません。\r
+ * @param i_rot\r
+ * 回転行列\r
+ * @param i_trans\r
+ * 平行移動量\r
+ * @param i_vertex3d\r
+ * オフセット位置\r
+ * @param i_vertex2d\r
+ * 理想座標\r
+ * @param i_number_of_vertex\r
+ * 評価する頂点数\r
+ * @param o_rot_vertex\r
+ * 計算過程で得られた、各頂点の三次元座標\r
+ * @return\r
+ * エラーレート(Σ(理想座標と計算座標の距離[n]^2))\r
+ * @throws NyARException\r
+ */\r
public final double errRate(NyARDoubleMatrix33 i_rot,NyARDoublePoint3d i_trans, NyARDoublePoint3d[] i_vertex3d, NyARDoublePoint2d[] i_vertex2d,int i_number_of_vertex,NyARDoublePoint3d[] o_rot_vertex) throws NyARException\r
{\r
NyARPerspectiveProjectionMatrix cp = this._ref_projection_mat;\r
import jp.nyatla.nyartoolkit.core.types.matrix.*;\r
\r
/**\r
- * NyARTransMat戻り値専用のNyARMat\r
- * \r
+ * {@link INyARTransMat}の出力する、位置姿勢行列を受け取る行列クラスです。\r
*/\r
public class NyARTransMatResult extends NyARDoubleMatrix44\r
{\r
/**\r
* この行列に1度でも行列をセットしたかを返します。\r
+ * {@link INyARTransMat#transMatContinue}関数が使います。\r
*/\r
public boolean has_value = false;\r
/**\r
- * 観測値とのずれを示すエラーレート値です。SetValueにより更新されます。\r
+ * 観測値とのずれを示すエラーレート値です。{@link INyARTransMat}が更新します。\r
+ * エラーレートの意味は、実装クラスごとに異なることに注意してください。\r
+ * ユーザからは読出し専用です。\r
* {@link #has_value}がtrueの時に使用可能です。\r
*/\r
public double last_error;\r
/**\r
* コンストラクタです。\r
+ * 初期値を設定したインスタンスを作成します。\r
*/\r
public NyARTransMatResult()\r
{\r
this.m33=1.0;\r
}\r
/**\r
- * 平行移動量と回転行列をセットします。この関数は、INyARTransmatインタフェイスのクラスが結果を保存するために使います。\r
+ * この関数は、平行移動量と回転行列をセットして、インスタンスのパラメータを更新します。\r
+ * 通常、ユーザが使うことはありません。\r
+ * {@link INyARTransMat#transMatContinue}関数が使います。\r
* @param i_rot\r
+ * 設定する回転行列\r
* @param i_trans\r
+ * 設定する平行移動量\r
*/\r
public final void setValue(NyARDoubleMatrix33 i_rot, NyARDoublePoint3d i_trans,double i_error)\r
{\r
\r
\r
/**\r
- * This class calculates ARMatrix from square information and holds it. --\r
- * 変換行列を計算して、結果を保持するクラス。\r
- * \r
+ * このクラスは、ARToolKitと同じ方法で、二次元矩形から３次元位置姿勢を推定します。\r
*/\r
public class NyARTransMat_ARToolKit implements INyARTransMat\r
{\r
private final static double AR_GET_TRANS_MAT_MAX_FIT_ERROR = 1.0;// #define AR_GET_TRANS_MAT_MAX_FIT_ERROR 1.0\r
private final static double AR_GET_TRANS_CONT_MAT_MAX_FIT_ERROR = 1.0;\r
\r
+ /** 回転行列の計算オブジェクト*/\r
protected NyARRotMatrix_ARToolKit _rotmatrix;\r
+ /** 平行移動量の計算オブジェクト*/\r
protected INyARTransportVectorSolver _transsolver;\r
+ /** 姿勢行列最適化オブジェクト*/\r
protected INyARRotMatrixOptimize _mat_optimize;\r
private NyARCameraDistortionFactor _ref_dist_factor;\r
\r
/**\r
- * 派生クラスで自分でメンバオブジェクトを指定したい場合はこちらを使う。\r
- *\r
+ * コンストラクタです。\r
+ * 派生クラスで自分でメンバオブジェクトを指定したい場合はこちらを使います。\r
*/\r
protected NyARTransMat_ARToolKit()\r
{\r
//作成して割り当ててください。\r
return;\r
}\r
+ /**\r
+ * コンストラクタです。\r
+ * 座標計算に必要なオブジェクトの参照値を元に、インスタンスを生成します。\r
+ * @param i_ref_distfactor\r
+ * 樽型歪み矯正オブジェクトの参照値です。歪み矯正が不要な時は、nullを指定します。\r
+ * @param i_ref_projmat\r
+ * 射影変換オブジェクトの参照値です。\r
+ * @throws NyARException\r
+ */\r
public NyARTransMat_ARToolKit(NyARCameraDistortionFactor i_ref_distfactor,NyARPerspectiveProjectionMatrix i_ref_projmat) throws NyARException\r
{\r
initInstance(i_ref_distfactor,i_ref_projmat);\r
return;\r
- } \r
+ }\r
+ /**\r
+ * コンストラクタです。\r
+ * 座標計算に必要なカメラパラメータの参照値を元に、インスタンスを生成します。\r
+ * @param i_param\r
+ * ARToolKit形式のカメラパラメータです。\r
+ * インスタンスは、この中から樽型歪み矯正オブジェクト、射影変換オブジェクトを参照します。\r
+ * @throws NyARException\r
+ */ \r
public NyARTransMat_ARToolKit(NyARParam i_param) throws NyARException\r
{\r
initInstance(i_param.getDistortionFactor(),i_param.getPerspectiveProjectionMatrix());\r
private final NyARDoublePoint3d[] __transMat_vertex_3d = NyARDoublePoint3d.createArray(4);\r
private final NyARDoublePoint3d __transMat_trans=new NyARDoublePoint3d();\r
/**\r
- * double arGetTransMat( ARMarkerInfo *marker_info,double center[2], double width, double conv[3][4] )\r
- * \r
- * @param i_square\r
- * 計算対象のNyARSquareオブジェクト\r
- * @param i_width\r
- * @return\r
- * @throws NyARException\r
+ * この関数は、理想座標系の四角系を元に、位置姿勢変換行列を求めます。\r
+ * ARToolKitのarGetTransMatに該当します。\r
+ * @see INyARTransMat#transMatContinue\r
*/\r
public final void transMat(NyARSquare i_square,NyARRectOffset i_offset, NyARTransMatResult o_result_conv) throws NyARException\r
{\r
o_result_conv.setValue(this._rotmatrix,trans,err);\r
return;\r
}\r
-\r
- /*\r
- * (non-Javadoc)\r
- * @see jp.nyatla.nyartoolkit.core.transmat.INyARTransMat#transMatContinue(jp.nyatla.nyartoolkit.core.NyARSquare, int, double, jp.nyatla.nyartoolkit.core.transmat.NyARTransMatResult)\r
+ /**\r
+ * この関数は、理想座標系の四角系を元に、位置姿勢変換行列を求めます。\r
+ * 計算に過去の履歴を使う点が、{@link #transMat}と異なります。\r
+ * @see INyARTransMat#transMatContinue\r
*/\r
public final void transMatContinue(NyARSquare i_square,NyARRectOffset i_offset,NyARTransMatResult i_prev_result,NyARTransMatResult o_result) throws NyARException\r
{\r
}\r
\r
/**\r
- * 基本姿勢と実画像を一致するように、角度を微調整→平行移動量を再計算 を繰り返して、変換行列を最適化する。\r
- * \r
+ * このクラスは、NyARToolkit方式の姿勢行列Optimizerです。\r
+ * <p>アルゴリズム -\r
+ * 姿勢行列をX,Y,Zの回転方向について偏微分して、それぞれ誤差が最小になる点を求めます。\r
+ * 下位が２点ある場合は、前回の結果に近い値を採用することで、ジッタを減らします。\r
+ * </p>\r
*/\r
public class NyARPartialDifferentiationOptimize\r
{\r
private final NyARPerspectiveProjectionMatrix _projection_mat_ref;\r
\r
+ /**\r
+ * コンストラクタです。\r
+ * 射影変換オブジェクトの参照値を設定して、インスタンスを生成します。\r
+ * @param i_projection_mat_ref\r
+ * 射影変換オブジェクトの参照値。\r
+ */\r
public NyARPartialDifferentiationOptimize(NyARPerspectiveProjectionMatrix i_projection_mat_ref)\r
{\r
this._projection_mat_ref = i_projection_mat_ref;\r
return getMinimumErrorAngleFromParam(L,J, K, M, N, O, i_hint_angle);\r
}\r
private NyARDoublePoint3d __ang=new NyARDoublePoint3d();\r
+ /**\r
+ * この関数は、回転行列を最適化します。\r
+ * i_vertex3dのオフセット値を、io_rotとi_transで座標変換後に射影変換した２次元座標と、i_vertex2dが最も近くなるように、io_rotを調整します。\r
+ * io_rot,i_transの値は、ある程度の精度で求められている必要があります。\r
+ * @param io_rot\r
+ * 調整する回転行列\r
+ * @param i_trans\r
+ * 平行移動量\r
+ * @param i_vertex3d\r
+ * 三次元オフセット座標\r
+ * @param i_vertex2d\r
+ * 理想座標系の頂点座標\r
+ * @param i_number_of_vertex\r
+ * 頂点数\r
+ * @throws NyARException\r
+ */\r
public void modifyMatrix(NyARDoubleMatrix33 io_rot, NyARDoublePoint3d i_trans, NyARDoublePoint3d[] i_vertex3d, NyARDoublePoint2d[] i_vertex2d, int i_number_of_vertex) throws NyARException\r
{\r
NyARDoublePoint3d ang = this.__ang; \r
io_rot.setZXYAngle(ang.x, ang.y, ang.z);\r
return;\r
}\r
+ /**\r
+ * この関数は、回転角を最適化します。\r
+ * i_vertex3dのオフセット値を、i_angleとi_transで座標変換後に射影変換した２次元座標と、i_vertex2dが最も近くなる値を、o_angleへ返します。\r
+ * io_rot,i_transの値は、ある程度の精度で求められている必要があります。\r
+ * @param i_angle\r
+ * 回転角\r
+ * @param i_trans\r
+ * 平行移動量\r
+ * @param i_vertex3d\r
+ * 三次元オフセット座標\r
+ * @param i_vertex2d\r
+ * 理想座標系の頂点座標\r
+ * @param i_number_of_vertex\r
+ * 頂点数\r
+ * @param o_angle\r
+ * 調整した回転角を受け取る配列\r
+ * @throws NyARException\r
+ */ \r
public void modifyMatrix(NyARDoublePoint3d i_angle,NyARDoublePoint3d i_trans, NyARDoublePoint3d[] i_vertex3d, NyARDoublePoint2d[] i_vertex2d, int i_number_of_vertex,NyARDoublePoint3d o_angle) throws NyARException\r
{\r
\r
import jp.nyatla.nyartoolkit.core.transmat.rotmatrix.*;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
+/**\r
+ * このクラスは、ARToolKit由来の回転行列最適化関数を定義します。\r
+ *\r
+ */\r
public interface INyARRotMatrixOptimize\r
{\r
/**\r
+ * この関数は、回転行列を最適化します。\r
+ * 実装クラスでは、ARToolKitと互換性のある値を返す、回転行列の最適化処理を書きます。\r
* @param io_rot\r
- * 初期回転行列\r
+ * 最適化する回転行列を指定します。\r
* @param i_trans\r
- * å\88\9dæ\9c\9f並é\80²ã\83\99ã\82¯ã\83\88ã\83«\r
+ * å¹³è¡\8c移å\8b\95é\87\8f\r
* @param i_vertex3d\r
- * 初期3次元座標\r
+ * 三次元オフセット座標\r
* @param i_vertex2d\r
- * ç\94»é\9d¢ä¸\8aã\81®é \82ç\82¹ç¾¤\r
+ * ç\90\86æ\83³åº§æ¨\99ç³»ã\81®é \82ç\82¹åº§æ¨\99\r
* @return\r
* エラーレート\r
* @throws NyARException\r
*/\r
-// public double optimize(NyARRotMatrix io_rotmat,NyARDoublePoint3d io_transvec,INyARTransportVectorSolver i_solver,NyARDoublePoint3d[] i_offset_3d,NyARDoublePoint2d[] i_2d_vertex) throws NyARException;\r
public double modifyMatrix(NyARRotMatrix_ARToolKit io_rot, NyARDoublePoint3d i_trans, NyARDoublePoint3d[] i_vertex3d, NyARDoublePoint2d[] i_vertex2d) throws NyARException;\r
\r
}\r
import jp.nyatla.nyartoolkit.core.transmat.solver.INyARTransportVectorSolver;\r
import jp.nyatla.nyartoolkit.core.types.NyARDoublePoint2d;\r
import jp.nyatla.nyartoolkit.core.types.NyARDoublePoint3d;\r
+\r
/**\r
- * 基本姿勢と実画像を一致するように、角度を微調整→平行移動量を再計算\r
- * を繰り返して、変換行列を最適化する。\r
- *\r
+ * このクラスは、高速化したARToolKit由来の姿勢行列最適化処理を実装します。\r
+ * さらに高速化した{@link NyARRotMatrixOptimize_O2}を使用してください。\r
*/\r
public class NyARRotMatrixOptimize implements INyARRotMatrixOptimize\r
{\r
- private final static int AR_GET_TRANS_MAT_MAX_LOOP_COUNT = 5;// #define AR_GET_TRANS_MAT_MAX_LOOP_COUNT 5\r
- private final static double AR_GET_TRANS_MAT_MAX_FIT_ERROR = 1.0;// #define AR_GET_TRANS_MAT_MAX_FIT_ERROR 1.0\r
private final NyARPerspectiveProjectionMatrix _projection_mat_ref;\r
+ /**\r
+ * コンストラクタです。\r
+ * 射影変換オブジェクトの参照値を設定して、インスタンスを生成します。\r
+ * @param i_projection_mat_ref\r
+ * 射影変換オブジェクトの参照値。\r
+ */ \r
public NyARRotMatrixOptimize(NyARPerspectiveProjectionMatrix i_projection_mat_ref)\r
{\r
this._projection_mat_ref=i_projection_mat_ref;\r
return;\r
}\r
- final public double optimize(NyARRotMatrix_ARToolKit io_rotmat,NyARDoublePoint3d io_transvec,INyARTransportVectorSolver i_solver,NyARDoublePoint3d[] i_offset_3d,NyARDoublePoint2d[] i_2d_vertex) throws NyARException\r
- {\r
- double err = -1;\r
- /*ループを抜けるタイミングをARToolKitと合わせるために変なことしてます。*/\r
- for (int i = 0;; i++) {\r
- // <arGetTransMat3>\r
- err = modifyMatrix(io_rotmat,io_transvec,i_offset_3d,i_2d_vertex);\r
- i_solver.solveTransportVector(i_offset_3d, io_transvec);\r
- err = modifyMatrix(io_rotmat,io_transvec,i_offset_3d,i_2d_vertex); \r
- // //</arGetTransMat3>\r
- if (err < AR_GET_TRANS_MAT_MAX_FIT_ERROR || i == AR_GET_TRANS_MAT_MAX_LOOP_COUNT-1) {\r
- break;\r
- }\r
- i_solver.solveTransportVector(i_offset_3d, io_transvec);\r
- } \r
- return err;\r
- }\r
\r
private final double[][] __modifyMatrix_double1D = new double[8][3];\r
/**\r
- * arGetRot計算を階層化したModifyMatrix 896\r
- * \r
- * @param nyrot\r
- * @param trans\r
- * @param i_vertex3d\r
- * [m][3]\r
- * @param i_vertex2d\r
- * [n][2]\r
- * @return\r
- * @throws NyARException\r
+ * この関数は、回転行列を最適化します。\r
+ * ARToolKitのarGetRotに相当します。\r
*/\r
public double modifyMatrix(NyARRotMatrix_ARToolKit io_rot,NyARDoublePoint3d trans, NyARDoublePoint3d[] i_vertex3d, NyARDoublePoint2d[] i_vertex2d) throws NyARException\r
{\r
import jp.nyatla.nyartoolkit.core.types.*;\r
\r
/**\r
- * 処理構造がわかる程度に展開したNyARRotTransOptimize\r
- * \r
+ * このクラスは、ARToolKit由来の姿勢行列最適化処理を実装します。\r
+ * 構造も含めた手順の実装が目的の為、低速です。\r
+ * 高速化した{@link NyARRotMatrixOptimize_O2}を使用してください。\r
*/\r
public class NyARRotMatrixOptimize_Base implements INyARRotMatrixOptimize\r
{\r
private final NyARPerspectiveProjectionMatrix _projection_mat_ref;\r
-\r
+ /**\r
+ * コンストラクタです。\r
+ * 射影変換オブジェクトの参照値を設定して、インスタンスを生成します。\r
+ * @param i_projection_mat_ref\r
+ * 射影変換オブジェクトの参照値。\r
+ */\r
public NyARRotMatrixOptimize_Base(NyARPerspectiveProjectionMatrix i_projection_mat_ref)\r
{\r
this._projection_mat_ref = i_projection_mat_ref;\r
private final NyARDoublePoint3d __modifyMatrix_angle = new NyARDoublePoint3d();\r
private final NyARDoubleMatrix34 __modifyMatrix_combo=new NyARDoubleMatrix34();\r
private final NyARDoubleMatrix33[] __modifyMatrix_next_rot_matrix=NyARDoubleMatrix33.createArray(27); \r
+ /**\r
+ * この関数は、回転行列を最適化します。\r
+ * ARToolKitのarGetRotに相当します。\r
+ */\r
public double modifyMatrix(NyARRotMatrix_ARToolKit io_rot, NyARDoublePoint3d i_trans, NyARDoublePoint3d[] i_vertex3d, NyARDoublePoint2d[] i_vertex2d) throws NyARException\r
{\r
final NyARDoublePoint3d angle = this.__modifyMatrix_angle;\r
import jp.nyatla.nyartoolkit.core.types.NyARDoublePoint2d;\r
import jp.nyatla.nyartoolkit.core.types.NyARDoublePoint3d;\r
/**\r
- * 基本姿勢と実画像を一致するように、角度を微調整→平行移動量を再計算\r
- * を繰り返して、変換行列を最適化する。\r
- *\r
+ * このクラスは、高速化したARToolKit由来の姿勢行列最適化処理を実装します。\r
*/\r
public class NyARRotMatrixOptimize_O2 implements INyARRotMatrixOptimize\r
{\r
private final NyARPerspectiveProjectionMatrix _projection_mat_ref;\r
+ /**\r
+ * コンストラクタです。\r
+ * 射影変換オブジェクトの参照値を設定して、インスタンスを生成します。\r
+ * @param i_projection_mat_ref\r
+ * 射影変換オブジェクトの参照値。\r
+ */ \r
public NyARRotMatrixOptimize_O2(NyARPerspectiveProjectionMatrix i_projection_mat_ref)\r
{\r
this._projection_mat_ref=i_projection_mat_ref;\r
}\r
private final double[][] __modifyMatrix_double1D = new double[8][3];\r
/**\r
- * arGetRot計算を階層化したModifyMatrix 896\r
- * \r
- * @param trans\r
- * @param i_vertex3d\r
- * [m][3]\r
- * @param i_vertex2d\r
- * [n][2]\r
- * @return\r
- * @throws NyARException\r
+ * この関数は、回転行列を最適化します。\r
+ * ARToolKitのarGetRotに相当します。\r
*/\r
public double modifyMatrix(NyARRotMatrix_ARToolKit io_rot,NyARDoublePoint3d trans, NyARDoublePoint3d[] i_vertex3d, NyARDoublePoint2d[] i_vertex2d) throws NyARException\r
{\r
import jp.nyatla.nyartoolkit.core.transmat.NyARTransMatResult;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
import jp.nyatla.nyartoolkit.core.types.matrix.NyARDoubleMatrix33;\r
+\r
/**\r
- * 回転行列計算用の、3x3行列\r
- *\r
+ * このクラスは、回転行列を計算する行列クラスです。\r
+ * 通常は、ユーザが使用することはありません。\r
*/\r
public class NyARRotMatrix extends NyARDoubleMatrix33\r
{\r
/**\r
- * インスタンスを準備します。\r
- * \r
- * @param i_param\r
+ * コンストラクタです。\r
+ * 参照する射影変換オブジェクトを指定して、インスタンスを生成します。\r
+ * @param i_matrix\r
+ * 参照する射影変換オブジェクト\r
+ * @throws NyARException\r
*/\r
public NyARRotMatrix(NyARPerspectiveProjectionMatrix i_matrix) throws NyARException\r
{\r
final private NyARRotVector __initRot_vec1;\r
final private NyARRotVector __initRot_vec2;\r
/**\r
- * NyARTransMatResultの内容からNyARRotMatrixを復元します。\r
+ * この関数は、{@link NyARTransMatResult}の内容を、回転行列にセットします。\r
* @param i_prev_result\r
+ * セットする姿勢変換行列。\r
*/\r
public final void initRotByPrevResult(NyARTransMatResult i_prev_result)\r
{\r
return;\r
} \r
/**\r
+ * この関数は、２次元座標系の矩形を表す直線式と、３次元座標系の矩形のオフセット座標値から、回転行列を計算します。\r
+ * <p>メモ - \r
+ * Cで実装するときは、配列のポインタ版関数と2重化すること\r
+ * </p>\r
* @param i_linear\r
+ * 直線式。4要素である必要があります。\r
* @param i_sqvertex\r
- * @note\r
- * Cで実装するときは、配列のポインタ版関数と2重化すること\r
+ * 矩形の３次元オフセット座標。4要素である必要があります。\r
* @throws NyARException\r
*/\r
public void initRotBySquare(final NyARLinear[] i_linear,final NyARDoublePoint2d[] i_sqvertex) throws NyARException\r
this.m22 = w22/w;\r
return;\r
}\r
+ /**\r
+ * この関数は、ZXY系の角度値を、回転行列にセットします。\r
+ * @param i_angle\r
+ * ZXY系のラジアン値\r
+ */\r
public final void initRotByAngle(NyARDoublePoint3d i_angle)\r
{\r
this.setZXYAngle(i_angle);\r
} \r
/**\r
- * i_in_pointを変換行列で座標変換する。\r
+ * この関数は、入力した３次元頂点を回転して返します。\r
* @param i_in_point\r
+ * 回転する三次元座標\r
* @param i_out_point\r
+ * 回転した三次元座標\r
*/\r
public final void getPoint3d(final NyARDoublePoint3d i_in_point,final NyARDoublePoint3d i_out_point)\r
{\r
return;\r
}\r
/**\r
- * 複数の頂点を一括して変換する\r
+ * この関数は、入力した複数の３次元頂点を回転して返します。\r
* @param i_in_point\r
+ * 回転する三次元座標の配列\r
* @param i_out_point\r
+ * 回転した三次元座標の配列\r
* @param i_number_of_vertex\r
+ * 回転する座標の個数\r
*/\r
public final void getPoint3dBatch(final NyARDoublePoint3d[] i_in_point,NyARDoublePoint3d[] i_out_point,int i_number_of_vertex)\r
{\r
import jp.nyatla.nyartoolkit.NyARException;\r
import jp.nyatla.nyartoolkit.core.types.*;\r
import jp.nyatla.nyartoolkit.core.param.*;\r
+\r
/**\r
- * 回転行列計算用の、3x3行列\r
- *\r
+ * このクラスは、ARToolKitと同じ計算結果を出力する、行列クラスです。\r
*/\r
public class NyARRotMatrix_ARToolKit extends NyARRotMatrix\r
{ \r
/**\r
- * インスタンスを準備します。\r
- * \r
- * @param i_param\r
+ * コンストラクタです。\r
+ * 参照する射影変換オブジェクトを指定して、インスタンスを生成します。\r
+ * @param i_matrix\r
+ * 参照する射影変換オブジェクト\r
+ * @throws NyARException\r
*/\r
public NyARRotMatrix_ARToolKit(NyARPerspectiveProjectionMatrix i_matrix) throws NyARException\r
{\r
this._angle=new NyARDoublePoint3d();\r
return;\r
}\r
+ /** ARToolkitスタイルの角度値です。*/\r
final protected NyARDoublePoint3d _angle;\r
\r
-\r
- \r
+ //override\r
public final void initRotBySquare(final NyARLinear[] i_linear,final NyARDoublePoint2d[] i_sqvertex) throws NyARException\r
{\r
super.initRotBySquare(i_linear,i_sqvertex);\r
this.updateAngleFromMatrix();\r
return;\r
}\r
+ /**\r
+ * ARToolKitスタイルの角度値の参照値を返します。\r
+ * @return\r
+ * [read only]角度値\r
+ */\r
public final NyARDoublePoint3d refAngle()\r
{\r
return this._angle;\r
}\r
/**\r
- * 回転角から回転行列を計算してセットします。\r
+ * ARToolKitスタイルの角度値を、行列にセットします。\r
* @param i_x\r
+ * X軸の回転量。\r
* @param i_y\r
+ * Y軸の回転量。\r
* @param i_z\r
+ * Z軸の回転量。\r
*/\r
public void setAngle(final double i_x, final double i_y, final double i_z)\r
{\r
public class NyARRotMatrix_ARToolKit_O2 extends NyARRotMatrix_ARToolKit\r
{ \r
/**\r
- * インスタンスを準備します。\r
- * \r
- * @param i_param\r
+ * コンストラクタです。\r
+ * 参照する射影変換オブジェクトを指定して、インスタンスを生成します。\r
+ * @param i_matrix\r
+ * 参照する射影変換オブジェクト\r
+ * @throws NyARException\r
*/\r
public NyARRotMatrix_ARToolKit_O2(NyARPerspectiveProjectionMatrix i_matrix) throws NyARException\r
{\r
super(i_matrix);\r
return;\r
}\r
+ //override\r
public final void setAngle(final double i_x, final double i_y, final double i_z)\r
{\r
final double sina = Math.sin(i_x);\r
import jp.nyatla.nyartoolkit.core.types.matrix.*;\r
import jp.nyatla.nyartoolkit.core.param.*;\r
\r
+/**\r
+ * このクラスは、ベクトル(直線)から回転行列を計算する関数を定義します。\r
+ * 通常、ユーザがこのクラスを使うことはありません。{@link NyARRotMatrix}クラスから使います。\r
+ */\r
public class NyARRotVector\r
{\r
\r
- //publicメンバ達\r
+ /** ベクトル要素1*/\r
public double v1;\r
-\r
+ /** ベクトル要素2*/\r
public double v2;\r
-\r
+ /** ベクトル要素3*/\r
public double v3;\r
\r
- //privateメンバ達\r
- \r
+ //privateメンバ達 \r
private NyARPerspectiveProjectionMatrix _projection_mat_ref;\r
-\r
private NyARDoubleMatrix44 _inv_cpara=new NyARDoubleMatrix44();\r
\r
+ /**\r
+ * コンストラクタです。\r
+ * 射影変換オブジェクトの参照値を設定して、インスタンスを作成します。\r
+ * @param i_cmat\r
+ * 射影変換オブジェクト。この値はインスタンスの生存中は変更しないでください。\r
+ * @throws NyARException\r
+ */\r
public NyARRotVector(NyARPerspectiveProjectionMatrix i_cmat) throws NyARException\r
{\r
this._inv_cpara.inverse(i_cmat);\r
}\r
\r
/**\r
- * ２直線に直交するベクトルを計算する・・・だと思う。\r
+ * この関数は、２直線に直交するベクトルを計算して、その３次元ベクトルをインスタンスに格納します。\r
+ * （多分）\r
* @param i_linear1\r
+ * 直線１\r
* @param i_linear2\r
+ * 直線２\r
*/\r
public void exteriorProductFromLinear(NyARLinear i_linear1, NyARLinear i_linear2)\r
{\r
this.v3 = m2 / w;\r
return;\r
}\r
-\r
/**\r
- * static int check_dir( double dir[3], double st[2], double ed[2],double cpara[3][4] ) Optimize:STEP[526->468]\r
- * ベクトルの開始/終了座標を指定して、ベクトルの方向を調整する。\r
+ * この関数は、ARToolKitのcheck_dir関数に相当します。\r
+ * 詳細は不明です。(ベクトルの開始/終了座標を指定して、ベクトルの方向を調整？)\r
* @param i_start_vertex\r
+ * 開始位置？\r
* @param i_end_vertex\r
- * @param cpara\r
+ * 終了位置？\r
+ * @throws NyARException\r
*/\r
public void checkVectorByVertex(final NyARDoublePoint2d i_start_vertex, final NyARDoublePoint2d i_end_vertex) throws NyARException\r
{\r
}\r
}\r
/**\r
- * int check_rotation( double rot[2][3] )\r
- * 2つのベクトル引数の調整をする？\r
- * @param i_r\r
+ * この関数は、ARToolKitのcheck_rotationに相当する計算をします。\r
+ * 詳細は不明です。(2つのベクトルの関係を調整？)\r
* @throws NyARException\r
*/\r
-\r
public final static void checkRotation(NyARRotVector io_vec1, NyARRotVector io_vec2) throws NyARException\r
{\r
double w;\r
\r
/**\r
* このクラスは、1個のARマーカを検出する処理を、イベントドリブンにするシーケンスを定義します。\r
- * マーカの出現・移動・消滅を、イベントで通知することができます。\r
+ * マーカの出現・移動・消滅を、自己コールバック関数で通知することができます。\r
* クラスにはマーカパターンテーブルがあり、そこに複数種類のマーカを登録することができます。\r
* 一つのマーカが見つかると、プロセッサは継続して同じマーカを1つだけ認識し続け、見失うまでの間は他のマーカを認識しません。\r
* <p>イベントの説明-\r
- * このクラスには、３個のイベントハンドラがあります。{@link SingleARMarkerProcesser}は、以下のタイミングでこれらを呼び出します。\r
+ * このクラスには、３個の自己コールバック関数があります。{@link SingleARMarkerProcesser}は、以下のタイミングでこれらを呼び出します。\r
* ユーザは継承クラスでこれらの関数に実装を行い、イベント駆動のアプリケーションを作成できます。\r
* <ul>\r
* <li> {@link #onEnterHandler} - 登録したマーカが初めて見つかった時に呼び出されます。ここに、発見したマーカに対応した初期処理を書きます。\r
\r
private NyARTransMatResult __NyARSquare_result = new NyARTransMatResult();\r
\r
- /** オブジェクトのステータスを更新し、必要に応じてハンドル関数を駆動します。\r
+ /** オブジェクトのステータスを更新し、必要に応じて自己コールバック関数を駆動します。\r
* 戻り値は、「実際にマーカを発見する事ができたか」を示す真偽値です。クラスの状態とは異なります。\r
*/\r
private boolean updateStatus(NyARSquare i_square, int i_code_index) throws NyARException\r
}\r
}\r
/**\r
- * イベントハンドラです。\r
+ * 自己コールバック関数です。\r
* 継承したクラスで、マーカ発見時の処理を実装してください。\r
* @param i_code\r
* 検出したマーカパターンのID番号です。ID番号については、{@link #setARCodeTable}の説明を参照してください。\r
*/\r
protected abstract void onEnterHandler(int i_code);\r
/**\r
- * イベントハンドラです。\r
+ * 自己コールバック関数です。\r
* 継承したクラスで、マーカ消失時の処理を実装してください。\r
*/\r
protected abstract void onLeaveHandler();\r
/**\r
- * イベントハンドラです。\r
+ * 自己コールバック関数です。\r
* 継承したクラスで、マーカ更新時の処理を実装してください。\r
- * 引数の値の有効期間は、イベントハンドラが終了するまでです。\r
+ * 引数の値の有効期間は、関数が終了するまでです。\r
* @param i_square\r
* 現在のマーカ検出位置です。\r
* @param result\r
import jp.nyatla.nyartoolkit.core.squaredetect.*;\r
/**\r
* このクラスは、1個のNyARマーカを検出する処理を、イベントドリブンにするシーケンスを定義します。\r
- * マーカの出現・移動・消滅を、イベントで通知することができます。\r
+ * マーカの出現・移動・消滅を、自己コールバック関数で通知することができます。\r
* クラスにはNyIdマーカのエンコーダを指定できます。エンコーダの種類を変えることで、異なる種類のNyIdマーカを同じクラスで\r
* 取り扱うことができます。（同時に取り扱うことはできません。）\r
- * <p>イベントの説明-\r
- * このクラスには、３個のイベントハンドラがあります。{@link SingleARMarkerProcesser}は、以下のタイミングでこれらを呼び出します。\r
+ * <p>自己コールバック関数の説明-\r
+ * このクラスには、３個の自己コールバック関数があります。{@link SingleARMarkerProcesser}は、以下のタイミングでこれらを呼び出します。\r
* ユーザは継承クラスでこれらの関数に実装を行い、イベント駆動のアプリケーションを作成できます。\r
* <ul>\r
* <li> {@link #onEnterHandler} - 登録したマーカが初めて見つかった時に呼び出されます。ここに、発見したマーカに対応した初期処理を書きます。\r
private NyARRasterThresholdAnalyzer_SlidePTile _threshold_detect;\r
private NyARTransMatResult __NyARSquare_result = new NyARTransMatResult();\r
\r
- /**オブジェクトのステータスを更新し、必要に応じてハンドル関数を駆動します。\r
+ /**オブジェクトのステータスを更新し、必要に応じて自己コールバック関数を駆動します。\r
*/\r
private boolean updateStatus(NyARSquare i_square, INyIdMarkerData i_marker_data) throws NyARException\r
{\r
return is_id_found;\r
} \r
/**\r
- * イベントハンドラです。\r
+ * 自己コールバック関数です。\r
* 継承したクラスで、マーカ発見時の処理を実装してください。\r
* @param i_code\r
* 検出したIDマーカの内容をエンコードしたデータです。\r
*/\r
protected abstract void onEnterHandler(INyIdMarkerData i_code);\r
/**\r
- * イベントハンドラです。\r
+ * 自己コールバック関数です。\r
* 継承したクラスで、マーカ消失時の処理を実装してください。\r
*/\r
protected abstract void onLeaveHandler();\r
/**\r
- * イベントハンドラです。\r
+ * 自己コールバック関数です。\r
* 継承したクラスで、マーカ更新時の処理を実装してください。\r
- * 引数の値の有効期間は、イベントハンドラが終了するまでです。\r
+ * 引数の値の有効期間は、関数が終了するまでです。\r
* @param i_square\r
* 現在のマーカ検出位置です。\r
* @param result\r
\r
import com.sun.j3d.utils.universe.*;\r
import java.awt.*;\r
+import java.awt.event.WindowAdapter;\r
+import java.awt.event.WindowEvent;\r
+\r
import javax.swing.JFrame;\r
import javax.vecmath.*;\r
\r
public NyARJava3D() throws Exception\r
{\r
super("Java3D Example NyARToolkit");\r
-\r
+ this.addWindowListener(new WindowAdapter() {\r
+ public void windowClosing(WindowEvent e)\r
+ {\r
+ nya_behavior.stop();\r
+ System.exit(0);\r
+ }\r
+ });\r
//NyARToolkitの準備\r
NyARCode ar_code = new NyARCode(16, 16);\r
ar_code.loadARPattFromFile(CARCODE_FILE);\r
_gl.glRotatef(90,1.0f,0.0f,0.0f); // Place base of cube on marker surface.\r
NyARGLDrawUtil.setFontColor(t.getGrabbRate()<50?Color.RED:Color.BLUE);\r
ARTKMarkerTable.GetBestMatchTargetResult d=((ARTKMarkerTable.GetBestMatchTargetResult)(t.tag));\r
- NyARGLDrawUtil.drawText("Name:"+d.name+" GRUB:"+t.grab_rate+"%",0.5f);\r
+ NyARGLDrawUtil.drawText("Name:"+d.name+" GRUB:"+t._grab_rate+"%",0.5f);\r
_gl.glPopMatrix();\r
\r
break;\r
_gl.glRotatef(90,1.0f,0.0f,0.0f); // Place base of cube on marker surface.\r
//マーカ情報の表示\r
NyARGLDrawUtil.setFontColor(t.getGrabbRate()<50?Color.RED:Color.BLUE);\r
- NyARGLDrawUtil.drawText("ID:"+(Long)(t.tag)+" GRUB:"+t.grab_rate+"%",0.5f);\r
+ NyARGLDrawUtil.drawText("ID:"+(Long)(t.tag)+" GRUB:"+t._grab_rate+"%",0.5f);\r
_gl.glPopMatrix();\r
\r
break;\r
_gl.glRotatef(90,1.0f,0.0f,0.0f); // Place base of cube on marker surface.\r
//マーカ情報の表示\r
NyARGLDrawUtil.setFontColor(t.getGrabbRate()<50?Color.RED:Color.BLUE);\r
- NyARGLDrawUtil.drawText("ID:"+(Long)(t.tag)+" GRUB:"+t.grab_rate+"%",0.5f);\r
+ NyARGLDrawUtil.drawText("ID:"+(Long)(t.tag)+" GRUB:"+t._grab_rate+"%",0.5f);\r
_gl.glPopMatrix();\r
\r
break;\r
frame.addWindowListener(new WindowAdapter() {\r
public void windowClosing(WindowEvent e)\r
{\r
+ _capture.stop();\r
System.exit(0);\r
}\r
});\r
NyARIntPoint2d b=new NyARIntPoint2d();\r
t.getTargetCenter(b);\r
NyARIntRect r=t._ref_tracktarget._sample_area;\r
- g.drawString("[K]("+t.grab_rate+")",b.x,b.y);\r
+ g.drawString("[K]("+t._grab_rate+")",b.x,b.y);\r
g.drawRect(r.x,r.y, r.w,r.h);\r
if(t._ref_tracktarget._st_type==NyARTargetStatus.ST_RECT){\r
g.drawString(">"+((NyARRectTargetStatus)(t._ref_tracktarget._ref_status)).detect_type,r.x,r.y+10);\r
NyARIntPoint2d b=new NyARIntPoint2d();\r
t.getTargetCenter(b);\r
NyARIntRect r=t._ref_tracktarget._sample_area;\r
- g.drawString("[U]("+t.grab_rate+")",b.x,b.y);\r
+ g.drawString("[U]("+t._grab_rate+")",b.x,b.y);\r
g.drawRect(r.x,r.y, r.w,r.h);\r
}\r
private void drawDeadRT(Graphics g,NyARRealityTarget t)\r
{\r
g.setColor(Color.RED);\r
NyARIntRect r=t._ref_tracktarget._sample_area;\r
- g.drawString("[D]("+t.grab_rate+")",r.x,r.y);\r
+ g.drawString("[D]("+t._grab_rate+")",r.x,r.y);\r
}\r
\r
private final static String PATT_HIRO = "../../Data/patt.hiro";\r
try{\r
this._yuv2rgb.open();\r
}catch(Exception e){\r
- throw new NyARException();\r
+ throw new NyARException(e);\r
}\r
return;\r
}\r
OSDN Git Service
