ネームスペース | データ構造 | 関数
ネームスペース 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)
 全ての要素が等しいかどうかを判定する（ $ a = b $）
template<class SetType >
bool operator!= (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
 全ての要素が等しくないかどうかを判定する（ $ a \neq b $）
template<class SetType >
bool operator< (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
 集合の包含関係を調べる（ $ a \subset b $）
template<class SetType >
bool operator<= (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
 集合の包含関係を調べる（ $ a \subseteq b $）
template<class SetType >
bool operator> (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
 集合の包含関係を調べる（ $ a \supset b $）
template<class SetType >
bool operator>= (const set_base< SetType > &s1, const typename set_base< SetType >::key_type &s2)
 集合の包含関係を調べる（ $ a \supseteq b $）
template<class SetType >
bool operator== (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
 全ての要素が等しいかどうかを判定する（ $ a = b $）
template<class SetType >
bool operator!= (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
 全ての要素が等しくないかどうかを判定する（ $ a \neq b $）
template<class SetType >
bool operator< (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
 集合の包含関係を調べる（ $ a \subset b $）
template<class SetType >
bool operator<= (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
 集合の包含関係を調べる（ $ a \subseteq b $）
template<class SetType >
bool operator> (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
 集合の包含関係を調べる（ $ a \supset b $）
template<class SetType >
bool operator>= (const typename set_base< SetType >::key_type &s1, const set_base< SetType > &s2)
 集合の包含関係を調べる（ $ a \supseteq b $）
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]signalis input data
[in]tauis lag
[in]biasedis 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]signal1is input data 1
[in]signal2is input data 2
[in]tauis lag
[in]biasedis 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]matis homography matrix
[in]p1,p2are 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]ttensor to be decomposed
[in,out]zcore tensor of the tensor
[in,out]u1unitary matrix corresponding to the 1st mode
[in,out]u2unitary 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]ztensorto be decomposed
[in,out]zcore tensor of the tensor
[in,out]u1unitary matrix corresponding to the 1st mode
[in,out]u2unitary matrix corresponding to the 2nd mode
[in,out]u3unitary 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]ztensorto be decomposed
[in,out]zcore tensor of the tensor
[in,out]u1unitary matrix corresponding to the 1st mode
[in,out]u2unitary matrix corresponding to the 2nd mode
[in,out]u3unitary matrix corresponding to the 3rd mode
[in,out]u4unitary 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]ztensorto be decomposed
[in,out]zcore tensor of the tensor
[in,out]u1unitary matrix corresponding to the 1st mode
[in,out]u2unitary matrix corresponding to the 2nd mode
[in,out]u3unitary matrix corresponding to the 3rd mode
[in,out]u4unitary matrix corresponding to the 4th mode
[in,out]u5unitary 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]ttensor
[in]vvalue
戻り値
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]vvalue
[in]ttensor
戻り値
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]t11st tensor
[in]t22nd 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]t11st tensor
[in]t22nd 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]ttensor
[in]vvalue
戻り値
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]ooutput stream
[in]ttensor
戻り値
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]coris autocorrelation values (the length should be p + 1)
[out]alfis linear predict cofficients
[out]refis PARCOR cofficients
[in]pis 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]matis rotation matrix
[in]radianis 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]matis rotation matrix
[in]radianis rotation angle
[in]cxis X coordinate of the rotation center
[in]cyis 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]matis scaling matrix
[in]sx,syis 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]matis translation matrix
[in]x,yis 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().

Generated on Wed Nov 12 2014 19:44:28 for MIST by doxygen 1.8.1.2