- メインページ
- モジュール
- ネームスペース
- データ構造
- ファイル

- ネームスペース一覧
- ネームスペースメンバ

ネームスペース | データ構造 | 関数
ネームスペース mist

## ネームスペース
namespace | Armijo
| Armijoの基準を用いた極小値の一次元探索
namespace | average
| 一様重み平滑化フィルタの実装（コールバック関数を指定することが可能）
namespace | brent
| Brent の放物線補間を用いた極小値の1次元探索（2次収束）
namespace | BSpline
| 3次のBスプライン関数を用いた補間
namespace | calvin
| Calvinによるユークリッド2乗距離変換
namespace | chessboard
| チェスボード距離変換
namespace | cityblock
| マンハッタン距離（シティーブロック距離）変換
namespace | condor
| CONDOR法（多変数関数の極小値の探索）
namespace | conjugate_gradient
| 共役勾配法（勾配を用いた多変数関数の極小値の探索）
namespace | cubic
| 3次のsinc関数を用いた補間
namespace | dicom
| DICOMファイルを操作する関数・クラスを含む名前空間
namespace | discriminant_analysis
| 判別分析法に基づくしきい値決定
namespace | euclidean
| ユークリッド距離変換
namespace | gauss
| 正規乱数のジェネレータ
namespace | gaussian
| ガウシアンフィルタの実装（コールバック関数を指定することが可能）
namespace | gold
| 黄金分割を用いた極小値の1次元探索（1次収束）
namespace | gradient
| 最急降下法（勾配を用いた多変数関数の極小値の探索）
namespace | gradient_with_vector
| 勾配関数をユーザーが定義する最急降下法（勾配を用いた多変数関数の極小値の探索）
namespace | hilditch
| C. J. Hilditch の細線化アルゴリズム
namespace | histogram
| ヒストグラムから正規分布の混合分布を推定する関数群
namespace | laplacian
| ラプラシアンフィルタの実装（コールバック関数を指定することが可能）
namespace | linear
| 一般カーネルの線形フィルタの実装（コールバック関数を指定することが可能）
namespace | lucidi
| Lucidi法（方向集合を用いた多変数関数の極小値の探索）
namespace | machine_learning
| 機械学習
namespace | manhattan
| マンハッタン距離（シティーブロック距離）変換
namespace | mean
| 平均値型補間
namespace | meijster
| A. Meijster による距離変換（CDT, MDT）
namespace | mixture
| 混合分布推定に用いるパラメータ
namespace | mode_filter
| 最頻値フィルタに利用する構造要素関連
namespace | morphology
| モルフォロジ演算に利用する構造要素関連
namespace | multivariate_gauss
| 多変量正規乱数のジェネレータ
namespace | nearest
| 最近傍型補間
namespace | non_rigid
| FFDを用いた非剛体レジストレーション
namespace | poisson
| ポアソン分布に従う乱数のジェネレータ
namespace | powell
| Powell法（方向集合を用いた多変数関数の極小値の探索）
namespace | ptile
| Pタイル法に基づくしきい値決定
namespace | region_growing_utility
| 領域拡張法に利用する構造要素関連
namespace | saito
| 斉藤先生によるユークリッド2乗距離変換
namespace | sinc
| sinc関数を用いた補間
namespace | statistics
| 統計処理
namespace | Tsai
| Tsai のカメラキャリブレーション手法
namespace | uniform
| MT(Mersenne Twister)法による一様乱数
namespace | video
| ビデオファイルを扱うライブラリ

## データ構造
class | bitmap
| 要素数が可変のビットマップ画像を扱うクラス [詳細]
struct | bspline_base
| Bスプラインの基底関数を計算する関数を実装した構造体 [詳細]
struct | bspline_base< 1 >
| Bスプラインの基底関数を計算する関数を実装した構造体の特殊化 [詳細]
class | bspline
| Bスプライン曲線を扱うためのクラス [詳細]
class | binary
| バイナリ演算を行うためのもの [詳細]
struct | rgb
| カラー画像用の画素 [詳細]
struct | bgr
| カラー画素の和 [詳細]
struct | rgba
| カラー画素の和 [詳細]
struct | bgra
| カラー画素の和 [詳細]
struct | nRGB
| カラー画素の和 [詳細]
struct | color
| カラー画素の和 [詳細]
struct | is_color
| 入力された型がカラー画像かどうか調べる [詳細]
struct | float_type< rgb< T > >
| char 判定 [詳細]
struct | colors
| 定義済み色 [詳細]
union | byte_array
| バイト配列と値のペアを表現するクラス [詳細]
class | mist_iterator1
| mistコンテナで利用する1次元操作用ランダムアクセスイテレータ [詳細]
class | mist_iterator2
| mistコンテナで利用する2次元操作用ランダムアクセスイテレータ [詳細]
class | mist_reverse_iterator
| イテレータから逆方向ランダムアクセスイテレータを生成する [詳細]
struct | mist_memory_operator
| ユーザー定義型用のメモリ操作関数群 [詳細]
struct | mist_memory_operator<true >
| 組み込み型用のメモリ操作関数群 [詳細]
class | mist_allocator
| MIST内部でSTLのアロケータを効果的に利用するための仕組み [詳細]
struct | __mist_dmy_callback__
| MISTのアルゴリズム全般で利用するダミーコールバックファンクタ [詳細]
struct | __mist_convert_callback__
| 指定したコールバックの戻り値 [0,100] を指定した区間に変換する [詳細]
struct | __mist_console_callback__
| MISTのアルゴリズム全般で利用可能な，標準出力型コールバックファンクタ [詳細]
struct | __mist_progress_callback__
| MISTのアルゴリズム全般で利用可能な，進行状況表示型ダミーコールバックファンクタ [詳細]
class | scoped_ptr
| オブジェクトのスコープが切れると自動的にメモリ開放を行うポインタ [詳細]
class | scoped_array
| オブジェクトのスコープが切れると配列用に確保したメモリの自動開放を行うポインタ [詳細]
class | shared_ptr
| オブジェクトへのポインタの参照カウントを管理し，どこからも参照されなくなったときにメモリを自動開放するポインタ [詳細]
class | shared_array
| 配列へのポインタの参照カウントを管理し，どこからも参照されなくなったときにメモリを自動開放するポインタ [詳細]
class | weak_ptr
| 参照カウント型のメモリに対する，弱参照を扱うポインタ [詳細]
class | set_base
| 集合を扱うための基本クラス [詳細]
class | set
| 集合演算を行うことができる，STLの set の拡張版 [詳細]
class | multiset
| 集合演算を行うことができる，STLの set の拡張版 [詳細]
struct | stereo
| ステレオ音声用のデータ型 [詳細]
struct | is_stereo
| 入力された型が音声データかどうか調べる [詳細]
struct | is_char
| char 判定 [詳細]
struct | is_float
| 浮動小数点 判定 [詳細]
struct | is_integer
| integer 判定 [詳細]
struct | is_signed
| 符号付き型かどうか判定 [詳細]
struct | is_arithmetic
| arithmetic 判定 [詳細]
struct | is_builtin
| 組み込み型の判定 [詳細]
struct | float_type
| 対応する float 型を返す [詳細]
struct | promote_trait
| 型の昇格型を返す [詳細]
struct | type_trait
| データ型の確定を避けるために利用する [詳細]
struct | half_adjust
| 値の四捨五入をする [詳細]
struct | type_and
| 型のAND演算を行う [詳細]
struct | type_or
| 型のOR演算を行う型 [詳細]
struct | type_not
| 型のNOT演算を行う型 [詳細]
struct | type_equal
| 型のEQUAL演算を行う型 [詳細]
struct | crc
| CRC を生成・検証を行うクラス [詳細]
class | facet
| ポリゴン（三角形）を扱うクラス [詳細]
class | facet_list
| ポリゴン（三角形）の集合を扱うクラス [詳細]
class | hash_algorithm
| ハッシュ関数を計算する基底クラス [詳細]
class | integral_image
| 1次元の積分画像を保持し，任意の矩形領域の画素値の総和を高速に計算するためのクラス [詳細]
class | integral_image< array< T, Allocator > >
| 1次元の積分画像を保持し，任意の矩形領域の画素値の総和を高速に計算するためのクラス [詳細]
class | integral_image< array2< T, Allocator > >
| 2次元の積分画像を保持し，任意の矩形領域の画素値の総和を高速に計算するためのクラス [詳細]
class | integral_image< array3< T, Allocator > >
| 3次元の積分画像を保持し，任意の矩形領域の画素値の総和を高速に計算するためのクラス [詳細]
struct | type_limits
| 入力された型の情報を取得する [詳細]
class | marching_cubes
| ボリュームデータから等値面を生成するためのクラス [詳細]
class | matrix
| 行と列の要素数が可変の行列 [詳細]
class | md2
| MD2 を生成するクラス [詳細]
class | md4
| MD4 を生成するクラス [詳細]
class | md5
| MD5 を生成するクラス [詳細]
class | array
| 要素数が可変の1次元配列 [詳細]
class | array1
| 要素数が可変の解像度付1次元配列 [詳細]
class | array2
| 要素数が可変の解像度付き2次元配列 [詳細]
class | array3
| 要素数が可変の解像度付き3次元配列 [詳細]
class | marray
| 画像のふちにマージンを持った配列 [詳細]
class | buffered_array
| １辺が2の指数乗のバッファを持った画像を作成する [詳細]
struct | matrix_style
| 行列計算をする際の入力となる行列の形式 [詳細]
struct | implement_operator_add
| 足し算 [詳細]
struct | implement_operator_sub
| 引き算 [詳細]
struct | implement_operator_mul
| 掛け算 [詳細]
struct | implement_operator_div
| 割り算 [詳細]
struct | implement_operator_ne
| 等しくない [詳細]
struct | implement_operator_gt
| より大きい [詳細]
struct | implement_operator_le
| 以下 [詳細]
struct | implement_operator_ge
| 以上 [詳細]
struct | implement_operator_mod
| 剰余演算子 [詳細]
struct | implement_operator_or
| ビットOR演算子 [詳細]
struct | implement_operator_and
| ビットAND演算子 [詳細]
struct | implement_operator_xor
| XOR演算子 [詳細]
struct | implement_arithmetic_operators
| 四則演算オペレータを実装する [詳細]
struct | implement_comparison_operators
| 比較オペレータを実装する [詳細]
struct | implement_bit_operators
| ビット演算オペレータを実装する [詳細]
struct | implement_operators
| 全てのオペレータを実装する [詳細]
class | quaternion
| クォータニオン（四元数）を扱うクラス [詳細]
class | sha1
| SHA-1 を生成するクラス [詳細]
class | sha256
| SHA-256 を生成するクラス [詳細]
class | sha384
| SHA-384 を生成するクラス [詳細]
class | sha512
| SHA-512 を生成するクラス [詳細]
class | singleton
| Singleton を扱うクラス [詳細]
class | spline
| 3次スプライン曲線を扱うためのクラス [詳細]
class | tensor
| Tensor class. [詳細]
struct | simple_lock_object
| スレッドの排他制御をサポートする最も単純なクラス [詳細]
struct | lock_object
| スレッドの排他制御をサポートするクラス [詳細]
class | lock
| スレッドの排他制御を簡便に記述するためのヘルパクラス [詳細]
class | thread
| template 型のデータを扱うことができるスレッドクラス [詳細]
class | thread_pool
| スレッドプールを利用してスレッドの再利用を可能にするクラス [詳細]
class | worker_thread
| バックグラウンドで実行するワーカースレッドを実現するクラス [詳細]
class | thread_handle
| 生成したスレッドを管理するクラス [詳細]
class | timer
class | stopwatch
class | options
| コマンドライン引数を解析するクラス [詳細]
class | vector3
| 3次元ベクトルを扱うクラス [詳細]
class | vector2
| 2次元ベクトルを扱うクラス [詳細]
class | vector
| N次元ベクトルを扱うクラス [詳細]

## 関数
template<typename T >
double | cross_correlation (const array1< T > &signal1, const array1< T > &signal2, int tau, bool biased=true)
| Cross correlation.
template<typename T , class Allocator >
double | autocorrelation (const array1< T, Allocator > &signal, int tau, bool biased=true)
| Autocorrelation.
template<class T1 , class Allocator1 , class T2 , class Allocator2 , class T3 , class Allocator3 >
double | parcor (const array1< T1, Allocator1 > &cor, array1< T2, Allocator2 > &alf, array1< T3, Allocator3 > &ref, int p)
| Calculate PARCOR and linear predict cofficients from autocorrelation values.
template<size_t BITS, class Allocator >
std::ostream & | operator<< (std::ostream &out, const bitmap< BITS, Allocator > &a)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
const binary | operator+ (const binary &b1, const binary &b2)
| 論理演算
const binary | operator- (const binary &b1, const binary &b2)
| 論理演算
const binary | operator* (const binary &b1, const binary &b2)
| 論理演算
const binary | operator/ (const binary &b1, const binary &b2)
| 論理演算
const binary | operator% (const binary &b1, const binary &b2)
| 論理演算
const binary | operator| (const binary &b1, const binary &b2)
| 論理演算
const binary | operator& (const binary &b1, const binary &b2)
| 論理演算
const binary | operator^ (const binary &b1, const binary &b2)
| 論理演算
const binary | operator* (const binary &b1, const binary::value_type &b2)
| 論理演算
const binary | operator* (const binary::value_type &b1, const binary &b2)
| 論理演算
const binary | operator/ (const binary &b1, const binary::value_type &b2)
| 論理演算
const binary | operator+ (const binary &b1, const binary::value_type &b2)
| 論理演算
const binary | operator+ (const binary::value_type &b1, const binary &b2)
| 論理演算
const binary | operator- (const binary &b1, const binary::value_type &b2)
| 論理演算
const binary | operator- (const binary::value_type &b1, const binary &b2)
| 論理演算
std::ostream & | operator<< (std::ostream &out, const binary &b)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
template<class T >
std::ostream & | operator<< (std::ostream &out, const rgb< T > &c)
| カラー画素の和
template<class T >
std::ostream & | operator<< (std::ostream &out, const rgba< T > &c)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
template<class T >
std::ostream & | operator<< (std::ostream &out, const nRGB< T > &c)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
template<class T , size_t NDIM>
std::ostream & | operator<< (std::ostream &out, const color< T, NDIM > &c)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
void | rgb2hsv (double r, double g, double b, double &h, double &s, double &v)
| RGB色空間をHSV色空間に変換する
void | hsv2rgb (double h, double s, double v, double &r, double &g, double &b)
| HSV色空間をRGB色空間に変換する
void | rgb2yiq (double r, double g, double b, double &y, double &i, double &q)
| RGB色空間をYIQ色空間に変換する
void | yiq2rgb (double y, double i, double q, double &r, double &g, double &b)
| YIQ色空間をRGB色空間に変換する
void | rgb2ycbcr (double r, double g, double b, double &y, double &cb, double &cr)
| RGB色空間をYCbCr色空間に変換する
void | ycbcr2rgb (double y, double cb, double cr, double &r, double &g, double &b)
| YCbCr色空間をRGB色空間に変換する
void | rgb2xyz (double r, double g, double b, double &x, double &y, double &z)
| RGB色空間をXYZ色空間に変換する
void | xyz2rgb (double x, double y, double z, double &r, double &g, double &b)
| XYZ色空間をRGB色空間に変換する
void | rgb2lab (double r, double g, double b, double &l_, double &a_, double &b_)
| RGB色空間をL*a*b*色空間に変換する
void | lab2rgb (double l_, double a_, double b_, double &r, double &g, double &b)
| L*a*b*色空間をRGB色空間に変換する
bool | _is_little_endian_ ()
| 現在のマシンのエンディアンがリトルエンディアンかどうかを調べる
bool | _is_big_endian_ ()
| 現在のマシンのエンディアンがビッグエンディアンかどうかを調べる
template<class T >
void | swap_bytes (byte_array< T > &bytes)
| byte_array内のバイトスワップをする
template<class T >
byte_array< T > | to_current_endian (const byte_array< T > &bytes, bool from_little_endian)
| byte_array内のデータを現在の計算機のエンディアンに合わせる
template<class T >
byte_array< T > | from_current_endian (const byte_array< T > &bytes, bool to_little_endian)
| byte_array内のデータを現在の計算機のエンディアンから目的のエンディアンに合わせる
template<class T , class Distance , class Pointer , class Reference >
const mist_iterator1< T, Distance, Pointer, Reference > | operator+ (const mist_iterator1< T, Distance, Pointer, Reference > &ite, typename mist_iterator1< T, Distance, Pointer, Reference >::difference_type dist)
| dist だけ + 方向にイテレータを進めたイテレータを返す
template<class T , class Distance , class Pointer , class Reference >
const mist_iterator1< T, Distance, Pointer, Reference > | operator+ (typename mist_iterator1< T, Distance, Pointer, Reference >::difference_type dist, const mist_iterator1< T, Distance, Pointer, Reference > &ite)
| dist だけ + 方向にイテレータを進めたイテレータを返す
template<class T , class Distance , class Pointer , class Reference >
const mist_iterator1< T, Distance, Pointer, Reference > | operator- (const mist_iterator1< T, Distance, Pointer, Reference > &ite, typename mist_iterator1< T, Distance, Pointer, Reference >::difference_type dist)
| dist だけ - 方向にイテレータを進めたイテレータを返す
template<class T , class Distance , class Pointer , class Reference >
const mist_iterator2< T, Distance, Pointer, Reference > | operator+ (const mist_iterator2< T, Distance, Pointer, Reference > &ite, typename mist_iterator2< T, Distance, Pointer, Reference >::difference_type dist)
| dist だけ + 方向にイテレータを進めたイテレータを返す
template<class T , class Distance , class Pointer , class Reference >
const mist_iterator2< T, Distance, Pointer, Reference > | operator+ (typename mist_iterator2< T, Distance, Pointer, Reference >::difference_type dist, const mist_iterator2< T, Distance, Pointer, Reference > &ite)
| dist だけ + 方向にイテレータを進めたイテレータを返す
template<class T , class Distance , class Pointer , class Reference >
const mist_iterator2< T, Distance, Pointer, Reference > | operator- (const mist_iterator2< T, Distance, Pointer, Reference > &ite, typename mist_iterator2< T, Distance, Pointer, Reference >::difference_type dist)
| dist だけ - 方向にイテレータを進めたイテレータを返す
template<class T >
const mist_reverse_iterator< T > | operator+ (const mist_reverse_iterator< T > &ite1, const mist_reverse_iterator< T > ite2)
| dist だけ + 方向にイテレータを進めたイテレータを返す
template<class T >
const mist_reverse_iterator< T > | operator+ (const mist_reverse_iterator< T > &ite, typename T::difference_type dist)
| dist だけ + 方向にイテレータを進めたイテレータを返す
template<class T >
const mist_reverse_iterator< T > | operator+ (typename T::difference_type dist, const mist_reverse_iterator< T > &ite)
| dist だけ - 方向にイテレータを進めたイテレータを返す
template<class T >
const mist_reverse_iterator< T > | operator- (const mist_reverse_iterator< T > &ite, typename T::difference_type dist)
| dist だけ - 方向にイテレータを進めたイテレータを返す
template<class Object1 , class Object2 >
bool | is_same_object (const Object1 &o1, const Object2 &o2)
| 入力された2つのオブジェクトが同じもの（メモリ上で同じ位置にある）かどうかを判定する
const std::string | wstr2str (const std::wstring &src)
| UNICODE文字列をマルチバイト文字列に変換する
void | mist_debug_assertion (ptrdiff_t index)
| DEBUGでMISTをビルドした際に，1次元アクセスでの範囲外アクセスをチェックし，エラーの際に呼ばれる関数．
void | mist_debug_assertion (ptrdiff_t index1, ptrdiff_t index2)
| DEBUGでMISTをビルドした際に，2次元アクセスでの範囲外アクセスをチェックし，エラーの際に呼ばれる関数．
void | mist_debug_assertion (ptrdiff_t index1, ptrdiff_t index2, ptrdiff_t index3)
| DEBUGでMISTをビルドした際に，3次元アクセスでの範囲外アクセスをチェックし，エラーの際に呼ばれる関数．
template<class T >
std::ostream & | operator<< (std::ostream &out, const scoped_ptr< T > &p)
| 指定されたストリームにデータを出力する
template<class T >
std::ostream & | operator<< (std::ostream &out, const scoped_array< T > &p)
| 指定されたストリームにデータを出力する
template<class T >
std::ostream & | operator<< (std::ostream &out, const shared_ptr< T > &p)
| 指定されたストリームにデータを出力する
template<class T >
std::ostream & | operator<< (std::ostream &out, const weak_ptr< T > &p)
| 指定されたストリームにデータを出力する
template<class SetType >
const set_base< SetType > | operator+ (const set_base< SetType > &s1, const set_base< SetType > &s2)
| 和集合を計算する
template<class SetType >
const set_base< SetType > | operator- (const set_base< SetType > &s1, const set_base< SetType > &s2)
| 差集合を計算する
template<class SetType >
const set_base< SetType > | operator* (const set_base< SetType > &s1, const set_base< SetType > &s2)
| 積集合を計算する
template<class SetType >
const set_base< SetType > | operator* (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
| 集合と1要素の積を計算する
template<class SetType >
const set_base< SetType > | operator* (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
| 1要素と集合の積を計算する
template<class SetType >
const set_base< SetType > | operator+ (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
| 集合と1要素の和を計算する
template<class SetType >
const set_base< SetType > | operator+ (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
| 1要素と集合の和を計算する
template<class SetType >
const set_base< SetType > | operator- (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
| 集合と1要素の差を計算する
template<class SetType >
const set_base< SetType > | operator- (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
| 1要素と集合の差を計算する
template<class SetType >
bool | operator== (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
| 全ての要素が等しいかどうかを判定する（ ）
template<class SetType >
bool | operator!= (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
| 全ての要素が等しくないかどうかを判定する（ ）
template<class SetType >
bool | operator< (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
| 集合の包含関係を調べる（ ）
template<class SetType >
bool | operator<= (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
| 集合の包含関係を調べる（ ）
template<class SetType >
bool | operator> (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
| 集合の包含関係を調べる（ ）
template<class SetType >
bool | operator>= (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
| 集合の包含関係を調べる（ ）
template<class SetType >
bool | operator== (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
| 全ての要素が等しいかどうかを判定する（ ）
template<class SetType >
bool | operator!= (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
| 全ての要素が等しくないかどうかを判定する（ ）
template<class SetType >
bool | operator< (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
| 集合の包含関係を調べる（ ）
template<class SetType >
bool | operator<= (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
| 集合の包含関係を調べる（ ）
template<class SetType >
bool | operator> (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
| 集合の包含関係を調べる（ ）
template<class SetType >
bool | operator>= (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
| 集合の包含関係を調べる（ ）
template<class SetType >
std::ostream & | operator<< (std::ostream &out, const set_base< SetType > &s)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
template<class T >
std::ostream & | operator<< (std::ostream &out, const stereo< T > &s)
| ステレオ音声データの和
template<class Array1 , class Array2 >
void | convert (const Array1 &in, Array2 &out)
| あるMISTコンテナから他のコンテナへの変換
template<class Array >
bool | draw_buffer (const Array &image, typename Array::size_type image_width, typename Array::size_type image_height, typename Array::size_type window_width, typename Array::size_type window_height, double zoom=1.0, double xpos=0.0, double ypos=0.0, bool interpolate=true)
| 2次元画像をOpenGLを用いてウィンドウに描画する
template<class Array >
bool | draw_image (const Array &image, typename Array::size_type window_width, typename Array::size_type window_height, double zoom=1.0, double xpos=0.0, double ypos=0.0, double back_r=0.0, double back_g=0.0, double back_b=0.0, bool interpolate=true, bool blend=false)
| 2次元画像をOpenGLを用いてウィンドウに描画する
template<class Array >
bool | draw_pixels (const Array &image, typename Array::size_type window_width, typename Array::size_type window_height, typename Array::difference_type xpos=0, typename Array::difference_type ypos=0, bool blend=false)
| 2次元画像をOpenGLを用いてウィンドウに描画する
vector2< double > | screen2point (const vector2< double > &pt, double imgX, double imgY, double aspect, double winW, double winH, double zoom, double posx, double posy)
| ウィンドウ座標系の点を画像座標系の点に変換する
vector2< double > | point2screen (const vector2< double > &pt, double imgX, double imgY, double aspect, double winW, double winH, double zoom, double posx, double posy)
| 画像座標系の点をウィンドウ座標系の点に変換する
template<class T , class Allocator >
void | draw_line (array2< T, Allocator > &image, typename array2< T, Allocator >::difference_type x1, typename array2< T, Allocator >::difference_type y1, typename array2< T, Allocator >::difference_type x2, typename array2< T, Allocator >::difference_type y2, typename array2< T, Allocator >::value_type color=typename array2< T, Allocator >::value_type())
| 2次元画像に直線を描画する
template<size_t BITS>
void | draw_line (bitmap< BITS > &image, typename bitmap< BITS >::difference_type x1, typename bitmap< BITS >::difference_type y1, typename bitmap< BITS >::difference_type x2, typename bitmap< BITS >::difference_type y2, typename bitmap< BITS >::value_type color=typename bitmap< BITS >::value_type())
| 2次元ビットマップ画像に直線を描画する
template<class T , class Allocator >
void | draw_line (array3< T, Allocator > &image, typename array3< T, Allocator >::difference_type x1, typename array3< T, Allocator >::difference_type y1, typename array3< T, Allocator >::difference_type z1, typename array3< T, Allocator >::difference_type x2, typename array3< T, Allocator >::difference_type y2, typename array3< T, Allocator >::difference_type z2, typename array3< T, Allocator >::value_type color=typename array3< T, Allocator >::value_type())
| 3次元画像に直線を描画する
template<class T , class Allocator >
void | draw_point (array2< T, Allocator > &image, typename array2< T, Allocator >::difference_type x, typename array2< T, Allocator >::difference_type y, typename array2< T, Allocator >::difference_type radius, typename array2< T, Allocator >::value_type value=typename array3< T, Allocator >::value_type())
| 3次元画像に直線を描画する
template<class T , class Allocator >
void | draw_point (array3< T, Allocator > &image, typename array3< T, Allocator >::difference_type x, typename array3< T, Allocator >::difference_type y, typename array3< T, Allocator >::difference_type z, typename array3< T, Allocator >::difference_type radius, typename array3< T, Allocator >::value_type value=typename array3< T, Allocator >::value_type())
| 3次元画像に直線を描画する
template<typename T , typename Allocator >
void | set_pixel (array2< T, Allocator > &image, typename array2< T, Allocator >::difference_type x, typename array2< T, Allocator >::difference_type y, const typename array2< T, Allocator >::value_type &value)
| 2次元が像に範囲チェックを行い，値を代入
template<typename T , typename Allocator >
void | draw_circle (array2< T, Allocator > &image, typename array2< T, Allocator >::difference_type cx, typename array2< T, Allocator >::difference_type cy, typename array2< T, Allocator >::difference_type r, const typename array2< T, Allocator >::value_type &value)
| 円を描く(Michenerの手法)
template<typename T , typename Allocator >
void | draw_rect (array2< T, Allocator > &image, typename array2< T, Allocator >::difference_type x0, typename array2< T, Allocator >::difference_type y0, typename array2< T, Allocator >::difference_type x1, typename array2< T, Allocator >::difference_type y1, const typename array2< T, Allocator >::value_type &value)
| 長方形を描く
template<typename T , typename Allocator >
void | fill_rect (array2< T, Allocator > &image, typename array2< T, Allocator >::difference_type x0, typename array2< T, Allocator >::difference_type y0, typename array2< T, Allocator >::difference_type x1, typename array2< T, Allocator >::difference_type y1, const typename array2< T, Allocator >::value_type &value)
| 長方形で塗りつぶす
template<typename T , typename Allocator >
void | draw_crosspoint (array2< T, Allocator > &image, typename array2< T, Allocator >::difference_type cx, typename array2< T, Allocator >::difference_type cy, typename array2< T, Allocator >::difference_type size, const typename array2< T, Allocator >::value_type &value)
| 十字点を描画
std::string | os ()
| OS情報を返す関数
std::string | cpu ()
| CPU名を返す関数
size_t | cpu_num ()
| CPU数を返す関数
std::string | machine ()
| 計算機名を返す関数
std::string | user ()
| 現在のユーザー名を返す関数
template<class T >
std::ostream & | operator<< (std::ostream &out, const facet< T > &f)
| 指定されたストリームに，ポリゴンオブジェクトを整形して出力する
template<class T , class T1 , class T2 >
bool | convert_to_vertex_face_list (const facet_list< T > &facets, std::vector< vector3< T1 > > &vertices, std::vector< vector3< T2 > > &faces, const double eps=1.0e-6)
| 3角形パッチの集合から頂点集合と三角形パッチを構成するインデックス集合に変換する
template<class T >
bool | surface_simplification (facet_list< T > &facets, size_t number_of_facets, bool use_optimal_vertex_placement=true, double threshold_for_triangle_compactness=0.0, const double eps=1.0e-3)
| 3角形パッチの集合から頂点集合と三角形パッチを構成するインデックス集合に変換する
template<class T >
bool | maximum_connected_region (facet_list< T > &facets, const double eps=1.0e-3)
| 3角形パッチの集合から最大の連結領域のみを取り出し，他を全て削除する
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | dct (const array1< T1, Allocator1 > &in, array1< T2, Allocator2 > &out)
| 1次元高速コサイン変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | idct (const array1< T1, Allocator1 > &in, array1< T2, Allocator2 > &out)
| 1次元高速コサイン逆変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | dct (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out)
| 2次元高速コサイン変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | idct (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out)
| 2次元高速コサイン逆変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | dct (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out)
| 3次元高速コサイン変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | idct (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out)
| 3次元高速コサイン逆変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | dst (const array1< T1, Allocator1 > &in, array1< T2, Allocator2 > &out)
| 1次元高速サイン変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | idst (const array1< T1, Allocator1 > &in, array1< T2, Allocator2 > &out)
| 1次元高速サイン逆変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | dst (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out)
| 2次元高速サイン変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | idst (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out)
| 2次元高速サイン逆変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | dst (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out)
| 3次元高速サイン変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | idst (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out)
| 3次元高速サイン逆変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | fft (const array1< T1, Allocator1 > &in, array1< T2, Allocator2 > &out)
| 1次元高速フーリエ変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | ifft (const array1< T1, Allocator1 > &in, array1< T2, Allocator2 > &out)
| 1次元高速逆フーリエ変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | fft (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out)
| 2次元高速フーリエ変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | ifft (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out)
| 2次元高速逆フーリエ変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | fft (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out)
| 3次元高速フーリエ変換
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | ifft (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out)
| 3次元高速逆フーリエ変換
template<class T , class Allocator , class Functor >
array2< T, Allocator >::size_type | boundary4 (array2< T, Allocator > &in, typename array2< T, Allocator >::value_type border, typename array2< T, Allocator >::value_type inside, bool boundary_is_border, Functor f)
| 背景と4近傍で接する境界画素を抽出する
template<class T , class Allocator >
array2< T, Allocator >::size_type | boundary4 (array2< T, Allocator > &in, typename array2< T, Allocator >::value_type border, typename array2< T, Allocator >::value_type inside=0, bool boundary_is_border=true)
| 背景と4近傍で接する境界画素を抽出する
template<class T , class Allocator , class Functor >
array2< T, Allocator >::size_type | boundary8 (array2< T, Allocator > &in, typename array2< T, Allocator >::value_type border, typename array2< T, Allocator >::value_type inside, bool boundary_is_border, Functor f)
| 背景と8近傍で接する境界画素を抽出する
template<class T , class Allocator >
array2< T, Allocator >::size_type | boundary8 (array2< T, Allocator > &in, typename array2< T, Allocator >::value_type border, typename array2< T, Allocator >::value_type inside=0, bool boundary_is_border=true)
| 背景と8近傍で接する境界画素を抽出する
template<class T , class Allocator , class Functor >
array3< T, Allocator >::size_type | boundary6 (array3< T, Allocator > &in, typename array3< T, Allocator >::value_type border, typename array3< T, Allocator >::value_type inside, bool boundary_is_border, Functor f)
| 背景と6近傍で接する境界画素を抽出する
template<class T , class Allocator >
array3< T, Allocator >::size_type | boundary6 (array3< T, Allocator > &in, typename array3< T, Allocator >::value_type border, typename array3< T, Allocator >::value_type inside=0, bool boundary_is_border=true)
| 背景と6近傍で接する境界画素を抽出する
template<class T , class Allocator , class Functor >
array3< T, Allocator >::size_type | boundary18 (array3< T, Allocator > &in, typename array3< T, Allocator >::value_type border, typename array3< T, Allocator >::value_type inside, bool boundary_is_border, Functor f)
| 背景と18近傍で接する境界画素を抽出する
template<class T , class Allocator >
array3< T, Allocator >::size_type | boundary18 (array3< T, Allocator > &in, typename array3< T, Allocator >::value_type border, typename array3< T, Allocator >::value_type inside=0, bool boundary_is_border=true)
| 背景と18近傍で接する境界画素を抽出する
template<class T , class Allocator , class Functor >
array3< T, Allocator >::size_type | boundary26 (array3< T, Allocator > &in, typename array3< T, Allocator >::value_type border, typename array3< T, Allocator >::value_type inside, bool boundary_is_border, Functor f)
| 背景と26近傍で接する境界画素を抽出する
template<class T , class Allocator >
array3< T, Allocator >::size_type | boundary26 (array3< T, Allocator > &in, typename array3< T, Allocator >::value_type border, typename array3< T, Allocator >::value_type inside=0, bool boundary_is_border=true)
| 背景と18近傍で接する境界画素を抽出する
template<class T , class Allocator , template< typename, typename > class LIST, class TT , class AAllocator >
array2< T, Allocator > ::difference_type | harris (const array2< T, Allocator > &in, LIST< vector2< TT >, AAllocator > &out, typename array2< T, Allocator >::size_type max_corners, double min_distance, double kappa=0.04, typename array2< T, Allocator >::size_type window_size=3)
| Harrisのコーナー検出フィルタ
template<class Array1 , class Array2 , class Functor >
Array1::size_type | figure_decomposition (const Array1 &in, Array2 &out, double max_distance, Functor f)
| ユークリッド距離に基づく図形分割
template<class Array1 , class Array2 >
Array1::size_type | figure_decomposition (const Array1 &in, Array2 &out, double max_distance=-1)
| ユークリッド距離に基づく図形分割
template<class Array1 , class Array2 >
void | skeleton (const Array1 &in, Array2 &out)
| ユークリッド2乗距離画像を入力とするスケルトン抽出
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
bool | canny (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, double lower, double upper, bool useL2gradient=false, const typename array2< T2, Allocator2 >::value_type &fgval=typename array2< T2, Allocator2 >::value_type(255), const typename array2< T2, Allocator2 >::value_type &bgval=typename array2< T2, Allocator2 >::value_type(0), typename array2< T2, Allocator2 >::size_type thread_num=0)
| Cannyのエッジ検出フィルタ
template<class Array1 , class Array2 , class Fusion >
bool | fusion (const Array1 &in, Array2 &out, typename Array1::size_type length, typename Array1::size_type thread_num, Fusion fusion)
| 任意の距離タイプに対応した図形融合
template<class Array1 , class Array2 >
bool | expand_mdt (const Array1 &in, Array2 &out, typename Array1::size_type length=1, typename Array1::size_type thread_num=0)
| マンハッタン距離（L1ノルム，シティーブロック距離）タイプの図形拡大
template<class Array1 , class Array2 >
bool | shrink_mdt (const Array1 &in, Array2 &out, typename Array1::size_type length=1, typename Array1::size_type thread_num=0)
| マンハッタン距離（L1ノルム，シティーブロック距離）タイプの図形縮小
template<class T , class Allocator >
bool | interlace (const array2< T, Allocator > &in, array2< T, Allocator > &out, bool is_odd_line=false, bool is_row_interlace=true)
| 2次元画像のインターレス除去を行う
template<class T1 , class T2 , class Allocator1 , class Allocator2 , class Functor >
array2< T2, Allocator2 >::size_type | labeling4 (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, typename array2< T2, Allocator2 >::size_type max_label, Functor f)
| 2次元画像に対する4近傍型ラベリング
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
array2< T2, Allocator2 >::size_type | labeling4 (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, typename array2< T2, Allocator2 >::size_type max_label=__labeling_controller__::default_label_num2< T2 >::value)
| 2次元画像に対する4近傍型ラベリング
template<class T1 , class T2 , class Allocator1 , class Allocator2 , class Functor >
array2< T2, Allocator2 >::size_type | labeling8 (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, typename array2< T2, Allocator2 >::size_type max_label, Functor f)
| 2次元画像に対する8近傍型ラベリング
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
array2< T2, Allocator2 >::size_type | labeling8 (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, typename array2< T2, Allocator2 >::size_type max_label=__labeling_controller__::default_label_num2< T2 >::value)
| 2次元画像に対する8近傍型ラベリング
template<class T1 , class T2 , class Allocator1 , class Allocator2 , class Functor >
array3< T2, Allocator2 >::size_type | labeling6 (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T2, Allocator2 >::size_type max_label, Functor f)
| 3次元画像に対する6近傍型ラベリング
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
array3< T2, Allocator2 >::size_type | labeling6 (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T2, Allocator2 >::size_type max_label=__labeling_controller__::default_label_num3< T2 >::value)
| 3次元画像に対する6近傍型ラベリング
template<class T1 , class T2 , class Allocator1 , class Allocator2 , class Functor >
array3< T2, Allocator2 >::size_type | labeling18 (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T2, Allocator2 >::size_type max_label, Functor f)
| 3次元画像に対する18近傍型ラベリング
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
array3< T2, Allocator2 >::size_type | labeling18 (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T2, Allocator2 >::size_type max_label=__labeling_controller__::default_label_num3< T2 >::value)
| 3次元画像に対する18近傍型ラベリング
template<class T1 , class T2 , class Allocator1 , class Allocator2 , class Functor >
array3< T2, Allocator2 >::size_type | labeling26 (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T2, Allocator2 >::size_type max_label, Functor f)
| 3次元画像に対する26近傍型ラベリング
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
array3< T2, Allocator2 >::size_type | labeling26 (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T2, Allocator2 >::size_type max_label=__labeling_controller__::default_label_num3< T2 >::value)
| 3次元画像に対する26近傍型ラベリング
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
void | maximum_region (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, typename array2< T1, Allocator1 >::size_type sx, typename array2< T1, Allocator1 >::size_type ex, typename array2< T1, Allocator1 >::size_type sy, typename array2< T1, Allocator1 >::size_type ey, typename array2< T1, Allocator1 >::size_type max_label=__labeling_controller__::default_label_num2< T2 >::value)
| ある範囲内での最大のラベルを抽出する
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
void | maximum_region (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, typename array2< T1, Allocator1 >::size_type max_label=__labeling_controller__::default_label_num2< T2 >::value)
| 画像の全範囲内での最大のラベルを抽出する
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
void | maximum_region (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T1, Allocator1 >::size_type sx, typename array3< T1, Allocator1 >::size_type ex, typename array3< T1, Allocator1 >::size_type sy, typename array3< T1, Allocator1 >::size_type ey, typename array3< T1, Allocator1 >::size_type sz, typename array3< T1, Allocator1 >::size_type ez, typename array3< T1, Allocator1 >::size_type max_label=__labeling_controller__::default_label_num3< T2 >::value)
| ある範囲内での最大のラベルを抽出する
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
void | maximum_region (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T1, Allocator1 >::size_type max_label=__labeling_controller__::default_label_num3< T2 >::value)
| 画像の全範囲内での最大のラベルを抽出する
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
void | remove_hole_region (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, const bool include_corner_labels, typename array2< T1, Allocator1 >::size_type max_label=__labeling_controller__::default_label_num2< T2 >::value)
| 画像の0/1を反転させて穴埋め処理を行う
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
void | remove_hole_region (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, typename array2< T1, Allocator1 >::size_type max_label=__labeling_controller__::default_label_num2< T2 >::value)
| 画像の0/1を反転させて穴埋め処理を行う
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
void | remove_hole_region (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, const bool include_corner_labels, typename array3< T1, Allocator1 >::size_type max_label=__labeling_controller__::default_label_num3< T2 >::value)
| 画像の0/1を反転させて穴埋め処理を行う
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
void | remove_hole_region (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T1, Allocator1 >::size_type max_label=__labeling_controller__::default_label_num3< T2 >::value)
| 画像の0/1を反転させて穴埋め処理を行う
template<class T1 , class Allocator1 , class T2 , class Allocator2 , class Kernel >
bool | linear_filter (const array< T1, Allocator1 > &in, array< T2, Allocator2 > &out, const Kernel &kernel, typename array< T1, Allocator1 >::size_type thread_num=0)
| 一般の線形フィルタ( array )
template<class T1 , class Allocator1 , class T2 , class Allocator2 , class Kernel >
bool | linear_filter (const array1< T1, Allocator1 > &in, array1< T2, Allocator2 > &out, const Kernel &kernel, typename array1< T1, Allocator1 >::size_type thread_num=0)
| 一般の線形フィルタ( array1 )
template<class T1 , class Allocator1 , class T2 , class Allocator2 , class Kernel >
bool | linear_filter (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, const Kernel &kernel, typename array2< T1, Allocator1 >::size_type thread_num=0)
| 一般の線形フィルタ( array2 )
template<class T1 , class Allocator1 , class T2 , class Allocator2 , class Kernel >
bool | linear_filter (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, const Kernel &kernel, typename array3< T1, Allocator1 >::size_type thread_num=0)
| 一般の線形フィルタ( array3 )
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | laplacian_filter (const array< T1, Allocator1 > &in, array< T2, Allocator2 > &out, typename array< T1, Allocator1 >::size_type thread_num=0)
| ラプラシアン( array )
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | laplacian_filter (const array1< T1, Allocator1 > &in, array1< T2, Allocator2 > &out, typename array1< T1, Allocator1 >::size_type thread_num=0)
| ラプラシアン( array1 )
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | laplacian_filter (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, typename array2< T1, Allocator1 >::size_type thread_num=0)
| ラプラシアン( array2 )
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | laplacian_filter (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T1, Allocator1 >::size_type thread_num=0)
| ラプラシアン( array3 )
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | gaussian_filter (const array< T1, Allocator1 > &in, array< T2, Allocator2 > &out, const double sigma=1.0, typename array< T1, Allocator1 >::size_type thread_num=0)
| ガウシアンフィルタ( array )
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | gaussian_filter (const array1< T1, Allocator1 > &in, array1< T2, Allocator2 > &out, const double sigma=1.0, typename array1< T1, Allocator1 >::size_type thread_num=0)
| ガウシアンフィルタ( array1 )
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | gaussian_filter (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, const double sigma=1.0, typename array2< T1, Allocator1 >::size_type thread_num=0)
| ガウシアンフィルタ( array2 )
template<class T , class Allocator >
bool | gaussian_filter (array2< T, Allocator > &in, const double sigma=1.0, typename array2< T, Allocator >::size_type thread_num=0)
| ガウシアンフィルタ( array2 )
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | gaussian_filter (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, const double sigma=1.0, typename array3< T1, Allocator1 >::size_type thread_num=0)
| ガウシアンフィルタ( array3 )
template<class T , class Allocator >
bool | gaussian_filter (array3< T, Allocator > &in, const double sigma=1.0, typename array3< T, Allocator >::size_type thread_num=0)
| ガウシアンフィルタ( array3 )
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | average_filter (const array< T1, Allocator1 > &in, array< T2, Allocator2 > &out, typename array< T1, Allocator1 >::size_type fw, typename array< T1, Allocator1 >::size_type thread_num=0)
| 一様重み( array )
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | average_filter (const array1< T1, Allocator1 > &in, array1< T2, Allocator2 > &out, typename array1< T1, Allocator1 >::size_type fw, typename array1< T1, Allocator1 >::size_type thread_num=0)
| 一様重み( array1 )
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | average_filter (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, typename array2< T1, Allocator1 >::size_type fw, typename array2< T1, Allocator1 >::size_type fh, typename array2< T1, Allocator1 >::size_type thread_num=0)
| 一様重み( array2 )
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | average_filter (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T1, Allocator1 >::size_type fw, typename array3< T1, Allocator1 >::size_type fh, typename array3< T1, Allocator1 >::size_type fd, typename array3< T1, Allocator1 >::size_type thread_num=0)
| 一様重み( array3 )
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | median (const array< T1, Allocator1 > &in, array< T2, Allocator2 > &out, typename array< T1, Allocator1 >::size_type fw, typename array< T1, Allocator1 >::size_type thread_num=0)
| メディアン（中央値）フィルタを適用する
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | median (const array1< T1, Allocator1 > &in, array1< T2, Allocator2 > &out, typename array1< T1, Allocator1 >::size_type fw, typename array1< T1, Allocator1 >::size_type thread_num=0)
| メディアン（中央値）フィルタを適用する
template<class T1 , class Allocator1 , class T2 , class Allocator2 , class Functor >
bool | median (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, typename array2< T1, Allocator1 >::size_type fw, typename array2< T1, Allocator1 >::size_type fh, Functor f, typename array2< T1, Allocator1 >::size_type thread_num)
| メディアン（中央値）フィルタを適用する
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | median (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, typename array2< T1, Allocator1 >::size_type fw, typename array2< T1, Allocator1 >::size_type fh, typename array2< T1, Allocator1 >::size_type thread_num)
| メディアン（中央値）フィルタを適用する
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | median (const array2< T1, Allocator1 > &in, array2< T2, Allocator2 > &out, typename array2< T1, Allocator1 >::size_type fw, typename array2< T1, Allocator1 >::size_type thread_num=0)
| メディアン（中央値）フィルタを適用する
template<class T1 , class Allocator1 , class T2 , class Allocator2 , class Functor >
bool | median (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T1, Allocator1 >::size_type fw, typename array3< T1, Allocator1 >::size_type fh, typename array3< T1, Allocator1 >::size_type fd, Functor f, typename array3< T1, Allocator1 >::size_type thread_num)
| メディアン（中央値）フィルタを適用する
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | median (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T1, Allocator1 >::size_type fw, typename array3< T1, Allocator1 >::size_type fh, typename array3< T1, Allocator1 >::size_type fd, typename array3< T1, Allocator1 >::size_type thread_num)
| メディアン（中央値）フィルタを適用する
template<class T1 , class Allocator1 , class T2 , class Allocator2 >
bool | median (const array3< T1, Allocator1 > &in, array3< T2, Allocator2 > &out, typename array3< T1, Allocator1 >::size_type fw, typename array3< T1, Allocator1 >::size_type thread_num=0)
| メディアン（中央値）フィルタを適用する
template<class T , class Allocator , class Functor >
bool | mode (array2< T, Allocator > &in, const mode_filter::mode_structure &s, Functor f, typename array2< T, Allocator >::size_type thread_num)
| 任意の構造要素に対応した最頻値フィルタ
template<class T , class Allocator >
bool | mode (array2< T, Allocator > &in, const mode_filter::mode_structure &s, typename array2< T, Allocator >::size_type thread_num=0)
| 任意の構造要素に対応した最頻値フィルタ
template<class T , class Allocator , class Functor >
bool | mode (array2< T, Allocator > &in, double radius, Functor f, typename array2< T, Allocator >::size_type thread_num)
| 円を構造要素とする最頻値フィルタ
template<class T , class Allocator >
bool | mode (array2< T, Allocator > &in, double radius, typename array2< T, Allocator >::size_type thread_num=0)
| 円を構造要素とする最頻値フィルタ
template<class T , class Allocator , class Functor >
bool | mode (array3< T, Allocator > &in, const mode_filter::mode_structure &s, Functor f, typename array3< T, Allocator >::size_type thread_num)
| 任意の構造要素に対応した最頻値フィルタ
template<class T , class Allocator >
bool | mode (array3< T, Allocator > &in, const mode_filter::mode_structure &s, typename array3< T, Allocator >::size_type thread_num=0)
| 任意の構造要素に対応した最頻値フィルタ
template<class T , class Allocator , class Functor >
bool | mode (array3< T, Allocator > &in, double radius, Functor f, typename array3< T, Allocator >::size_type thread_num)
| 球を構造要素とする最頻値フィルタ
template<class T , class Allocator >
bool | mode (array3< T, Allocator > &in, double radius, typename array3< T, Allocator >::size_type thread_num=0)
| 球を構造要素とする最頻値フィルタ
template<class Array , class Functor >
bool | erosion (Array &in, const morphology::morphology_structure &s, Functor f, typename Array::size_type thread_num)
| 任意の構造要素に対応したErosion演算
template<class Array >
bool | erosion (Array &in, const morphology::morphology_structure &s, typename Array::size_type thread_num=0)
| 任意の構造要素に対応したErosion演算
template<class Array , class Functor >
bool | dilation (Array &in, const morphology::morphology_structure &s, Functor f, typename Array::size_type thread_num)
| 任意の構造要素に対応したDilation演算
template<class Array >
bool | dilation (Array &in, const morphology::morphology_structure &s, typename Array::size_type thread_num=0)
| 任意の構造要素に対応したDilation演算
template<class Array , class Functor >
bool | opening (Array &in, const morphology::morphology_structure &s, Functor f, typename Array::size_type thread_num)
| 任意の構造要素に対応したOpening演算
template<class Array >
bool | opening (Array &in, const morphology::morphology_structure &s, typename Array::size_type thread_num=0)
| 任意の構造要素に対応したOpening演算
template<class Array , class Functor >
bool | closing (Array &in, const morphology::morphology_structure &s, Functor f, typename Array::size_type thread_num)
| 任意の構造要素に対応したClosing演算
template<class Array >
bool | closing (Array &in, const morphology::morphology_structure &s, typename Array::size_type thread_num=0)
| 任意の構造要素に対応したClosing演算
template<class Array , class Functor >
bool | erosion (Array &in, double radius, Functor f, typename Array::size_type thread_num)
| 球を構造要素とするErosion演算
template<class Array , class Functor >
bool | dilation (Array &in, double radius, Functor f, typename Array::size_type thread_num)
| 球を構造要素とするDilation演算
template<class Array , class Functor >
bool | opening (Array &in, double radius, Functor f, typename Array::size_type thread_num)
| 球を構造要素とするOpening演算
template<class Array , class Functor >
bool | closing (Array &in, double radius, Functor f, typename Array::size_type thread_num)
| 球を構造要素とするClosing演算
template<class Array >
bool | erosion (Array &in, double radius, typename Array::size_type thread_num=0)
| 球を構造要素とするErosion演算
template<class Array >
bool | dilation (Array &in, double radius, typename Array::size_type thread_num=0)
| 球を構造要素とするDilation演算
template<class Array >
bool | opening (Array &in, double radius, typename Array::size_type thread_num=0)
| 球を構造要素とするOpening演算
template<class Array >
bool | closing (Array &in, double radius, typename Array::size_type thread_num=0)
| 球を構造要素とするClosing演算
template<class Array1 , class Array2 , class MaskType , class PointList , class Component , class Condition >
Array1::difference_type | region_growing (const Array1 &in, Array2 &out, const MaskType &mask, const PointList &start_points, typename Array2::value_type output_value, const Component &components, const Condition &condition, typename Array1::size_type max_paint)
| 任意の構造要素と条件を用いて領域拡張を行う関数
template<class Array1 , class Array2 , class PointList , class Component , class Condition >
Array1::difference_type | region_growing (const Array1 &in, Array2 &out, const PointList &start_points, typename Array2::value_type output_value, const Component &components, const Condition &condition, typename Array1::size_type max_paint=type_limits< typename Array1::size_type >::maximum())
| 任意の構造要素と条件を用いて領域拡張を行う関数
template<class T , class Allocator >
void | translation_matrix (matrix< T, Allocator > &mat, typename matrix< T, Allocator >::value_type x, typename matrix< T, Allocator >::value_type y)
| calculate translation matrix
template<class T , class Allocator >
void | rotation_matrix (matrix< T, Allocator > &mat, typename matrix< T, Allocator >::value_type radian)
| calculate rotation matrix
template<class T , class Allocator >
void | rotation_matrix (matrix< T, Allocator > &mat, typename matrix< T, Allocator >::value_type radian, typename matrix< T, Allocator >::value_type cx, typename matrix< T, Allocator >::value_type cy)
| calculate rotation matrix
template<class T , class Allocator >
void | scaling_matrix (matrix< T, Allocator > &mat, typename matrix< T, Allocator >::value_type x, typename matrix< T, Allocator >::value_type y)
| calculate scaling matrix
template<class T , class Allocator >
bool | homography_matrix (matrix< T, Allocator > &mat, const matrix< T, Allocator > &p1, const matrix< T, Allocator > &p2)
| calculate homography matrix
std::ostream & | operator<< (std::ostream &out, const hash_algorithm &h)
| 指定されたストリームにデータを出力する
template<class T >
bool | hilbert (const array< T > &in, array< std::complex< T > > &out, bool mirror=false)
| ヒルベルト変換
template<class T1 , class T2 >
size_t | emd (const array< T1 > &in, array< T2 > &imf, double sd=0.3)
| 経験的モード分解
template<class T , class Allocator >
std::ostream & | operator<< (std::ostream &out, const integral_image< array< T, Allocator > > &a)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
template<class T , class Allocator >
std::ostream & | operator<< (std::ostream &out, const integral_image< array1< T, Allocator > > &a)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
template<class T , class Allocator >
std::ostream & | operator<< (std::ostream &out, const integral_image< array2< T, Allocator > > &a)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
template<class T , class Allocator >
std::ostream & | operator<< (std::ostream &out, const integral_image< array3< T, Allocator > > &a)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
template<class T , class Allocator >
bool | read_bmp (array2< T, Allocator > &image, const std::string &filename)
| BMP画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_bmp (array2< T, Allocator > &image, const std::wstring &filename)
| BMP画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | write_bmp (const array2< T, Allocator > &image, const std::string &filename, typename array2< T, Allocator >::size_type bmp_bits=24)
| MISTコンテナの画像をBMP形式でファイルに出力する
template<class T , class Allocator >
bool | write_bmp (const array2< T, Allocator > &image, const std::wstring &filename, typename array2< T, Allocator >::size_type bmp_bits=24)
| MISTコンテナの画像をBMP形式でファイルに出力する
template<class Array >
bool | read_csv (Array &csv, const std::string &filename, const std::string &separator=", ")
| CSV形式のファイルをSTLコンテナに読み込む
template<class Array >
bool | read_csv (Array &csv, const std::wstring &filename, const std::wstring &separator=", ")
| CSV形式のファイルをSTLコンテナに読み込む
template<class T , class Allocator >
bool | read_csv (matrix< T, Allocator > &csv, const std::string &filename, const std::string &separator=", ")
| CSV形式のファイルをMISTコンテナ（mist::matrix）に読み込む
template<class T , class Allocator >
bool | read_csv (matrix< T, Allocator > &csv, const std::wstring &filename, const std::string &separator=", ")
| CSV形式のファイルをMISTコンテナ（mist::matrix）に読み込む
template<class T , class Allocator >
bool | read_dicom (array2< T, Allocator > &image, const std::string &filename)
| DICOMデータを画像コンテナに読み込む
template<class T , class Allocator >
bool | read_gif (array2< T, Allocator > &image, const std::string &filename)
| GIF画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_gif (array2< T, Allocator > &image, const std::wstring &filename)
| GIF画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_image (mist::array2< T, Allocator > &image, const std::string &filename)
| JPEG，TIFF，PNG，BMP，PNM，GIF 画像を拡張子に基づいてMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_image (mist::array2< T, Allocator > &image, const std::wstring &filename)
| JPEG，TIFF，PNG，BMP，PNM，GIF 画像を拡張子に基づいてMISTコンテナに読み込む
template<class T , class Allocator >
bool | write_image (const mist::array2< T, Allocator > &image, const std::string &filename)
| MISTコンテナの画像をTIFF形式でJPEG，TIFF，PNG，BMP，PNM，GIF 画像形式でファイルに出力する
template<class T , class Allocator >
bool | write_image (const mist::array2< T, Allocator > &image, const std::wstring &filename)
| MISTコンテナの画像をTIFF形式でJPEG，TIFF，PNG，BMP，PNM，GIF 画像形式でファイルに出力する
template<class T , class Allocator >
bool | read_jpeg (array2< T, Allocator > &image, const std::string &filename)
| JPEG画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_jpeg (array2< T, Allocator > &image, const std::wstring &filename)
| JPEG画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | write_jpeg (const array2< T, Allocator > &image, const std::string &filename, int quality=100)
| MISTコンテナの画像をJPEG形式でファイルに出力する
template<class T , class Allocator >
bool | write_jpeg (const array2< T, Allocator > &image, const std::wstring &filename, int quality=100)
| MISTコンテナの画像をJPEG形式でファイルに出力する
template<class T , class Allocator >
bool | read_jpeg2000 (array2< T, Allocator > &image, const std::string &filename)
| JPEG2000画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_jpeg2000 (array2< T, Allocator > &image, const std::wstring &filename)
| JPEG2000画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | write_jpeg2000 (const array2< T, Allocator > &image, const std::string &filename, double compression_level=0)
| MISTコンテナの画像をJPEG2000形式でファイルに出力する
template<class T , class Allocator >
bool | write_jpeg2000 (const array2< T, Allocator > &image, const std::wstring &filename, double compression_level=0)
| MISTコンテナの画像をJPEG2000形式でファイルに出力する
template<template< typename T, typename A > class Array, class Allocator >
bool | read_lines (Array< std::string, Allocator > &lines, const std::string &filename)
| 改行区切りのファイルをSTLコンテナに読み込む
template<template< typename T, typename A > class Array, class Allocator >
bool | read_lines (Array< std::string, Allocator > &lines, const std::wstring &filename)
| 改行区切りのファイルをSTLコンテナに読み込む
template<class T >
bool | read_mqo (std::vector< facet_list< T > > &facet_lists, const std::string &filename)
| Metasequoia形式のファイルからポリゴンデータを読み込む
template<class T >
bool | read_mqo (std::vector< facet_list< T > > &facet_lists, const std::wstring &filename)
| Metasequoia形式のファイルからポリゴンデータを読み込む
template<class T >
bool | read_mqo (facet_list< T > &facets, const std::string &filename)
| Metasequoia形式のファイルからポリゴンデータを読み込む
template<class T >
bool | read_mqo (facet_list< T > &facets, const std::wstring &filename)
| Metasequoia形式のファイルからポリゴンデータを読み込む
template<class T >
bool | write_mqo (const std::vector< facet_list< T > > &facet_lists, const std::string &filename)
| ポリゴンデータをMetasequoia形式で出力する
template<class T >
bool | write_mqo (const std::vector< facet_list< T > > &facet_lists, const std::wstring &filename)
| ポリゴンデータをMetasequoia形式で出力する
template<class T >
bool | write_mqo (const facet_list< T > &facets, const std::string &filename)
| ポリゴンデータをMetasequoia形式で出力する
template<class T >
bool | write_mqo (const facet_list< T > &facets, const std::wstring &filename)
| ポリゴンデータをMetasequoia形式で出力する
template<class T , class Allocator >
bool | read_png (array2< T, Allocator > &image, const std::string &filename)
| PNG画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_png (array2< T, Allocator > &image, const std::wstring &filename)
| PNG画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | write_png (const array2< T, Allocator > &image, const std::string &filename, int compression_level=6)
| MISTコンテナの画像をPNG形式でファイルに出力する
template<class T , class Allocator >
bool | write_png (const array2< T, Allocator > &image, const std::wstring &filename, int compression_level=6)
| MISTコンテナの画像をPNG形式でファイルに出力する
template<class T , class Allocator >
bool | read_pnm (array2< T, Allocator > &image, const std::string &filename, typename array2< T, Allocator >::size_type level=255)
| PNM画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_pnm (array2< T, Allocator > &image, const std::wstring &filename, typename array2< T, Allocator >::size_type level=255)
| PNM画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | write_pnm (const array2< T, Allocator > &image, const std::string &filename, typename array2< T, Allocator >::size_type pnm_type=6, typename array2< T, Allocator >::size_type level=255)
| MISTコンテナの画像をPNM形式でファイルに出力する
template<class T , class Allocator >
bool | write_pnm (const array2< T, Allocator > &image, const std::wstring &filename, typename array2< T, Allocator >::size_type pnm_type=6, typename array2< T, Allocator >::size_type level=255)
| MISTコンテナの画像をPNM形式でファイルに出力する
template<class T , class Allocator , class ValueType , class Functor >
bool | read_raw (array< T, Allocator > &image, const std::string &filename, typename array< T, Allocator >::size_type w, typename array< T, Allocator >::value_type offset, bool from_little_endian, ValueType __dmy__, Functor callback)
| 無圧縮RAW，GZ圧縮RAW 画像をMISTコンテナに読み込む
template<class T , class Allocator , class ValueType , class Functor >
bool | write_raw (const array< T, Allocator > &image, const std::string &filename, typename array< T, Allocator >::value_type offset, bool to_little_endian, ValueType __dmy__, Functor callback)
| MISTコンテナ内の画像を 無圧縮RAW 画像として出力する
template<class T , class Allocator , class ValueType , class Functor >
bool | write_raw_gz (const array< T, Allocator > &image, const std::string &filename, typename array< T, Allocator >::value_type offset, bool to_little_endian, ValueType __dmy__, Functor callback)
| MISTコンテナ内の画像を GZ圧縮RAW 画像として出力する
template<class T , class Allocator , class Functor >
bool | read_raw (array< T, Allocator > &image, const std::string &filename, typename array< T, Allocator >::size_type w, typename array< T, Allocator >::value_type offset, bool from_little_endian, Functor callback)
| 無圧縮RAW，GZ圧縮RAW 画像をMISTコンテナに読み込む
template<class T , class Allocator , class Functor >
bool | write_raw (const array< T, Allocator > &image, const std::string &filename, typename array< T, Allocator >::value_type offset, bool to_little_endian, Functor callback)
| MISTコンテナ内の画像を 無圧縮RAW 画像として出力する
template<class T , class Allocator , class Functor >
bool | write_raw_gz (const array< T, Allocator > &image, const std::string &filename, typename array< T, Allocator >::value_type offset, bool to_little_endian, Functor callback)
| MISTコンテナ内の画像を GZ圧縮RAW 画像として出力する
template<class T , class Allocator >
bool | read_raw (array< T, Allocator > &image, const std::string &filename, typename array< T, Allocator >::size_type w, typename array< T, Allocator >::value_type offset=0, bool from_little_endian=false)
| 無圧縮RAW，GZ圧縮RAW 画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | write_raw (const array< T, Allocator > &image, const std::string &filename, typename array< T, Allocator >::value_type offset=0, bool to_little_endian=false)
| MISTコンテナ内の画像を 無圧縮RAW 画像として出力する
template<class T , class Allocator >
bool | write_raw_gz (const array< T, Allocator > &image, const std::string &filename, typename array< T, Allocator >::value_type offset=typename array< T, Allocator >::value_type(0), bool to_little_endian=false)
| MISTコンテナ内の画像を GZ圧縮RAW 画像として出力する
template<class T , class Allocator , class ValueType , class Functor >
bool | read_raw (array1< T, Allocator > &image, const std::string &filename, typename array1< T, Allocator >::size_type w, double x, typename array1< T, Allocator >::value_type offset, bool from_little_endian, ValueType __dmy__, Functor callback)
| 無圧縮RAW，GZ圧縮RAW 画像をMISTコンテナに読み込む
template<class T , class Allocator , class Functor >
bool | read_raw (array1< T, Allocator > &image, const std::string &filename, typename array1< T, Allocator >::size_type w, double x, typename array1< T, Allocator >::value_type offset, bool from_little_endian, Functor callback)
| 無圧縮RAW，GZ圧縮RAW 画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_raw (array1< T, Allocator > &image, const std::string &filename, typename array1< T, Allocator >::size_type w, double x=1.0, typename array1< T, Allocator >::value_type offset=0, bool from_little_endian=false)
| 無圧縮RAW，GZ圧縮RAW 画像をMISTコンテナに読み込む
template<class T , class Allocator , class ValueType , class Functor >
bool | read_raw (array2< T, Allocator > &image, const std::string &filename, typename array2< T, Allocator >::size_type w, typename array2< T, Allocator >::size_type h, double x, double y, typename array2< T, Allocator >::value_type offset, bool from_little_endian, ValueType __dmy__, Functor callback)
| 無圧縮RAW，GZ圧縮RAW 画像をMISTコンテナに読み込む
template<class T , class Allocator , class Functor >
bool | read_raw (array2< T, Allocator > &image, const std::string &filename, typename array2< T, Allocator >::size_type w, typename array2< T, Allocator >::size_type h, double x, double y, typename array2< T, Allocator >::value_type offset, bool from_little_endian, Functor callback)
| 無圧縮RAW，GZ圧縮RAW 画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_raw (array2< T, Allocator > &image, const std::string &filename, typename array2< T, Allocator >::size_type w, typename array2< T, Allocator >::size_type h, double x=1.0, double y=1.0, typename array2< T, Allocator >::value_type offset=0, bool from_little_endian=false)
| 無圧縮RAW，GZ圧縮RAW 画像をMISTコンテナに読み込む
template<class T , class Allocator , class ValueType , class Functor >
bool | read_raw (array3< T, Allocator > &image, const std::string &filename, typename array3< T, Allocator >::size_type w, typename array3< T, Allocator >::size_type h, typename array3< T, Allocator >::size_type d, double x, double y, double z, typename array3< T, Allocator >::value_type offset, bool from_little_endian, ValueType __dmy__, Functor callback)
| 無圧縮RAW，GZ圧縮RAW 画像をMISTコンテナに読み込む
template<class T , class Allocator , class Functor >
bool | read_raw (array3< T, Allocator > &image, const std::string &filename, typename array3< T, Allocator >::size_type w, typename array3< T, Allocator >::size_type h, typename array3< T, Allocator >::size_type d, double x, double y, double z, typename array3< T, Allocator >::value_type offset, bool from_little_endian, Functor callback)
| 無圧縮RAW，GZ圧縮RAW 画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_raw (array3< T, Allocator > &image, const std::string &filename, typename array3< T, Allocator >::size_type w, typename array3< T, Allocator >::size_type h, typename array3< T, Allocator >::size_type d, double x=1.0, double y=1.0, double z=1.0, typename array3< T, Allocator >::value_type offset=typename array3< T, Allocator >::value_type(0), bool from_little_endian=false)
| 無圧縮RAW，GZ圧縮RAW 画像をMISTコンテナに読み込む
template<class T >
bool | read_stl (facet_list< T > &facets, const std::wstring &filename)
| STL（ASCII，バイナリ）形式のファイルからポリゴンデータを読み込む
template<class T >
bool | read_stl (facet_list< T > &facets, const std::string &filename)
| STL（ASCII，バイナリ）形式のファイルからポリゴンデータを読み込む
template<class T >
bool | write_stl (const facet_list< T > &facets, const std::wstring &filename, bool use_ascii_format=true)
| ポリゴンデータをSTL（ASCII，バイナリ）形式で出力する
template<class T >
bool | write_stl (const facet_list< T > &facets, const std::string &filename, bool use_ascii_format=true)
| ポリゴンデータをSTL（ASCII，バイナリ）形式で出力する
template<class T , class Allocator >
bool | read_tga (array2< T, Allocator > &image, const std::string &filename)
| TGA画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_tga (array2< T, Allocator > &image, const std::wstring &filename)
| TGA画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | write_tga (const array2< T, Allocator > &image, const std::string &filename, typename array2< T, Allocator >::size_type tga_bits=32, bool is_encode_RLE=true)
| MISTコンテナの画像をTGA形式でファイルに出力する
template<class T , class Allocator >
bool | write_tga (const array2< T, Allocator > &image, const std::wstring &filename, typename array2< T, Allocator >::size_type tga_bits=32, bool is_encode_RLE=true)
| MISTコンテナの画像をTGA形式でファイルに出力する
template<class T , class Allocator >
bool | read_tiff (array2< T, Allocator > &image, const std::string &filename)
| TIFF画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_tiff (array2< T, Allocator > &image, const std::wstring &filename)
| TIFF画像をMISTコンテナに読み込む
template<class T , class Allocator >
bool | write_tiff (const array2< T, Allocator > &image, const std::string &filename, bool use_lzw_compression=_LZW_COMPRESSION_SUPPORT_)
| MISTコンテナの画像をTIFF形式でファイルに出力する
template<class T , class Allocator >
bool | write_tiff (const array2< T, Allocator > &image, const std::wstring &filename, bool use_lzw_compression=_LZW_COMPRESSION_SUPPORT_)
| MISTコンテナの画像をTIFF形式でファイルに出力する
template<class T , class Allocator >
bool | read_wav (array< T, Allocator > &sound, const std::string &filename, unsigned int &sampling_rate)
| WAVファイルから音声データををMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_wav (array< T, Allocator > &sound, const std::wstring &filename, unsigned int &sampling_rate)
| WAVファイルから音声データををMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_wav (array< T, Allocator > &sound, const std::string &filename)
| WAVファイルから音声データををMISTコンテナに読み込む
template<class T , class Allocator >
bool | read_wav (array< T, Allocator > &sound, const std::wstring &filename)
| WAVファイルから音声データををMISTコンテナに読み込む
template<class T , class Allocator >
bool | write_wav (const array< T, Allocator > &sound, const std::string &filename, typename array< T, Allocator >::size_type wav_bits, typename array< T, Allocator >::size_type sampling_rate)
| MISTコンテナのデータをWAVファイルへ出力する
template<class T , class Allocator >
bool | write_wav (const array< T, Allocator > &sound, const std::wstring &filename, typename array< T, Allocator >::size_type wav_bits, typename array< T, Allocator >::size_type sampling_rate)
| MISTコンテナのデータをWAVファイルへ出力する
template<class T >
const T | limits_min_max (const T &v, const T &min, const T &max)
| 入力されたデータを min から max の範囲に変換する
template<class T >
const T | limits_0_255 (const T &v)
| 入力されたデータを 0 から 255 の範囲に変換する
template<class T , class Allocator >
inline::std::ostream & | operator<< (::std::ostream &out, const matrix< T, Allocator > &m)
| 指定されたストリームに，行列内の要素を整形して出力する
template<class T , class Allocator >
matrix< T, Allocator > | operator+ (const matrix< T, Allocator > &m1, const matrix< T, Allocator > &m2)
| 足し算
template<class T , class Allocator >
matrix< T, Allocator > | operator- (const matrix< T, Allocator > &m1, const matrix< T, Allocator > &m2)
| 引き算
template<class T , class Allocator >
matrix< T, Allocator > | operator* (const matrix< T, Allocator > &m1, const matrix< T, Allocator > &m2)
| 掛け算
template<class T , class Allocator >
matrix< T, Allocator > | operator+ (const matrix< T, Allocator > &m, typename type_trait< T >::value_type val)
| 単位行列の定数倍との足し算
template<class T , class Allocator >
matrix< T, Allocator > | operator+ (typename matrix< T, Allocator >::value_type val, const matrix< T, Allocator > &m)
| 定数との足し算
template<class T , class Allocator >
matrix< T, Allocator > | operator- (const matrix< T, Allocator > &m, typename type_trait< T >::value_type val)
| 定数との引き算
template<class T , class Allocator >
matrix< T, Allocator > | operator- (typename matrix< T, Allocator >::value_type val, const matrix< T, Allocator > &m)
| 定数との引き算
template<class T , class Allocator >
matrix< T, Allocator > | operator* (const matrix< T, Allocator > &m, typename type_trait< T >::value_type val)
| 定数との掛け算
template<class T , class Allocator >
matrix< T, Allocator > | operator* (typename matrix< T, Allocator >::value_type val, const matrix< T, Allocator > &m)
| 定数との掛け算
template<class T , class Allocator >
matrix< T, Allocator > | operator/ (const matrix< T, Allocator > &m, typename type_trait< T >::value_type val)
bool | cut_detection (video::decoder &iv, std::vector< int > &frame_indeces, size_t red_bin=8, size_t green_bin=8, size_t blue_bin=8, double threshold_of_similarity=0.95, ptrdiff_t number_of_between_frames=30)
| ビデオストリームを入力し，ビデオ内のカット位置を検出する
template<class Functor >
bool | enclose (double &a, double &b, double &c, double &fa, double &fb, double &fc, Functor f, size_t max_iterations=100)
| f(x)の一次元探索において，極小値を与える x を囲む区間を決定する
template<class T , class Allocator >
std::ostream & | operator<< (std::ostream &out, const array< T, Allocator > &a)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
template<class T , class Allocator >
std::ostream & | operator<< (std::ostream &out, const array1< T, Allocator > &a)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
template<class T , class Allocator >
std::ostream & | operator<< (std::ostream &out, const array2< T, Allocator > &a)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
template<class T , class Allocator >
std::ostream & | operator<< (std::ostream &out, const array3< T, Allocator > &a)
| 指定されたストリームに，コンテナ内の要素を整形して出力する
template<class Array >
bool | estimate_mixture (const Array &rSamples, mixture::distribution *opdp, size_t nSamples, size_t nComponents, size_t nMaxIteration, double tolerance, size_t &nIteration)
| データ系列から正規分布の混合分布を推定する
template<class Array >
bool | estimate_mixture (const Array &rSamples, mixture::distribution2 *opdp, size_t nSamples, size_t nComponents, size_t nMaxIteration, double tolerance, size_t &nIteration)
| データ系列から正規分布の混合分布を推定する
template<class Array1 , class Array2 >
bool | estimate_mixture (const Array1 &rSamples, Array2 &pdp, typename Array1::size_type nMaxIteration, double tolerance, typename Array1::size_type &nIteration)
| データ系列から正規分布の混合分布を推定する
template<class Array1 , class Array2 >
bool | estimate_mixture (const Array1 &rSamples, Array2 &pdp, typename Array1::size_type nMaxIteration, double tolerance)
| データ系列から1次元正規分布の混合分布を推定する
template<class Array >
bool | estimate_mixture (const Array &rSamples, mixture::distribution *pdp, typename Array::size_type nComponents, typename Array::size_type nMaxIteration, double tolerance)
| データ系列から正規分布の混合分布を推定する
template<class Array >
bool | estimate_mixture (const Array &rSamples, mixture::distribution2 *pdp, typename Array::size_type nComponents, typename Array::size_type nMaxIteration, double tolerance)
| データ系列から2次元正規分布の混合分布を推定する
template<class T , class Allocator >
bool | multiply (const matrix< T, Allocator > &a, const matrix< T, Allocator > &b, matrix< T, Allocator > &c, bool a_is_transpose, bool b_is_transpose, typename matrix< T, Allocator >::value_type alpha, typename matrix< T, Allocator >::value_type beta)
| 行列×行列の演算を行う
template<class T , class Allocator >
bool | multiply (const matrix< T, Allocator > &a, const matrix< T, Allocator > &b, matrix< T, Allocator > &c, bool a_is_transpose=false, bool b_is_transpose=false)
| 行列×行列の演算を行う
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
void | permutation_matrix (const matrix< T1, Allocator1 > &pivot, matrix< T2, Allocator2 > &out)
| LU分解などで得られるピボット配列からピボット行列を作成
template<class T , class Allocator >
const matrix< T, Allocator > ::value_type | trace (const matrix< T, Allocator > &a)
| トレースの計算（対角成分の和）
template<class T , class Allocator >
const matrix< T, Allocator > ::value_type | det (const matrix< T, Allocator > &a, matrix_style::style style=matrix_style::ge)
| 行列式の計算
template<class T , class Allocator >
const matrix< T, Allocator > & | solve (const matrix< T, Allocator > &a, matrix< T, Allocator > &b, matrix_style::style style=matrix_style::ge)
| 行列の連立一次方程式を解く関数
template<class T , class Allocator1 , class Allocator2 >
const matrix< T, Allocator1 > | lu_factorization (const matrix< T, Allocator1 > &a, matrix< __clapack__::integer, Allocator2 > &pivot, matrix_style::style style=matrix_style::ge)
| 行列のLU分解を行う
template<class T , class Allocator >
bool | lu_factorization (const matrix< T, Allocator > &a, matrix< T, Allocator > &L, matrix< T, Allocator > &U, matrix< T, Allocator > &pivot, matrix_style::style style=matrix_style::ge)
| 行列のLU分解を行う
template<class T , class Allocator >
const matrix< T, Allocator > | lu_factorization (const matrix< T, Allocator > &a, matrix_style::style style=matrix_style::ge)
| 行列のLU分解を行う
template<class T , class Allocator >
const matrix< T, Allocator > | cholesky_factorization (const matrix< T, Allocator > &a, matrix_style::style style=matrix_style::sy)
| 対称行列のコレスキー分解を行う
template<class T , class Allocator >
void | qr_factorization (const matrix< T, Allocator > &a, matrix< T, Allocator > &Q, matrix< T, Allocator > &R, matrix_style::style style=matrix_style::ge)
| 行列のQR分解を行う
template<class T , class Allocator >
matrix< T, Allocator > | inverse (const matrix< T, Allocator > &a, matrix_style::style style=matrix_style::ge)
| 行列の逆行列をLU分解を用いて計算する
template<class T , class Allocator >
const matrix< T, Allocator > & | eigen (const matrix< T, Allocator > &a, matrix< T, Allocator > &eigen_value, matrix< T, Allocator > &eigen_vector, matrix_style::style style=matrix_style::ge)
| 行列の固有値・固有ベクトルを計算する
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
const matrix< T2, Allocator2 > & | svd (const matrix< T1, Allocator1 > &a, matrix< T1, Allocator1 > &u, matrix< T2, Allocator2 > &s, matrix< T1, Allocator1 > &vt, matrix_style::style style=matrix_style::ge)
| 行列の特異値分解を計算する
template<class T1 , class T2 , class Allocator1 , class Allocator2 >
const matrix< T2, Allocator2 > & | svd (const matrix< T1, Allocator1 > &a, matrix< T2, Allocator2 > &s, matrix< T1, Allocator1 > &vt, matrix_style::style style=matrix_style::ge)
| 行列の特異値分解を計算する
template<class Array1 , class Array2 , class Array3 >
bool | seamlessCloning (const Array1 &src, const Array2 &target, Array3 &out, const array2< unsigned char > &mask, const int offx=0, const int offy=0, const bool mix=false)
| 入力画像のマスク領域を対象画像に合成する
template<class Array1 , class Array2 >
bool | localColorChange (const Array1 &in, Array2 &out, const array2< unsigned char > &mask)
| 入力画像のマスク領域以外をグレースケールにする
template<class Array1 , class Array2 >
bool | localColorChange (const Array1 &in, Array2 &out, const array2< unsigned char > &mask, const rgb< double > multiplier)
| 入力画像のマスク領域だけ色成分を変更する
template<class T >
std::ostream & | operator<< (std::ostream &out, const quaternion< T > &q)
| クォータニオンの和
template<class T1 , class T2 >
const quaternion< double > | interpolate (const quaternion< T1 > &q1, const quaternion< T2 > &q2, double t)
| 球面線形補間を行う
template<class T >
const quaternion< T > | track_ball (const vector2< T > &p1, const vector2< T > &p2, const vector3< T > &axisX, const vector3< T > axisY, const vector3< T > axisZ, const typename vector3< T >::value_type &trackball_size)
| 仮想トラックボールの実装(左手座標系)
template<class T >
const quaternion< T > | track_ball (const vector2< T > &p1, const vector2< T > &p2, const vector3< T > &axisX, const vector3< T > axisY, const vector3< T > axisZ)
| 仮想トラックボールの実装(左手座標系)
template<class T >
const quaternion< T > | track_ball (const typename vector3< T >::value_type &x1, const typename vector3< T >::value_type &y1, const typename vector3< T >::value_type &x2, const typename vector3< T >::value_type &y2, const vector3< T > &axisX, const vector3< T > &axisY, const vector3< T > &axisZ, const typename vector3< T >::value_type &trackball_size)
| 仮想トラックボールの実装(左手座標系)
template<class T >
const quaternion< T > | track_ball (const typename vector3< T >::value_type &x1, const typename vector3< T >::value_type &y1, const typename vector3< T >::value_type &x2, const typename vector3< T >::value_type &y2, const vector3< T > &axisX, const vector3< T > &axisY, const vector3< T > &axisZ)
| 仮想トラックボールの実装(左手座標系)
template<int M, typename V , typename A >
tensor< M, V, A > | operator+ (const tensor< M, V, A > &t1, const tensor< M, V, A > &t2)
| addition operator to calculate summation of two tensors
template<int M, typename V , typename A >
tensor< M, V, A > | operator- (const tensor< M, V, A > &t1, const tensor< M, V, A > &t2)
| subtraction operator to calculate difference betwwen two tensors
template<int M, typename V , typename A >
tensor< M, V, A > | operator* (const tensor< M, V, A > &t, const typename type_trait< V >::value_type &v)
| multiplication operator to calculate product of a tensor and a value
template<int M, typename V , typename A >
tensor< M, V, A > | operator* (const typename type_trait< V >::value_type &v, const tensor< M, V, A > &t)
| multiplication operator to calculate product of a value and a tensor
template<int M, typename V , typename A >
tensor< M, V, A > | operator/ (const tensor< M, V, A > &t, const typename type_trait< V >::value_type &v)
| division operator to calculate quotient of a tensor and a value
template<int M, typename V , typename A >
inline::std::ostream & | operator<< (::std::ostream &o, const tensor< M, V, A > &t)
| output stream operator
template<typename TV , typename TA , typename MV , typename MA >
void | hosvd (const tensor< 2, TV, TA > &t, tensor< 2, TV, TA > &z, matrix< MV, MA > &u1, matrix< MV, MA > &u2)
| apply higher order singular value decomposition (HOSVD) to a 2nd order tensor
template<typename TV , typename TA , typename MV , typename MA >
void | hosvd (const tensor< 3, TV, TA > &t, tensor< 3, TV, TA > &z, matrix< MV, MA > &u1, matrix< MV, MA > &u2, matrix< MV, MA > &u3)
| apply higher order singular value decomposition (HOSVD) to a 3rd order tensor
template<typename TV , typename TA , typename MV , typename MA >
void | hosvd (const tensor< 4, TV, TA > &t, tensor< 4, TV, TA > &z, matrix< MV, MA > &u1, matrix< MV, MA > &u2, matrix< MV, MA > &u3, matrix< MV, MA > &u4)
| apply higher order singular value decomposition (HOSVD) to a 4th order tensor
template<typename TV , typename TA , typename MV , typename MA >
void | hosvd (const tensor< 5, TV, TA > &t, tensor< 5, TV, TA > &z, matrix< MV, MA > &u1, matrix< MV, MA > &u2, matrix< MV, MA > &u3, matrix< MV, MA > &u4, matrix< MV, MA > &u5)
| apply higher order singular value decomposition (HOSVD) to a 5th order tensor
size_t | get_cpu_num ()
| 利用可能なCPU数を取得する
void | sleep (size_t dwMilliseconds)
| 指定した時間だけスリープする（ミリ秒単位）
template<class Thread >
bool | do_threads_ (Thread *threads, size_t num_threads, unsigned long dwMilliseconds=INFINITE)
| スレッド生成・終了待機・スレッドの破棄までを一連の流れとして行う
template<class Thread >
bool | do_threads_ (Thread **threads, size_t num_threads, unsigned long dwMilliseconds=INFINITE)
| スレッド生成・終了待機・スレッドの破棄までを一連の流れとして行う
template<class Thread >
bool | do_threads (Thread *threads, size_t num_threads, unsigned long dwMilliseconds=INFINITE)
| スレッド生成・終了待機・スレッドの破棄までを一連の流れとして行う
template<class Param , class Functor >
thread_handle | create_thread (Param &param, Functor f)
| 指定したスレッド関数を利用する，スレッドを作成する
template<class Param , class Functor >
void | create_threads (thread_handle *handles, Param *param, size_t num_threads, Functor f)
| 指定したスレッド関数を利用する，スレッドを複数作成する
bool | close_thread (thread_handle &thread_)
| スレッドが使用していたリソースを開放する
bool | close_threads (thread_handle *handles, size_t num_threads)
| 複数のスレッドが使用していたリソースを開放する
bool | wait_thread (thread_handle &thread_, unsigned long dwMilliseconds=INFINITE)
| スレッドが終了するか，タイムアウトが発生するまで待機する
bool | wait_threads (thread_handle *handles, size_t num_threads, unsigned long dwMilliseconds=INFINITE)
| 複数のスレッドが使用していたリソースを開放する
template<class Param , class Functor >
bool | do_thread (Param &param, Functor f, unsigned long dwMilliseconds=INFINITE)
| スレッド生成・終了待機・スレッドの破棄までを一連の流れとして行う
template<class Param , class Functor >
bool | do_threads (Param *params, size_t num_threads, Functor f, unsigned long dwMilliseconds=INFINITE)
| スレッド生成・終了待機・スレッドの破棄までを一連の流れとして行う
inline::std::ostream & | operator<< (::std::ostream &out, const timer &t)
| 経過時間を標準出力に出力する．
inline::std::ostream & | operator<< (::std::ostream &out, const stopwatch &t)
| 経過時間を標準出力に出力する．
std::vector< vector3< double > > | balloon (size_t number_of_division)
| 正20面体を分割して，球面上の方向集合を取得する
std::vector< vector3< double > > | half_balloon (size_t number_of_division)
| 正20面体を分割して，球面上の方向集合を取得する
template<class T , class Allocator >
bool | extract_mesh (array2< T, Allocator > &chart, matrix< vector2< double > > &grid, typename array2< T, Allocator >::difference_type row, typename array2< T, Allocator >::difference_type col, double threshold_for_circular_ratio=0.4)
| 円を格子状に並べた画像から，各点を抽出しメッシュ上の点と対応付ける
template<class T1 , class T2 >
promote_trait< T1, T2 >::value_type | operator^ (const vector3< T1 > &v1, const vector3< T2 > &v2)
| ベクトルの内積
template<class T >
std::ostream & | operator<< (std::ostream &out, const vector3< T > &v)
| ベクトルの和
template<class T >
std::istream & | operator>> (std::istream &in, vector3< T > &v)
| Method for reading the vector comma separated from an istream.
template<class T1 , class T2 >
promote_trait< T1, T2 >::value_type | operator^ (const vector2< T1 > &v1, const vector2< T2 > &v2)
| ベクトルの内積
template<class T1 , class T2 >
promote_trait< T1, T2 >::value_type | operator* (const vector2< T1 > &v1, const vector2< T2 > &v2)
| ベクトルの外積
template<class T >
std::ostream & | operator<< (std::ostream &out, const vector2< T > &v)
| ベクトルの和
template<class T >
std::istream & | operator>> (std::istream &in, vector2< T > &v)
| Method for reading the vector comma separated from an istream.
template<class T , class Allocator >
inline::std::ostream & | operator<< (::std::ostream &out, const vector< T, Allocator > &v)
| 指定されたストリームに，行列内の要素を整形して出力する
template<class T , class Allocator >
vector< T, Allocator > | operator* (const vector< T, Allocator > &v1, const vector< T, Allocator > &v2)
| ベクトルの外積を計算する
template<class Array1 , class Array2 , class DepthMap , class Renderer , class ATTRIBUTETYPE >
bool | volumerendering (const Array1 &in, Array2 &out, const DepthMap &dmap, const Renderer &renderer, const volumerender::parameter &param, const volumerender::attribute_table< ATTRIBUTETYPE > &table, typename Array1::size_type thread_num=0)
| ボリュームレンダリング
template<class Array1 , class Array2 , class DepthMap , class ATTRIBUTETYPE >
bool | volumerendering (const Array1 &in, Array2 &out, const DepthMap &dmap, const volumerender::parameter &param, const volumerender::attribute_table< ATTRIBUTETYPE > &table, typename Array1::size_type thread_num=0)
| ボリュームレンダリング
template<class Array1 , class Array2 , class ATTRIBUTETYPE >
bool | volumerendering (const Array1 &in, Array2 &out, const volumerender::parameter &param, const volumerender::attribute_table< ATTRIBUTETYPE > &table, typename Array1::size_type thread_num=0)
| ボリュームレンダリング
template<class Array1 , class Array2 , class Array3 , class DepthMap , class ATTRIBUTETYPE >
bool | volumerendering (const Array1 &in, const Array2 &mk, Array3 &out, const DepthMap &dmap, const volumerender::parameter &param, const volumerender::attribute_table< ATTRIBUTETYPE > &table, const volumerender::attribute_table< ATTRIBUTETYPE > &mktable, typename Array1::size_type thread_num=0)
| ボリュームレンダリング
template<class Array1 , class Array2 , class Array3 , class DepthMap , class ATTRIBUTETYPE >
bool | volumerendering (const Array1 &in, const Array2 &mk, Array3 &out, const DepthMap &dmap, const volumerender::parameter &param, const volumerender::attribute_table< ATTRIBUTETYPE > &table, const volumerender::attribute_table< ATTRIBUTETYPE > &mktable, bool apply_and_operation, typename Array1::size_type thread_num=0)
| ボリュームレンダリング
template<class Array1 , class Array2 , class Array3 , class ATTRIBUTETYPE >
bool | volumerendering (const Array1 &in, const Array2 &mk, Array3 &out, const volumerender::parameter &param, const volumerender::attribute_table< ATTRIBUTETYPE > &table, const volumerender::attribute_table< ATTRIBUTETYPE > &mktable, typename Array1::size_type thread_num=0)
| ボリュームレンダリング
template<class Array1 , class Array2 , class Array3 , class ATTRIBUTETYPE >
bool | volumerendering (const Array1 &in, const Array2 &mk, Array3 &out, const volumerender::parameter &param, const volumerender::attribute_table< ATTRIBUTETYPE > &table, const volumerender::attribute_table< ATTRIBUTETYPE > &mktable, bool apply_and_operation, typename Array1::size_type thread_num=0)
| ボリュームレンダリング
template<class Array1 , class Array2 >
bool | mip (const Array1 &in, Array2 &out, const volumerender::parameter &p, typename Array1::size_type thread_num=0)
| ボリュームレンダリング
template<class Array , class DepthMap , class Renderer , class T >
volumerender::parameter::vector_type | collision_detection (const Array &in, typename Array::size_type image_width, typename Array::size_type image_height, double resoX, double resoY, const DepthMap &dmap, const Renderer &renderer, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, typename Array::size_type i, typename Array::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array1 , class Array2 , class DepthMap , class Renderer , class T >
volumerender::parameter::vector_type | collision_detection (const Array1 &in, const Array2 &out, const DepthMap &dmap, const Renderer &renderer, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, typename Array1::size_type i, typename Array1::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array , class DepthMap , class T >
volumerender::parameter::vector_type | collision_detection (const Array &in, typename Array::size_type image_width, typename Array::size_type image_height, double resoX, double resoY, const DepthMap &dmap, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, typename Array::size_type i, typename Array::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array1 , class Array2 , class DepthMap , class T >
volumerender::parameter::vector_type | collision_detection (const Array1 &in, const Array2 &out, const DepthMap &dmap, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, typename Array1::size_type i, typename Array1::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array , class T >
volumerender::parameter::vector_type | collision_detection (const Array &in, typename Array::size_type image_width, typename Array::size_type image_height, double resoX, double resoY, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, typename Array::size_type i, typename Array::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array1 , class Array2 , class T >
volumerender::parameter::vector_type | collision_detection (const Array1 &in, const Array2 &out, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, typename Array1::size_type i, typename Array1::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array1 , class Array2 , class DepthMap , class T >
volumerender::parameter::vector_type | collision_detection (const Array1 &in, const Array2 &mk, typename Array1::size_type image_width, typename Array1::size_type image_height, double resoX, double resoY, const DepthMap &dmap, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, const volumerender::attribute_table< T > &mktable, typename Array1::size_type i, typename Array1::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array1 , class Array2 , class Array3 , class DepthMap , class T >
volumerender::parameter::vector_type | collision_detection (const Array1 &in, const Array2 &mk, const Array3 &out, const DepthMap &dmap, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, const volumerender::attribute_table< T > &mktable, typename Array1::size_type i, typename Array1::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array1 , class Array2 , class DepthMap , class T >
volumerender::parameter::vector_type | collision_detection (const Array1 &in, const Array2 &mk, typename Array1::size_type image_width, typename Array1::size_type image_height, double resoX, double resoY, const DepthMap &dmap, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, const volumerender::attribute_table< T > &mktable, bool apply_and_operation, typename Array1::size_type i, typename Array1::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array1 , class Array2 , class Array3 , class DepthMap , class T >
volumerender::parameter::vector_type | collision_detection (const Array1 &in, const Array2 &mk, const Array3 &out, const DepthMap &dmap, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, const volumerender::attribute_table< T > &mktable, bool apply_and_operation, typename Array1::size_type i, typename Array1::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array1 , class Array2 , class T >
volumerender::parameter::vector_type | collision_detection (const Array1 &in, const Array2 &mk, typename Array1::size_type image_width, typename Array1::size_type image_height, double resoX, double resoY, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, const volumerender::attribute_table< T > &mktable, typename Array1::size_type i, typename Array1::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array1 , class Array2 , class Array3 , class T >
volumerender::parameter::vector_type | collision_detection (const Array1 &in, const Array2 &mk, const Array3 &out, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, const volumerender::attribute_table< T > &mktable, typename Array1::size_type i, typename Array1::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array1 , class Array2 , class T >
volumerender::parameter::vector_type | collision_detection (const Array1 &in, const Array2 &mk, typename Array1::size_type image_width, typename Array1::size_type image_height, double resoX, double resoY, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, const volumerender::attribute_table< T > &mktable, bool apply_and_operation, typename Array1::size_type i, typename Array1::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array1 , class Array2 , class Array3 , class T >
volumerender::parameter::vector_type | collision_detection (const Array1 &in, const Array2 &mk, const Array3 &out, const volumerender::parameter &param, const volumerender::attribute_table< T > &table, const volumerender::attribute_table< T > &mktable, bool apply_and_operation, typename Array1::size_type i, typename Array1::size_type j)
| 衝突判定ルーチン（MISTのボリュームレンダリングエンジンで利用）
template<class Array , class DepthMap , class ATTRIBUTETYPE >
bool | generate_depth_map (const Array &in, DepthMap &dmap, const volumerender::attribute_table< ATTRIBUTETYPE > &table, typename Array::size_type thread_num=0)
| ボリュームレンダリング

## 説明

MISTプロジェクトの名前空間． すべての関数・クラスは mist 名前空間に含まれる．

## 関数

template<typename T , class Allocator >

double mist::autocorrelation | ( | const array1< T, Allocator > & | signal,
|  | int | tau,
|  | bool | biased = `true`
| ) |  |
| inline

Autocorrelation.

引数

  [in] | signal | is input data
  [in] | tau | is lag
  [in] | biased | is normalization factor

戻り値
  autocorrelation value

参照先 autocorrelation(), と cross_correlation().

参照元 autocorrelation().

template<typename T >

double mist::cross_correlation | ( | const array1< T > & | signal1,
|  | const array1< T > & | signal2,
|  | int | tau,
|  | bool | biased = `true`
| ) |  |
| inline

Cross correlation.

引数

  [in] | signal1 | is input data 1
  [in] | signal2 | is input data 2
  [in] | tau | is lag
  [in] | biased | is normalization factor

戻り値
  cross correlation value

参照先 cross_correlation(), と mist::array< T, Allocator >::size().

参照元 autocorrelation(), と cross_correlation().

bool mist::cut_detection | ( | video::decoder & | iv,
|  | std::vector< int > & | frame_indeces,
|  | size_t | red_bin = `8`,
|  | size_t | green_bin = `8`,
|  | size_t | blue_bin = `8`,
|  | double | threshold_of_similarity = `0.95`,
|  | ptrdiff_t | number_of_between_frames = `30`
| ) |  |

ビデオストリームを入力し，ビデオ内のカット位置を検出する

使い方
#include <mist/mist.h>
#include <mist/io/video.h>
#include <mist/io/bmp.h>
#include <mist/timer.h>
#include <mist/media/cut.h>
#include <vector>
int main( int argc, char *argv[] )
{
typedef mist::video::decoder::size_type size_type;
typedef mist::video::decoder::difference_type difference_type;
mist::video::decoder iv;
std::string filename = "入力ビデオファイル名";
if( !iv.open( filename ) )
{
std::cerr << "Failed to open video file [" << filename << "]" << std::endl;
return( 1 );
}
std::vector< int > indeces;
mist::cut_detection( iv, indeces, 8, 8, 8, 0.95, 30 );
iv.close( );
// 再度ファイルを開く
if( !iv.open( filename ) )
{
std::cerr << "Failed to open video file [" << filename << "]" << std::endl;
return( 1 );
}
mist::array2< mist::rgb< unsigned char > > img;
for( size_type i = 1 ; i < indeces.size( ) ; i++ )
{
std::cout << indeces[ i ] << std::endl;
char fname[ 256 ];
sprintf( fname, "%04d-%04d.avi", indeces[ i - 1 ], indeces[ i ] );
mist::video::mpeg4::encoder ov( fname, iv.width( ), iv.height( ), 1, 30 );
while( !iv.is_eof( ) && iv.frame_id( ) < indeces[ i ] )
{
iv >> img;
ov << img;
}
ov.close( );
}
return( 0 );
}

引数

  [in] | iv | … カット検出を行うビデオファイルを開いた mist::video::decoder オブジェクト
  [out] | frame_indeces | … カット位置を出力するリスト
  [in] | red_bin | … 赤色成分のビン数
  [in] | green_bin | … 緑色成分のビン数
  [in] | blue_bin | … 青色成分のビン数
  [in] | threshold_of_similarity | … 色ヒストグラムの正規化相関に対するしきい値
  [in] | number_of_between_frames | … カット間の最小フレーム間隔

戻り値

  true | … カットの検出に成功
  false | … カットの検出に失敗

参照先 mist::video::decoder::frame_id(), mist::video::decoder::is_eof(), mist::video::decoder::read(), と mist::array3< T, Allocator >::resize().

template<class T , class Allocator >

bool mist::homography_matrix | ( | matrix< T, Allocator > & | mat,
|  | const matrix< T, Allocator > & | p1,
|  | const matrix< T, Allocator > & | p2
| ) |  |

calculate homography matrix

引数

  [out] | mat | is homography matrix
  [in] | p1,p2 | are input matrix(2x4)

戻り値
  success of calculation

参照先 mist::matrix< T, Allocator >::cols(), mist::matrix< T, Allocator >::resize(), mist::matrix< T, Allocator >::rows(), と svd().

template<typename TV , typename TA , typename MV , typename MA >

void mist::hosvd | ( | const tensor< 2, TV, TA > & | t,
|  | tensor< 2, TV, TA > & | z,
|  | matrix< MV, MA > & | u1,
|  | matrix< MV, MA > & | u2
| ) |  |
| inline

apply higher order singular value decomposition (HOSVD) to a 2nd order tensor

HOSVD decomposes a 2nd order tensor T as T = Z U_1 U_2. Here U_1 and U_2 are unitary matrices and a 2nd order tensor Z is called as a core tensor. Using 1-mode-unfolding matrix of T, this is described like SVD of a matrix as T_1 = U_1 S U_2^t Here S is a singular value matrix.

引数

  [in] | t | tensor to be decomposed
  [in,out] | z | core tensor of the tensor
  [in,out] | u1 | unitary matrix corresponding to the 1st mode
  [in,out] | u2 | unitary matrix corresponding to the 2nd mode

参照先 mist::tensor< M, V, A >::hosvd().

template<typename TV , typename TA , typename MV , typename MA >

void mist::hosvd | ( | const tensor< 3, TV, TA > & | t,
|  | tensor< 3, TV, TA > & | z,
|  | matrix< MV, MA > & | u1,
|  | matrix< MV, MA > & | u2,
|  | matrix< MV, MA > & | u3
| ) |  |
| inline

apply higher order singular value decomposition (HOSVD) to a 3rd order tensor

HOSVD decomposes a 3rd order tensor T as T = Z U_1 U_2 U_3. Here U_1, U_2, and U_3 are unitary matrices and a 3rd order tensor Z is called as a core tensor.

引数

  [in] | z | tensorto be decomposed
  [in,out] | z | core tensor of the tensor
  [in,out] | u1 | unitary matrix corresponding to the 1st mode
  [in,out] | u2 | unitary matrix corresponding to the 2nd mode
  [in,out] | u3 | unitary matrix corresponding to the 3rd mode

参照先 mist::tensor< M, V, A >::hosvd().

template<typename TV , typename TA , typename MV , typename MA >

void mist::hosvd | ( | const tensor< 4, TV, TA > & | t,
|  | tensor< 4, TV, TA > & | z,
|  | matrix< MV, MA > & | u1,
|  | matrix< MV, MA > & | u2,
|  | matrix< MV, MA > & | u3,
|  | matrix< MV, MA > & | u4
| ) |  |
| inline

apply higher order singular value decomposition (HOSVD) to a 4th order tensor

HOSVD decomposes a 4th order tensor T as T = Z U_1 U_2 U_3 U_4. Here U_1, U_2, U_3 and U_4 are unitary matrices and a 4th order tensor Z is called as a core tensor.

引数

  [in] | z | tensorto be decomposed
  [in,out] | z | core tensor of the tensor
  [in,out] | u1 | unitary matrix corresponding to the 1st mode
  [in,out] | u2 | unitary matrix corresponding to the 2nd mode
  [in,out] | u3 | unitary matrix corresponding to the 3rd mode
  [in,out] | u4 | unitary matrix corresponding to the 4th mode

参照先 mist::tensor< M, V, A >::hosvd().

template<typename TV , typename TA , typename MV , typename MA >

void mist::hosvd | ( | const tensor< 5, TV, TA > & | t,
|  | tensor< 5, TV, TA > & | z,
|  | matrix< MV, MA > & | u1,
|  | matrix< MV, MA > & | u2,
|  | matrix< MV, MA > & | u3,
|  | matrix< MV, MA > & | u4,
|  | matrix< MV, MA > & | u5
| ) |  |
| inline

apply higher order singular value decomposition (HOSVD) to a 5th order tensor

HOSVD decomposes a 5th order tensor T as T = Z U_1 U_2 U_3 U_4 U_5. Here U_1, U_2, U_3 and U_4 are unitary matrices and a 5th order tensor Z is called as a core tensor.

引数

  [in] | z | tensorto be decomposed
  [in,out] | z | core tensor of the tensor
  [in,out] | u1 | unitary matrix corresponding to the 1st mode
  [in,out] | u2 | unitary matrix corresponding to the 2nd mode
  [in,out] | u3 | unitary matrix corresponding to the 3rd mode
  [in,out] | u4 | unitary matrix corresponding to the 4th mode
  [in,out] | u5 | unitary matrix corresponding to the 5th mode

参照先 mist::tensor< M, V, A >::hosvd().

template<class T1 , class T2 >

const quaternion< double > mist::interpolate | ( | const quaternion< T1 > & | q1,
|  | const quaternion< T2 > & | q2,
|  | double | t
| ) |  |

球面線形補間を行う

引数

  [in] | q1 | … 補間もとのクォータニオン1
  [in] | q2 | … 補間もとのクォータニオン2
  [in] | t | … [0,1]の間の数値で，補間点

戻り値
  球面線形補間されたクォータニオン

参照先 mist::quaternion< T >::inner(), と mist::quaternion< T >::unit().

template<class Object1 , class Object2 >

bool mist::is_same_object | ( | const Object1 & | o1,
|  | const Object2 & | o2
| ) |  |
| inline

入力された2つのオブジェクトが同じもの（メモリ上で同じ位置にある）かどうかを判定する

引数

  [in] | o1 | … オブジェクト1
  [in] | o2 | … オブジェクト2

戻り値
  true … 入力された2つのオブジェクトは，メモリ上で同じ位置に存在している
  false … 入力された2つのオブジェクトは，別のメモリ上に存在している

参照元 mist::linear::filter(), mist::average::filter(), generate_depth_map(), mist::statistics::generate_histogram(), mist::nearest::interpolate(), mist::mean::interpolate(), mist::linear::interpolate(), mist::cubic::interpolate(), mist::BSpline::interpolate(), mist::sinc::interpolate(), median(), mip(), region_growing(), と volumerendering().

void mist::mist_debug_assertion | ( | ptrdiff_t | index | ) |
| inline

DEBUGでMISTをビルドした際に，1次元アクセスでの範囲外アクセスをチェックし，エラーの際に呼ばれる関数．

引数

  [in] | index | … MISTコンテナに対するアクセス要求位置

void mist::mist_debug_assertion | ( | ptrdiff_t | index1,
|  | ptrdiff_t | index2
| ) |  |
| inline

DEBUGでMISTをビルドした際に，2次元アクセスでの範囲外アクセスをチェックし，エラーの際に呼ばれる関数．

引数

  [in] | index1 | … MISTコンテナに対するX軸でのアクセス要求位置
  [in] | index2 | … MISTコンテナに対するY軸でのアクセス要求位置

void mist::mist_debug_assertion | ( | ptrdiff_t | index1,
|  | ptrdiff_t | index2,
|  | ptrdiff_t | index3
| ) |  |
| inline

DEBUGでMISTをビルドした際に，3次元アクセスでの範囲外アクセスをチェックし，エラーの際に呼ばれる関数．

引数

  [in] | index1 | … MISTコンテナに対するX軸でのアクセス要求位置
  [in] | index2 | … MISTコンテナに対するY軸でのアクセス要求位置
  [in] | index3 | … MISTコンテナに対するZ軸でのアクセス要求位置

template<int M, typename V , typename A >

tensor< M, V, A > mist::operator* | ( | const tensor< M, V, A > & | t,
|  | const typename type_trait< V >::value_type & | v
| ) |  |
| inline

multiplication operator to calculate product of a tensor and a value

引数

  [in] | t | tensor
  [in] | v | value

戻り値
  product of the tensor and the value

template<int M, typename V , typename A >

tensor< M, V, A > mist::operator* | ( | const typename type_trait< V >::value_type & | v,
|  | const tensor< M, V, A > & | t
| ) |  |
| inline

multiplication operator to calculate product of a value and a tensor

引数

  [in] | v | value
  [in] | t | tensor

戻り値
  product of the value and the tensor

template<class T , class Allocator >

matrix< T, Allocator > mist::operator* | ( | const matrix< T, Allocator > & | m1,
|  | const matrix< T, Allocator > & | m2
| ) |  |
| inline

掛け算

引数

  [in] | m1 | … 左辺値
  [in] | m2 | … 右辺値

戻り値
  掛け算結果

template<class T , class Allocator >

matrix< T, Allocator > mist::operator* | ( | const matrix< T, Allocator > & | m,
|  | typename type_trait< T >::value_type | val
| ) |  |
| inline

定数との掛け算

詳細な説明や関数の使用例を書く

引数

  [in] | m | … 行列
  [in] | val | … 定数

戻り値
  左辺値の行列を定数倍した結果

template<class T , class Allocator >

matrix< T, Allocator > mist::operator* | ( | typename matrix< T, Allocator >::value_type | val,
|  | const matrix< T, Allocator > & | m
| ) |  |
| inline

定数との掛け算

詳細な説明や関数の使用例を書く

引数

  [in] | val | … 定数
  [in] | m | … 行列

戻り値
  右辺値の行列を定数倍した結果

template<int M, typename V , typename A >

tensor< M, V, A > mist::operator+ | ( | const tensor< M, V, A > & | t1,
|  | const tensor< M, V, A > & | t2
| ) |  |
| inline

addition operator to calculate summation of two tensors

引数

  [in] | t1 | 1st tensor
  [in] | t2 | 2nd tensor

戻り値
  summation of the 1st tensor and the 2nd tensor

template<class T , class Allocator >

matrix< T, Allocator > mist::operator+ | ( | const matrix< T, Allocator > & | m1,
|  | const matrix< T, Allocator > & | m2
| ) |  |
| inline

足し算

引数

  [in] | m1 | … 左辺値
  [in] | m2 | … 右辺値

戻り値
  足し算結果

template<class T , class Allocator >

matrix< T, Allocator > mist::operator+ | ( | const matrix< T, Allocator > & | m,
|  | typename type_trait< T >::value_type | val
| ) |  |
| inline

単位行列の定数倍との足し算

詳細な説明や関数の使用例を書く

引数

  [in] | m | … 行列
  [in] | val | … 定数

戻り値
  左辺値の行列に単位行列の定数倍を足し算した結果

template<class T , class Allocator >

matrix< T, Allocator > mist::operator+ | ( | typename matrix< T, Allocator >::value_type | val,
|  | const matrix< T, Allocator > & | m
| ) |  |
| inline

定数との足し算

詳細な説明や関数の使用例を書く

引数

  [in] | val | … 定数
  [in] | m | … 行列

戻り値
  右辺値の行列に単位行列の定数倍を足し算した結果

template<int M, typename V , typename A >

tensor< M, V, A > mist::operator- | ( | const tensor< M, V, A > & | t1,
|  | const tensor< M, V, A > & | t2
| ) |  |
| inline

subtraction operator to calculate difference betwwen two tensors

引数

  [in] | t1 | 1st tensor
  [in] | t2 | 2nd tensor

戻り値
  difference between the 1st tensor and the 2nd tensor

template<class T , class Allocator >

matrix< T, Allocator > mist::operator- | ( | const matrix< T, Allocator > & | m1,
|  | const matrix< T, Allocator > & | m2
| ) |  |
| inline

引き算

引数

  [in] | m1 | … 左辺値
  [in] | m2 | … 右辺値

戻り値
  引き算結果

template<class T , class Allocator >

matrix< T, Allocator > mist::operator- | ( | const matrix< T, Allocator > & | m,
|  | typename type_trait< T >::value_type | val
| ) |  |
| inline

定数との引き算

詳細な説明や関数の使用例を書く

引数

  [in] | m | … 行列
  [in] | val | … 定数

戻り値
  左辺値の行列から，単位行列を定数倍したものを引き算した結果

template<class T , class Allocator >

matrix< T, Allocator > mist::operator- | ( | typename matrix< T, Allocator >::value_type | val,
|  | const matrix< T, Allocator > & | m
| ) |  |
| inline

定数との引き算

詳細な説明や関数の使用例を書く

引数

  [in] | val | … 定数
  [in] | m | … 行列

戻り値
  単位行列を定数倍したものから右辺値の行列を引き算した結果

template<int M, typename V , typename A >

tensor< M, V, A > mist::operator/ | ( | const tensor< M, V, A > & | t,
|  | const typename type_trait< V >::value_type & | v
| ) |  |
| inline

division operator to calculate quotient of a tensor and a value

引数

  [in] | t | tensor
  [in] | v | value

戻り値
  quotient of the tensor and the value

template<class T , class Allocator >

matrix< T, Allocator > mist::operator/ | ( | const matrix< T, Allocator > & | m,
|  | typename type_trait< T >::value_type | val
| ) |  |
| inline

詳細な説明や関数の使用例を書く

引数

  [in] | m | … 行列
  [in] | val | … 定数

戻り値
  左辺値の行列を定数で割り算した結果

inline ::std::ostream& mist::operator<< | ( | ::std::ostream & | out,
|  | const timer & | t
| ) |  |

経過時間を標準出力に出力する．

引数

  [in,out] | out | … 引数の説明
  [in] | t | … 引数の説明

戻り値
  戻り値の説明

参照先 mist::timer::elapse().

inline ::std::ostream& mist::operator<< | ( | ::std::ostream & | out,
|  | const stopwatch & | t
| ) |  |

経過時間を標準出力に出力する．

引数

  [in,out] | out | … 引数の説明
  [in] | t | … 引数の説明

戻り値
  戻り値の説明

参照先 mist::stopwatch::elapse().

std::ostream& mist::operator<< | ( | std::ostream & | out,
|  | const binary & | b
| ) |  |
| inline

指定されたストリームに，コンテナ内の要素を整形して出力する

引数

  [in,out] | out | … 入力と出力を行うストリーム
  [in] | b | … バイナリ画素

戻り値
  入力されたストリーム

出力例
1

参照先 mist::binary::get_value().

template<class T >

std::ostream& mist::operator<< | ( | std::ostream & | out,
|  | const stereo< T > & | s
| ) |  |
| inline

ステレオ音声データの和

ステレオ音声データと定数の和 定数とステレオ音声データの和 ステレオ音声データの差 ステレオ音声データと定数の差 定数とステレオ音声データの差 ステレオ音声データの積 ステレオ音声データと定数の積 定数とステレオ音声データの積 ステレオ音声データの割り算 ステレオ音声データを定数で割る ステレオ音声データの剰余 ステレオ音声データの | 演算 ステレオ音声データの & 演算 ステレオ音声データの ^ 演算 指定されたストリームに，コンテナ内の要素を整形して出力する

引数

  [in,out] | out | … 入力と出力を行うストリーム
  [in] | s | … ステレオ音声

戻り値
  入力されたストリーム

出力例
( 1, 2 )
template<size_t BITS, class Allocator >

std::ostream& mist::operator<< | ( | std::ostream & | out,
|  | const bitmap< BITS, Allocator > & | a
| ) |  |
| inline

指定されたストリームに，コンテナ内の要素を整形して出力する

引数

  [in,out] | out | … 入力と出力を行うストリーム
  [in] | a | … bitmap 配列

戻り値
  入力されたストリーム

出力例
1, 2, 3, 4
5, 6, 7, 8
9, 10, 11, 12

参照先 mist::bitmap< BITS, Allocator >::size1(), と mist::bitmap< BITS, Allocator >::size2().

template<class T >

std::ostream& mist::operator<< | ( | std::ostream & | out,
|  | const quaternion< T > & | q
| ) |  |
| inline

クォータニオンの和

クォータニオンと定数の和 定数とクォータニオンの和 クォータニオンの差 クォータニオンと定数の差 定数とクォータニオンの差 クォータニオンの積 クォータニオンと定数の積 定数とクォータニオンの積 クォータニオンの割り算 クォータニオンを定数で割る 指定されたストリームに，コンテナ内の要素を整形して出力する

引数

  [in,out] | out | … 入力と出力を行うストリーム
  [in] | q | … クォータニオン

戻り値
  入力されたストリーム

出力例
( 1, 2, 3, 4 )
template<int M, typename V , typename A >

inline ::std::ostream& mist::operator<< | ( | ::std::ostream & | o,
|  | const tensor< M, V, A > & | t
| ) |  |

output stream operator

引数

  [in,out] | o | output stream
  [in] | t | tensor

戻り値
  output stream

template<class T , class Allocator >

inline ::std::ostream& mist::operator<< | ( | ::std::ostream & | out,
|  | const matrix< T, Allocator > & | m
| ) |  |

指定されたストリームに，行列内の要素を整形して出力する

引数

  [in,out] | out | … 入力と出力を行うストリーム
  [in] | m | … 出力する行列

戻り値
  入力されたストリーム

出力例
1, 4, 7
2, 5, 8
3, 6, 9

参照先 mist::matrix< T, Allocator >::cols(), と mist::matrix< T, Allocator >::rows().

template<class T , class Allocator >

std::ostream& mist::operator<< | ( | std::ostream & | out,
|  | const array< T, Allocator > & | a
| ) |  |
| inline

指定されたストリームに，コンテナ内の要素を整形して出力する

引数

  [in,out] | out | … 入力と出力を行うストリーム
  [in] | a | … array 配列

戻り値
  入力されたストリーム

出力例
1, 2, 3, 4

参照先 mist::array< T, Allocator >::size(), と mist::array< T, Allocator >::size1().

template<class T , class Allocator >

std::ostream& mist::operator<< | ( | std::ostream & | out,
|  | const array1< T, Allocator > & | a
| ) |  |
| inline

指定されたストリームに，コンテナ内の要素を整形して出力する

引数

  [in,out] | out | … 入力と出力を行うストリーム
  [in] | a | … array1 配列

戻り値
  入力されたストリーム

出力例
1, 2, 3, 4

参照先 mist::array< T, Allocator >::size(), と mist::array< T, Allocator >::size1().

template<class T , class Allocator >

std::ostream& mist::operator<< | ( | std::ostream & | out,
|  | const array2< T, Allocator > & | a
| ) |  |
| inline

指定されたストリームに，コンテナ内の要素を整形して出力する

引数

  [in,out] | out | … 入力と出力を行うストリーム
  [in] | a | … array2 配列

戻り値
  入力されたストリーム

出力例
1, 2, 3, 4
5, 6, 7, 8
9, 10, 11, 12

参照先 mist::array2< T, Allocator >::size1(), と mist::array2< T, Allocator >::size2().

template<class T , class Allocator >

std::ostream& mist::operator<< | ( | std::ostream & | out,
|  | const array3< T, Allocator > & | a
| ) |  |
| inline

指定されたストリームに，コンテナ内の要素を整形して出力する

引数

  [in,out] | out | … 入力と出力を行うストリーム
  [in] | a | … array3 配列

戻り値
  入力されたストリーム

出力例
1, 2, 3, 4
5, 6, 7, 8
9, 10, 11, 12
----- separator -----
1, 2, 3, 4
5, 6, 7, 8
9, 10, 11, 12

参照先 mist::array3< T, Allocator >::size1(), mist::array3< T, Allocator >::size2(), と mist::array3< T, Allocator >::size3().

template<class T1 , class Allocator1 , class T2 , class Allocator2 , class T3 , class Allocator3 >

double mist::parcor | ( | const array1< T1, Allocator1 > & | cor,
|  | array1< T2, Allocator2 > & | alf,
|  | array1< T3, Allocator3 > & | ref,
|  | int | p
| ) |  |
| inline

Calculate PARCOR and linear predict cofficients from autocorrelation values.

引数

  [in] | cor | is autocorrelation values (the length should be p + 1)
  [out] | alf | is linear predict cofficients
  [out] | ref | is PARCOR cofficients
  [in] | p | is number of cofficients

戻り値
  residual

参照先 parcor(), と mist::array< T, Allocator >::resize().

参照元 parcor().

template<class T , class Allocator >

void mist::rotation_matrix | ( | matrix< T, Allocator > & | mat,
|  | typename matrix< T, Allocator >::value_type | radian
| ) |  |

calculate rotation matrix

引数

  [out] | mat | is rotation matrix
  [in] | radian | is rotation angle

template<class T , class Allocator >

void mist::rotation_matrix | ( | matrix< T, Allocator > & | mat,
|  | typename matrix< T, Allocator >::value_type | radian,
|  | typename matrix< T, Allocator >::value_type | cx,
|  | typename matrix< T, Allocator >::value_type | cy
| ) |  |

calculate rotation matrix

引数

  [out] | mat | is rotation matrix
  [in] | radian | is rotation angle
  [in] | cx | is X coordinate of the rotation center
  [in] | cy | is Y coordinate of the rotation center

template<class T , class Allocator >

void mist::scaling_matrix | ( | matrix< T, Allocator > & | mat,
|  | typename matrix< T, Allocator >::value_type | x,
|  | typename matrix< T, Allocator >::value_type | y
| ) |  |

calculate scaling matrix

引数

  [out] | mat | is scaling matrix
  [in] | sx,sy | is scale

template<class T >

const quaternion< T > mist::track_ball | ( | const vector2< T > & | p1,
|  | const vector2< T > & | p2,
|  | const vector3< T > & | axisX,
|  | const vector3< T > | axisY,
|  | const vector3< T > | axisZ,
|  | const typename vector3< T >::value_type & | trackball_size
| ) |  |

仮想トラックボールの実装(左手座標系)

覚え書き
  以下のソースコードを参考にした

Trackball code:

Implementation of a virtual trackball. Implemented by Gavin Bell, lots of ideas from Thant Tessman and the August '88 issue of Siggraph's "Computer Graphics," pp. 121-129.

Vector manip code:

Original code from: David M. Ciemiewicz, Mark Grossman, Henry Moreton, and Paul Haeberli

Much mucking with by: Gavin Bell

引数

  [in] | p1 | … 回転前の点
  [in] | p2 | … 回転後の点
  [in] | axisX | … トラックボールのX軸
  [in] | axisY | … トラックボールのY軸
  [in] | axisZ | … トラックボールのZ軸
  [in] | trackball_size | … トラックボールの半径（デフォルトは0.8）

戻り値
  回転を表すクォータニオン

参照先 mist::vector2< T >::length(), mist::vector3< T >::x, mist::vector2< T >::x, mist::vector3< T >::y, mist::vector2< T >::y, と mist::vector3< T >::z.

参照元 track_ball().

template<class T >

const quaternion< T > mist::track_ball | ( | const vector2< T > & | p1,
|  | const vector2< T > & | p2,
|  | const vector3< T > & | axisX,
|  | const vector3< T > | axisY,
|  | const vector3< T > | axisZ
| ) |  |
| inline

仮想トラックボールの実装(左手座標系)

覚え書き
  以下のソースコードを参考にした

Trackball code:

Implementation of a virtual trackball. Implemented by Gavin Bell, lots of ideas from Thant Tessman and the August '88 issue of Siggraph's "Computer Graphics," pp. 121-129.

Vector manip code:

Original code from: David M. Ciemiewicz, Mark Grossman, Henry Moreton, and Paul Haeberli

Much mucking with by: Gavin Bell

引数

  [in] | p1 | … 回転前の点
  [in] | p2 | … 回転後の点
  [in] | axisX | … トラックボールのX軸
  [in] | axisY | … トラックボールのY軸
  [in] | axisZ | … トラックボールのZ軸

戻り値
  回転を表すクォータニオン

参照先 track_ball().

template<class T >

const quaternion< T > mist::track_ball | ( | const typename vector3< T >::value_type & | x1,
|  | const typename vector3< T >::value_type & | y1,
|  | const typename vector3< T >::value_type & | x2,
|  | const typename vector3< T >::value_type & | y2,
|  | const vector3< T > & | axisX,
|  | const vector3< T > & | axisY,
|  | const vector3< T > & | axisZ,
|  | const typename vector3< T >::value_type & | trackball_size
| ) |  |

仮想トラックボールの実装(左手座標系)

トラックボールを用いて，任意ベクトルの回転を行う

引数

  [in] | x1 | … 回転前のX座標
  [in] | y1 | … 回転前のY座標
  [in] | x2 | … 回転後のX座標
  [in] | y2 | … 回転後のY座標
  [in] | axisX | … トラックボールのX軸
  [in] | axisY | … トラックボールのY軸
  [in] | axisZ | … トラックボールのZ軸
  [in] | trackball_size | … トラックボールの半径（デフォルトは0.8）

戻り値
  回転を表すクォータニオン

参照先 track_ball().

template<class T >

const quaternion< T > mist::track_ball | ( | const typename vector3< T >::value_type & | x1,
|  | const typename vector3< T >::value_type & | y1,
|  | const typename vector3< T >::value_type & | x2,
|  | const typename vector3< T >::value_type & | y2,
|  | const vector3< T > & | axisX,
|  | const vector3< T > & | axisY,
|  | const vector3< T > & | axisZ
| ) |  |

仮想トラックボールの実装(左手座標系)

トラックボールを用いて，任意ベクトルの回転を行う

引数

  [in] | x1 | … 回転前のX座標
  [in] | y1 | … 回転前のY座標
  [in] | x2 | … 回転後のX座標
  [in] | y2 | … 回転後のY座標
  [in] | axisX | … トラックボールのX軸
  [in] | axisY | … トラックボールのY軸
  [in] | axisZ | … トラックボールのZ軸

戻り値
  回転を表すクォータニオン

参照先 track_ball().

template<class T , class Allocator >

void mist::translation_matrix | ( | matrix< T, Allocator > & | mat,
|  | typename matrix< T, Allocator >::value_type | x,
|  | typename matrix< T, Allocator >::value_type | y
| ) |  |

calculate translation matrix

引数

  [out] | mat | is translation matrix
  [in] | x,y | is position

const std::string mist::wstr2str | ( | const std::wstring & | src | ) |
| inline

UNICODE文字列をマルチバイト文字列に変換する

引数

  [in] | src | … UNICODE文字列

戻り値
  マルチバイト文字列

参照先 dst().

参照元 read_bmp(), read_csv(), read_gif(), read_image(), read_jpeg(), read_jpeg2000(), read_lines(), read_mqo(), read_png(), read_pnm(), read_stl(), read_tga(), read_tiff(), read_wav(), write_bmp(), write_image(), write_jpeg(), write_jpeg2000(), write_mqo(), write_png(), write_pnm(), write_stl(), write_tga(), write_tiff(), と write_wav().