public void cariX(IplImage imgSrc, ref int min, ref int max)
{
bool minTemu = false;
data = new CvMat();
CvScalar maxVal = cvlib.cvRealScalar(imgSrc.width * 255);
CvScalar val = cvlib.cvRealScalar(0);
//For each column sum, if sum <width * 255 then we find min
//then proceed to the end of me to find max, if sum <width * 255 then found a new max
for (int i = 0; i < imgSrc.width; i++)
{
cvlib.cvGetCol( imgSrc, data, i); //col
val = cvlib.cvSum( data);
if (val.Val < maxVal.Val)
{
max = i;
if (!minTemu)
{
min = i;
minTemu = true;
}
}
}
}
public FlannColoredModelPoints(List<Tuple<CvPoint3D64f, CvColor>> modelPoints, IndexParams indexParams, SearchParams searchParams, double colorScale)
{
_modelPoints = modelPoints;
_modelMat = new CvMat(_modelPoints.Count, 6, MatrixType.F32C1);
unsafe
{
float* modelArr = _modelMat.DataSingle;
foreach (var tuple in _modelPoints)
{
*(modelArr++) = (float)tuple.Item1.X;
*(modelArr++) = (float)tuple.Item1.Y;
*(modelArr++) = (float)tuple.Item1.Z;
*(modelArr++) = (float)(tuple.Item2.R * colorScale / 255);
*(modelArr++) = (float)(tuple.Item2.G * colorScale / 255);
*(modelArr++) = (float)(tuple.Item2.B * colorScale / 255);
}
}
_colorScale = colorScale;
_modelDataMat = new Mat(_modelMat);
_indexParam = indexParams;
_searchParam = searchParams;
_indexParam.IsEnabledDispose = false;
_searchParam.IsEnabledDispose = false;
_flannIndex = new Index(_modelDataMat, _indexParam);
}
public void Read(XmlElement me)
{
foreach (XmlNode node in me.ChildNodes)
{
if (node is XmlElement)
{
if (node.Name == "rotation")
{
CvMat mat;
OpenCVUtil.Read(out mat, node as XmlElement);
Rotation = mat;
}
else if (node.Name == "translation")
{
CvMat mat;
OpenCVUtil.Read(out mat, node as XmlElement);
Translation = mat;
}
else if (node.Name == "intrinsic")
{
CvMat mat;
OpenCVUtil.Read(out mat, node as XmlElement);
Intrinsic = mat;
}
else if (node.Name == "distortion")
{
CvMat mat;
OpenCVUtil.Read(out mat, node as XmlElement);
Distortion = mat;
}
}
}
}
public void cariY(IplImage imgSrc, ref int min, ref int max)
{
bool minFound = false;
data = new CvMat();
CvScalar maxVal = cvlib.cvRealScalar(imgSrc.width * 255);
CvScalar val = cvlib.cvRealScalar(0);
//For each row sum, if sum <width * 255 then we find min
//then proceed to the end of me to find max, if sum <width * 255 then found a new max
for (int i = 0; i < imgSrc.height; i++)
{
cvlib.cvGetRow( imgSrc, data, i); //row
val = cvlib.cvSum( data);
if (val.val1 < maxVal.val1)
{
max = i;
if (!minFound)
{
min = i;
minFound = true;
}
}
}
}
void CalcPoint(CvMat velx, CvMat vely, IplImage rez)
{
int sX = 0;
int sY = 0;
int coun = 0;
for (int x = 0; x < imWidth; x += 10)
{
for (int y = 0; y < imHeight; y += 10)
{
int dx = (int)Cv.GetReal2D(velx, y, x);
int dy = (int)Cv.GetReal2D(vely, y, x);
if (dx > 15 || dy > 15)
{
Cv.Line(rez, Cv.Point(x, y), Cv.Point(x + dx, y + dy), Cv.RGB(0, 0, 255), 1, Cv.AA, 0);
sX += x;
sY += y;
coun++;
}
if (dx < -15 || dy < -15)
{
Cv.Line(rez, Cv.Point(x, y), Cv.Point(x + dx, y + dy), Cv.RGB(0, 255, 0), 1, Cv.AA, 0);
sX += x;
sY += y;
coun++;
}
}
}
if (coun > 10)
{
moveVec.Set(sX / coun, sY / coun, 0);
}
}
/// <summary>
/// 学習データを与えて初期化
/// </summary>
/// <param name="trainData"></param>
/// <param name="tflag"></param>
/// <param name="responses"></param>
/// <param name="varIdx"></param>
/// <param name="sampleIdx"></param>
/// <param name="varType"></param>
/// <param name="missingMask"></param>
/// <param name="param"></param>
/// <param name="shared"></param>
/// <param name="addLabels"></param>
/// <returns></returns>
#else
/// <summary>
/// Training constructor
/// </summary>
/// <param name="trainData"></param>
/// <param name="tflag"></param>
/// <param name="responses"></param>
/// <param name="varIdx"></param>
/// <param name="sampleIdx"></param>
/// <param name="varType"></param>
/// <param name="missingMask"></param>
/// <param name="param"></param>
/// <param name="shared"></param>
/// <param name="addLabels"></param>
/// <returns></returns>
#endif
public CvDTreeTrainData(
CvMat trainData,
DTreeDataLayout tflag,
CvMat responses,
CvMat varIdx = null,
CvMat sampleIdx = null,
CvMat varType = null,
CvMat missingMask = null,
CvDTreeParams param = null,
bool shared = false,
bool addLabels = false)
{
if (trainData == null)
throw new ArgumentNullException("trainData");
if (responses == null)
throw new ArgumentNullException("responses");
trainData.ThrowIfDisposed();
responses.ThrowIfDisposed();
if(param == null)
param = new CvDTreeParams();
ptr = NativeMethods.ml_CvDTreeTrainData_new2(
trainData.CvPtr,
(int)tflag,
responses.CvPtr,
Cv2.ToPtr(varIdx),
Cv2.ToPtr(sampleIdx),
Cv2.ToPtr(varType),
Cv2.ToPtr(missingMask),
param.CvPtr,
shared ? 1 : 0,
addLabels ? 1 : 0
);
}
public static void MainLoop()
{
PROCESS.SetWindowPos(0, 0, 800, 600);
Thread.Sleep(200);
foreach (var image in ImageList)
{
CvMat screen = Utils.TakeScreenshot().ToMat().ToCvMat();
Screenshot = new CvMat(screen.Rows, screen.Cols, MatrixType.U8C1);
screen.CvtColor(Screenshot, ColorConversion.BgraToGray);
Result =
Cv.CreateImage(Cv.Size(Screenshot.Width - image.Width + 1, Screenshot.Height - image.Height + 1),
BitDepth.F32, 1);
Cv.MatchTemplate(Screenshot, image, Result, MatchTemplateMethod.CCoeffNormed);
/*Screenshot.SaveImage("data/screenshot.png");
image.SaveImage("data/image.png");*/
Cv.Normalize(Result, Result, 0, 1, NormType.MinMax);
Cv.MinMaxLoc(Result, out MinAcc, out MaxAcc, out MinPos, out MaxPos, null);
Console.WriteLine(MaxAcc);
if (MaxAcc >= 0.75)
{
Position = new Point(MaxPos.X, MaxPos.Y);
Utils.MoveMouse(Position);
Thread.Sleep(15);
Utils.LeftClick();
Thread.Sleep(100);
MaxAcc = 0;
}
Result.Dispose();
}
}
public static byte[] GetBytesFromData(CvMat mat)
{
int byteLength = mat.ElemDepth * mat.Cols * mat.Rows * mat.ElemChannels / 8;
byte[] ret = new byte[byteLength];
Marshal.Copy(mat.Data, ret, 0, byteLength);
return ret;
}
/// <summary>
/// 初期化
/// </summary>
/// <param name="trainData"></param>
/// <param name="responses"></param>
/// <param name="varIdx"></param>
/// <param name="sampleIdx"></param>
/// <param name="param"></param>
#else
/// <summary>
/// Training constructor
/// </summary>
/// <param name="trainData"></param>
/// <param name="responses"></param>
/// <param name="varIdx"></param>
/// <param name="sampleIdx"></param>
/// <param name="param"></param>
#endif
public CvSVM(
CvMat trainData,
CvMat responses,
CvMat varIdx = null,
CvMat sampleIdx = null,
CvSVMParams param = null)
{
if (trainData == null)
throw new ArgumentNullException("trainData");
if (responses == null)
throw new ArgumentNullException("responses");
if(param == null)
param = new CvSVMParams();
trainData.ThrowIfDisposed();
responses.ThrowIfDisposed();
ptr = NativeMethods.ml_CvSVM_new2_CvMat(
trainData.CvPtr,
responses.CvPtr,
Cv2.ToPtr(varIdx),
Cv2.ToPtr(sampleIdx),
param.NativeStruct
);
}
public static void Read(out CvMat matrix, XmlElement element)
{
int cols = int.Parse(element.GetAttribute("cols"));
int rows = int.Parse(element.GetAttribute("rows"));
MatrixType matType = (MatrixType)Enum.Parse(typeof(MatrixType), element.GetAttribute("type"));
string terms = element.GetAttribute("values");
List<double> values = new List<double>();
string[] words = terms.Split(',');
foreach (string w in words)
values.Add(double.Parse(w.Trim()));
switch (matType)
{
case MatrixType.F32C1:
break;
case MatrixType.F64C1:
break;
default:
throw new Exception("Read unsupported MatrixType " + matType.ToString());
}
matrix = new CvMat(rows, cols, matType);
// Fill the matrix popping values off
for (int x = 0; x < cols; ++x)
{
for (int y = 0; y < rows; ++y)
{
matrix.Set2D(x, y, new CvScalar(values[0]));
values.RemoveAt(0);
}
}
}
public SerializableCvMat(CvMat mat)
{
this.Cols = mat.Cols;
this.Rows = mat.Rows;
this.ElemType = mat.ElemType;
this.Array = mat.ToArray();
}
static public Rotation RotationMatrixToEulerZXY(CvMat R)
{
var i = 2;
var j = 0; // EULER_NEXT[2]
var k = 1; // EULER_NEXT[3]
var cos_beta = Math.Sqrt(Math.Pow(R[i, i], 2) + Math.Pow(R[j, i], 2));
double alpha, beta, gamma;
if (cos_beta > EULER_EPSILON)
{
alpha = Math.Atan2(R[k, j], R[k, k]);
beta = Math.Atan2(-R[k, i], cos_beta);
gamma = Math.Atan2(R[j, i], R[i, i]);
}
else
{
alpha = Math.Atan2(-R[j, k], R[j, j]);
beta = Math.Atan2(-R[k, i], cos_beta);
gamma = 0.0;
}
alpha = wrap_angles(alpha, 0.0, 2.0 * Math.PI); // Z
beta = wrap_angles(beta, 0.0, 2.0 * Math.PI); // X
gamma = wrap_angles(gamma, 0.0, 2.0 * Math.PI); // Y
// errr... 180 - Z result seems right. Why?
return new Rotation(RadianToDegree(beta), RadianToDegree(gamma), 180.0 - RadianToDegree(alpha));
}
private static void applyLinearFilter()
{
using (var src = new IplImage(@"..\..\Images\Penguin.Png", LoadMode.AnyDepth | LoadMode.AnyColor))
using (var dst = new IplImage(src.Size, src.Depth, src.NChannels))
{
float[] data = { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
var kernel = new CvMat(rows: 1, cols: 21, type: MatrixType.F32C1, elements: data);
Cv.Normalize(src: kernel, dst: kernel, a: 1.0, b: 0, normType: NormType.L1);
double sum = 0;
foreach (var item in data)
{
sum += Math.Abs(item);
}
Console.WriteLine(sum); // => .999999970197678
Cv.Filter2D(src, dst, kernel, anchor: new CvPoint(0, 0));
using (new CvWindow("src", image: src))
using (new CvWindow("dst", image: dst))
{
Cv.WaitKey(0);
}
}
}
public Solve()
{
// x + y + z = 6
// 2x - 3y + 4z = 8
// 4x + 4y - 4z = 0
double[] A = new double[]{
1, 1, 1,
2, -3, 4,
4, 4, -4
};
double[] B = new double[]{
6,
8,
0
};
CvMat matA = new CvMat(3, 3, MatrixType.F64C1, A);
CvMat matB = new CvMat(3, 1, MatrixType.F64C1, B);
// X = inv(A) * B
CvMat matAInv = matA.Clone();
matA.Inv(matAInv);
CvMat matX = matAInv * matB;
Console.WriteLine("X = {0}", matX[0].Val0);
Console.WriteLine("Y = {0}", matX[1].Val0);
Console.WriteLine("Z = {0}", matX[2].Val0);
Console.Read();
}
void CalcPoint(CvMat velx, CvMat vely, IplImage rez)
{
int sX = 0;
int sY = 0;
int coun = 0;
for (int x = 0; x < cols; x += 10) {
for (int y = 0; y < rows; y += 10) {
int dx = (int)Cv.GetReal2D (velx, y, x);
int dy = (int)Cv.GetReal2D (vely, y, x);
if(Mathf.Abs(dx)>8 && Mathf.Abs(dy)>8 && Mathf.Abs(dx)<75 && Mathf.Abs(dy)<75)
{
Cv.Line (rez, Cv.Point (x, y), Cv.Point (x + dx, y + dy), Cv.RGB (0, 0, 255), 1, Cv.AA, 0);
sX += x;
sY += y;
coun++;
}
if(y == 0 && x == cols/8*3 || y == 0 && x == cols/8*5 )
{
Debug.Log("wewe");
Cv.Line(rez, Cv.Point(x, 0), Cv.Point(x, rows), Cv.RGB(255, 0, 0), 3, Cv.AA, 0);
}
if (x == 0 && y == rows / 3 || x == 0 && y == rows / 3 * 2)
{
Cv.Line(rez, Cv.Point(0, y), Cv.Point(cols, y), Cv.RGB(255, 0, 0), 3, Cv.AA, 0);
}
}
}
if (coun >15) {
Cv.Circle(rez, Cv.Point(sX / coun, sY / coun),30, Cv.RGB(255, 255, 0),5);
moveVec.Set (sX / coun, sY / coun, 0);
}
}
public void cariX(IplImage imgSrc, ref int min, ref int max)
{
bool minTemu = false;
data = new CvMat();
CvScalar maxVal = cxtypes.cvRealScalar(imgSrc.width * 255);
CvScalar val = cxtypes.cvRealScalar(0);
//utk setiap kolom sum, jika sum < width*255 maka kita temukan min
//kemudian lanjutkan hingga akhir utk menemukan max, jika sum < width*255 maka ditemukan max baru
for (int i = 0; i < imgSrc.width; i++)
{
cxcore.CvGetCol(ref imgSrc, ref data, i); //col
val = cxcore.CvSum(ref data);
if (val.val1 < maxVal.val1)
{
max = i;
if (!minTemu)
{
min = i;
minTemu = true;
}
}
}
}
public CvMatProxy(CvMat mat)
{
Data = mat.ToRectangularArray();
Rows = mat.Rows;
Cols = mat.Cols;
ElemChannels = mat.ElemChannels;
}
public Filter2D()
{
// cvFilter2D
// ユーザが定義したカーネルによるフィルタリング
// (1)画像の読み込み
using (IplImage srcImg = new IplImage(Const.ImageFruits, LoadMode.AnyDepth | LoadMode.AnyColor))
using (IplImage dstImg = new IplImage(srcImg.Size, srcImg.Depth, srcImg.NChannels))
{
// (2)カーネルの正規化と，フィルタ処理
float[] data = { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};
CvMat kernel = new CvMat(1, 21, MatrixType.F32C1, data);
Cv.Normalize(kernel, kernel, 1.0, 0, NormType.L1);
Cv.Filter2D(srcImg, dstImg, kernel, new CvPoint(0, 0));
// (3)結果を表示する
using (CvWindow window = new CvWindow("Filter2D", dstImg))
{
Cv.WaitKey(0);
}
}
}
/// <summary>
/// 学習データを与えて初期化
/// </summary>
/// <param name="trainData"></param>
/// <param name="tflag"></param>
/// <param name="responses"></param>
/// <param name="varIdx"></param>
/// <param name="sampleIdx"></param>
/// <param name="varType"></param>
/// <param name="missingMask"></param>
/// <param name="param"></param>
#else
/// <summary>
/// Training constructor
/// </summary>
/// <param name="trainData"></param>
/// <param name="tflag"></param>
/// <param name="responses"></param>
/// <param name="varIdx"></param>
/// <param name="sampleIdx"></param>
/// <param name="varType"></param>
/// <param name="missingMask"></param>
/// <param name="param"></param>
#endif
public CvBoost(
CvMat trainData,
DTreeDataLayout tflag,
CvMat responses,
CvMat varIdx = null,
CvMat sampleIdx = null,
CvMat varType = null,
CvMat missingMask = null,
CvBoostParams param = null)
{
if (trainData == null)
throw new ArgumentNullException("trainData");
if (responses == null)
throw new ArgumentNullException("responses");
trainData.ThrowIfDisposed();
responses.ThrowIfDisposed();
if (param == null)
param = new CvBoostParams();
ptr = NativeMethods.ml_CvBoost_new_CvMat(
trainData.CvPtr,
(int)tflag,
responses.CvPtr,
Cv2.ToPtr(varIdx),
Cv2.ToPtr(sampleIdx),
Cv2.ToPtr(varType),
Cv2.ToPtr(missingMask),
param.CvPtr
);
}
private static CvMat CreatePointCountMatrix(int numPoints)
{
int[] pointCountsValue = new int[_numImages];
pointCountsValue[0] = numPoints;
CvMat pointCounts = new CvMat(_numImages, 1, MatrixType.S32C1, pointCountsValue);
return pointCounts;
}
private void ApplyCalibrationToUnityCamera(CvMat intrinsic, CvMat rotation, CvMat translation)
{
CvMat rotationInverse = GetRotationMatrixFromRotationVector(rotation).Transpose(); // transpose is same as inverse for rotation matrix
CvMat transFinal = (rotationInverse * -1) * translation.Transpose();
_mainCamera.projectionMatrix = LoadProjectionMatrix((float)intrinsic[0, 0], (float)intrinsic[1, 1], (float)intrinsic[0, 2], (float)intrinsic[1, 2]);
ApplyTranslationAndRotationToCamera(transFinal, RotationConversion.RotationMatrixToEulerZXY(rotationInverse));
}
// Convert the image to HSV values
CvMat ConvertToHSV(CvMat img)
{
CvMat imgHSV = img.EmptyClone(); // Assign destination matrix of same size and type
Cv.CvtColor(img, imgHSV, ColorConversion.BgrToHsv);
return(imgHSV);
}
private static CvMat CreatePointCountMatrix(int numPoints)
{
int[] pointCountsValue = new int[_numImages];
pointCountsValue[0] = numPoints;
CvMat pointCounts = new CvMat(_numImages, 1, MatrixType.S32C1, pointCountsValue);
return(pointCounts);
}
private void ApplyCalibrationToUnityCamera(CvMat intrinsic, CvMat rotation, CvMat translation)
{
CvMat rotationInverse = GetRotationMatrixFromRotationVector(rotation).Transpose(); // transpose is same as inverse for rotation matrix
CvMat transFinal = (rotationInverse * -1) * translation.Transpose();
_mainCamera.projectionMatrix = LoadProjectionMatrix((float)intrinsic[0, 0], (float)intrinsic[1, 1], (float)intrinsic[0, 2], (float)intrinsic[1, 2]);
ApplyTranslationAndRotationToCamera(transFinal, RotationConversion.RotationMatrixToEulerZXY(rotationInverse));
}
public static byte[] GetBytesFromData(CvMat mat)
{
int byteLength = mat.ElemDepth * mat.Cols * mat.Rows * mat.ElemChannels / 8;
byte[] ret = new byte[byteLength];
Marshal.Copy(mat.Data, ret, 0, byteLength);
return(ret);
}
public static SerializableCvMat CreateOrNull(CvMat mat)
{
if (mat == null)
{
return(null);
}
return(new SerializableCvMat(mat));
}
/// <summary>
/// 次元を指定するコンストラクタ
/// </summary>
/// <param name="dimension"></param>
public MemorySavingLeastSquare(int dimension)
{
_dimension = dimension;
_left = CvEx.InitCvMat(dimension, dimension, MatrixType.F64C1);
_right = CvEx.InitCvMat(dimension, 1, MatrixType.F64C1);
_left.Zero();
_right.Zero();
}
/// <summary>
///
/// </summary>
/// <param name="mat"></param>
/// <param name="row"></param>
/// <param name="col"></param>
/// <param name="pixSize"></param>
/// <returns></returns>
#else
/// <summary>
///
/// </summary>
/// <param name="mat"></param>
/// <param name="row"></param>
/// <param name="col"></param>
/// <param name="pixSize"></param>
/// <returns></returns>
#endif
public static unsafe byte *MAT_ELEM_PTR_FAST(CvMat mat, int row, int col, int pixSize)
{
/*if ((uint)row < (uint)mat.Rows && (uint)col < (uint)mat.Cols)
* {
* throw new ArgumentException();
* }*/
return(mat.DataByte + (uint)(mat.Step * row) + (pixSize * col));
}
static void showrite(String s, CvMat image)
{
CvWindow window = new CvWindow(showiteCounter.ToString() + s);
window.ShowImage(image);
image.SaveImage(showiteCounter.ToString() + s + ".png");
showiteCounter++;
}
/// <summary>
/// 次元を指定するコンストラクタ
/// </summary>
/// <param name="dimension"></param>
public MemorySavingLeastSquare(int dimension)
{
_dimension = dimension;
_left = CvEx.InitCvMat(dimension, dimension, MatrixType.F64C1);
_right = CvEx.InitCvMat(dimension, 1, MatrixType.F64C1);
_left.Zero();
_right.Zero();
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
/// <param name="missing"></param>
/// <param name="responses"></param>
/// <param name="pWeight"></param>
/// <returns></returns>
private CvDTree MushroomCreateDTree(CvMat data, CvMat missing, CvMat responses, float pWeight)
{
float[] priors = { 1, pWeight };
CvMat varType = new CvMat(data.Cols + 1, 1, MatrixType.U8C1);
Cv.Set(varType, CvScalar.ScalarAll(CvStatModel.CV_VAR_CATEGORICAL)); // all the variables are categorical
CvDTree dtree = new CvDTree();
CvDTreeParams p = new CvDTreeParams(8, // max depth
10, // min sample count
0, // regression accuracy: N/A here
true, // compute surrogate split, as we have missing data
15, // max number of categories (use sub-optimal algorithm for larger numbers)
10, // the number of cross-validation folds
true, // use 1SE rule => smaller tree
true, // throw away the pruned tree branches
priors // the array of priors, the bigger p_weight, the more attention
// to the poisonous mushrooms
// (a mushroom will be judjed to be poisonous with bigger chance)
);
dtree.Train(data, DTreeDataLayout.RowSample, responses, null, null, varType, missing, p);
// compute hit-rate on the training database, demonstrates predict usage.
int hr1 = 0, hr2 = 0, pTotal = 0;
for (int i = 0; i < data.Rows; i++)
{
CvMat sample, mask;
Cv.GetRow(data, out sample, i);
Cv.GetRow(missing, out mask, i);
double r = dtree.Predict(sample, mask).Value;
bool d = Math.Abs(r - responses.DataArraySingle[i]) >= float.Epsilon;
if (d)
{
if (r != 'p')
{
hr1++;
}
else
{
hr2++;
}
}
//Console.WriteLine(responses.DataArraySingle[i]);
pTotal += (responses.DataArraySingle[i] == (float)'p') ? 1 : 0;
}
Console.WriteLine("Results on the training database");
Console.WriteLine("\tPoisonous mushrooms mis-predicted: {0} ({1}%)", hr1, (double)hr1 * 100 / pTotal);
Console.WriteLine("\tFalse-alarms: {0} ({1}%)", hr2, (double)hr2 * 100 / (data.Rows - pTotal));
varType.Dispose();
return(dtree);
}
/// <summary>
/// 原点（直流成分）が画像の中心にくるように，画像の象限を入れ替える関数.
/// srcArr, dstArr は同じサイズ，タイプの配列.
/// </summary>
/// <param name="srcArr"></param>
/// <param name="dstArr"></param>
private static void ShiftDFT(CvArr srcArr, CvArr dstArr)
{
CvSize size = Cv.GetSize(srcArr);
CvSize dstSize = Cv.GetSize(dstArr);
if (dstSize.Width != size.Width || dstSize.Height != size.Height)
{
throw new ApplicationException("Source and Destination arrays must have equal sizes");
}
// (9)インプレースモード用のテンポラリバッファ
CvMat tmp = null;
if (srcArr == dstArr)
{
tmp = Cv.CreateMat(size.Height / 2, size.Width / 2, Cv.GetElemType(srcArr));
}
int cx = size.Width / 2; /* 画像中心 */
int cy = size.Height / 2;
// (10)1〜4象限を表す配列と，そのコピー先
CvMat q1stub, q2stub;
CvMat q3stub, q4stub;
CvMat d1stub, d2stub;
CvMat d3stub, d4stub;
CvMat q1 = Cv.GetSubRect(srcArr, out q1stub, new CvRect(0, 0, cx, cy));
CvMat q2 = Cv.GetSubRect(srcArr, out q2stub, new CvRect(cx, 0, cx, cy));
CvMat q3 = Cv.GetSubRect(srcArr, out q3stub, new CvRect(cx, cy, cx, cy));
CvMat q4 = Cv.GetSubRect(srcArr, out q4stub, new CvRect(0, cy, cx, cy));
CvMat d1 = Cv.GetSubRect(srcArr, out d1stub, new CvRect(0, 0, cx, cy));
CvMat d2 = Cv.GetSubRect(srcArr, out d2stub, new CvRect(cx, 0, cx, cy));
CvMat d3 = Cv.GetSubRect(srcArr, out d3stub, new CvRect(cx, cy, cx, cy));
CvMat d4 = Cv.GetSubRect(srcArr, out d4stub, new CvRect(0, cy, cx, cy));
if (srcArr != dstArr)
{
if (!Cv.ARE_TYPES_EQ(q1, d1))
{
throw new ApplicationException("Source and Destination arrays must have the same format");
}
Cv.Copy(q3, d1, null);
Cv.Copy(q4, d2, null);
Cv.Copy(q1, d3, null);
Cv.Copy(q2, d4, null);
}
else
{
Cv.Copy(q3, tmp, null);
Cv.Copy(q1, q3, null);
Cv.Copy(tmp, q1, null);
Cv.Copy(q4, tmp, null);
Cv.Copy(q2, q4, null);
Cv.Copy(tmp, q2, null);
}
if (tmp != null)
{
tmp.Dispose();
}
}
// 数字認識
internal static int recognizeDigit(CvMat image)
{
int nonzero = 0;
nonzero = image.GetCols( image.Cols-2, image.Cols ).CountNonZero();
if ( image.Rows * 2 == nonzero )
// 1 右端2列がすべて輝点
return 1;
nonzero = image.GetRows( image.Rows-2, image.Rows ).CountNonZero();
if ( image.Cols * 2 == nonzero )
// 2 下端2行がすべて輝点
return 2;
nonzero = image.GetRows ( 0, 2 ).CountNonZero();
if ( image.Cols * 2 - 2 < nonzero )
// 7 上端2行がすべて輝点．ただし1ピクセルまで欠けても良い
return 7;
nonzero = image.GetCols ( image.Cols-3, image.Cols-1 ).CountNonZero();
if ( image.Rows * 2 == nonzero )
// 4 右端の左2列がすべて輝点
return 4;
CvRect rect = new CvRect( 0, 0, 1, image.Rows*2/3 );
CvMat subarr;
nonzero = image.GetSubArr ( out subarr, rect ).CountNonZero();
if ( 0 == nonzero )
// 3 左端の上部3分の2がすべて暗点
return 3;
rect = new CvRect ( 0, image.Rows/2, 3, 2 );
nonzero = image.GetSubArr ( out subarr, rect ).CountNonZero();
if ( 0 == nonzero )
// 5 左端の下半分開始すぐのwidth3 height2 がすべて暗点
return 5;
rect = new CvRect ( image.Cols/2, image.Rows/2-1, 1, 3 );
nonzero = image.GetSubArr( out subarr, rect ).CountNonZero();
if ( 0 == nonzero )
// 0 中央列中央3ピクセルがすべて暗点
return 0;
rect = new CvRect ( image.Cols-1, 0, 1, image.Rows*2/5 );
nonzero = image.GetSubArr( out subarr, rect ).CountNonZero();
if ( 0 == nonzero )
// 6 右端上部5分の2がすべて暗点
return 6;
rect = new CvRect ( image.Cols-1, image.Rows-3, 1, 3 );
nonzero = image.GetSubArr( out subarr, rect ).CountNonZero();
if ( 0 == nonzero )
// 右端下部3ピクセルがすべて暗点
return 9;
// 8 上記条件を満たさない
return 8;
}
public PixelSampling()
{
// 並進移動のためのピクセルサンプリング cvGetRectSubPix
// (1) 画像の読み込み，出力用画像領域の確保を行なう
using (IplImage srcImg = new IplImage(Const.ImageLenna, LoadMode.AnyDepth | LoadMode.AnyColor))
using (IplImage dstImg = srcImg.Clone())
{
// (2)dst_imgの画像中心になるsrc_img中の位置centerを指定する
CvPoint2D32f center = new CvPoint2D32f
{
X = srcImg.Width - 1,
Y = srcImg.Height - 1
};
// (3)centerが画像中心になるように，GetRectSubPixを用いて画像全体をシフトさせる
Cv.GetRectSubPix(srcImg, dstImg, center);
// (4)結果を表示する
using (CvWindow wSrc = new CvWindow("src"))
using (CvWindow wDst = new CvWindow("dst"))
{
wSrc.Image = srcImg;
wDst.Image = dstImg;
Cv.WaitKey(0);
}
}
// 回転移動のためのピクセルサンプリング cvGetQuadrangleSubPix
const int angle = 45;
// (1)画像の読み込み，出力用画像領域の確保を行なう
using (IplImage srcImg = new IplImage(Const.ImageLenna, LoadMode.AnyDepth | LoadMode.AnyColor))
using (IplImage dstImg = srcImg.Clone())
{
// (2)回転のための行列（アフィン行列）要素を設定し，CvMat行列Mを初期化する
float[] m = new float[6];
m[0] = (float)(Math.Cos(angle * Cv.PI / 180.0));
m[1] = (float)(-Math.Sin(angle * Cv.PI / 180.0));
m[2] = srcImg.Width * 0.5f;
m[3] = -m[1];
m[4] = m[0];
m[5] = srcImg.Height * 0.5f;
using (CvMat mat = new CvMat(2, 3, MatrixType.F32C1, m))
{
// (3)指定された回転行列により，GetQuadrangleSubPixを用いて画像全体を回転させる
Cv.GetQuadrangleSubPix(srcImg, dstImg, mat);
// (4)結果を表示する
using (CvWindow wSrc = new CvWindow("src"))
using (CvWindow wDst = new CvWindow("dst"))
{
wSrc.Image = srcImg;
wDst.Image = dstImg;
Cv.WaitKey(0);
}
}
}
}
/// <summary>
/// 初期化
/// </summary>
/// <param name="svmType">SVMの種類</param>
/// <param name="kernelType">SVMカーネルの種類</param>
/// <param name="degree">poly 用</param>
/// <param name="gamma">poly/rbf/sigmoid 用</param>
/// <param name="coef0">poly/sigmoid 用</param>
/// <param name="c">SVMType.CSvc, SVMType.EpsSvr, SVMType.NuSvr 用</param>
/// <param name="nu">SVMType.NuSvc, SVMType.OneClass, SVMType.NuSvr 用</param>
/// <param name="p">SVMType.EpsSvr 用</param>
/// <param name="classWeights">SVMType.CSvc 用</param>
/// <param name="termCrit">終了条件</param>
#else
/// <summary>
/// Constructor
/// </summary>
/// <param name="svmType">Type of SVM</param>
/// <param name="kernelType">The kernel type</param>
/// <param name="degree">for poly</param>
/// <param name="gamma">for poly/rbf/sigmoid</param>
/// <param name="coef0">for poly/sigmoid</param>
/// <param name="c">for SVMType.CSvc, SVMType.EpsSvr and SVMType.NuSvr</param>
/// <param name="nu">for SVMType.NuSvc, SVMType.OneClass and SVMType.NuSvr</param>
/// <param name="p">for SVMType.EpsSvr</param>
/// <param name="classWeights">for SVMType.CSvc</param>
/// <param name="termCrit">Termination criteria</param>
#endif
public CvSVMParams(SVMType svmType, SVMKernelType kernelType, double degree,
double gamma, double coef0, double c, double nu, double p,
CvMat classWeights, CvTermCriteria termCrit)
{
data = new WCvSVMParams();
NativeMethods.ml_CvSVMParams_new2(
ref data, (int)svmType, (int)kernelType, degree, gamma, coef0,
c, nu, p, Cv2.ToPtr(classWeights), termCrit);
}
/// <summary>
/// 最小二乗法で解を得ます
/// </summary>
/// <returns></returns>
public double[] Solve()
{
CvMat invLeft = CvEx.InitCvMat(_left);
_left.Invert(invLeft, InvertMethod.Cholesky);
CvMat ret = invLeft * _right;
return(ret.Select(r => r.Val0).ToArray());
}
/// <summary>
/// サンプルに対する応答を予測する
/// </summary>
/// <param name="sample"></param>
/// <param name="returnDfVal"></param>
/// <returns></returns>
#else
/// <summary>
/// Predicts the response for sample
/// </summary>
/// <param name="sample"></param>
/// <param name="returnDfVal"></param>
/// <returns></returns>
#endif
public virtual float Predict(CvMat sample, bool returnDfVal = false)
{
if (sample == null)
{
throw new ArgumentNullException(nameof(sample));
}
sample.ThrowIfDisposed();
return(NativeMethods.ml_CvSVM_predict_CvMat1(ptr, sample.CvPtr, returnDfVal ? 1 : 0));
}
static int WhatCard(bool black)
{
List <CvMat> templates = new List <CvMat>();
var image = new CvMat(path + @"bin/Debug/temp.png");
double maximum = 0, maxVal, minVal;
CvPoint maxLoc, minLoc;
int num = 0;
CvMat template;
IplImage result;
if (black)
{
templates.AddRange(new CvMat[] { new CvMat(path + "B2.png"),
new CvMat(path + "B3.png"),
new CvMat(path + "B4.png"),
new CvMat(path + "B5.png"),
new CvMat(path + "B6.png"),
new CvMat(path + "B7.png"),
new CvMat(path + "B8.png"),
new CvMat(path + "B9.png"),
new CvMat(path + "B10.png"),
new CvMat(path + "BJack.png"),
new CvMat(path + "BQueen.png"),
new CvMat(path + "BKing.png"),
new CvMat(path + "BAce.png"), });
}
else
{
templates.AddRange(new CvMat[] { new CvMat(path + "R2.png"),
new CvMat(path + "R3.png"),
new CvMat(path + "R4.png"),
new CvMat(path + "R5.png"),
new CvMat(path + "R6.png"),
new CvMat(path + "R7.png"),
new CvMat(path + "R8.png"),
new CvMat(path + "R9.png"),
new CvMat(path + "R10.png"),
new CvMat(path + "RJack.png"),
new CvMat(path + "RQueen.png"),
new CvMat(path + "RKing.png"),
new CvMat(path + "RAce.png"), });
}
for (int i = 0; i < 13; i++)
{
template = templates[i];
result = new IplImage(new CvSize(image.Cols - template.Cols + 1, image.Rows - template.Rows + 1), BitDepth.F32, 1);
Cv.MatchTemplate(image, template, result, MatchTemplateMethod.CCoeff);
Cv.MinMaxLoc(result, out minVal, out maxVal, out minLoc, out maxLoc);
if (maxVal > maximum)
{
maximum = maxVal;
num = i;
}
}
return(num);
}
CvMat getDepthUndistortMatImage(out float maxValue, out float minValue, CvMat src, float?center)
{
CvMat ret = CvEx.InitCvMat(src, MatrixType.U8C1);
List <double> values = new List <double>();
for (int y = 0; y < src.Rows; y++)
{
for (int x = 0; x < src.Cols; x++)
{
if (!_undistortion.CameraStruct.IsInFocalLength(x, y))
{
continue;
}
int i = y * src.Cols + x;
float value = src.DataArraySingle[i];
// if (value < 2)
// continue;
values.Add(value);
}
}
float max = 0;
float min = float.MaxValue;
if (values.Count >= 1)
{
max = (float)CalcEx.GetNth(values, (int)(values.Count * 0.99));
min = (float)CalcEx.GetNth(values, (int)(values.Count * 0.01));
}
max = (max - 1) * 1.5f + 1;
min = (min - 1) * 1.5f + 1;
if (center.HasValue)
{
float maxRange = Math.Max(max - center.Value, center.Value - min);
max = center.Value + maxRange;
min = center.Value - maxRange;
}
//max = 1.05f;
//min = 0.95f;
maxValue = max;
minValue = min;
if (max == min)
{
max += 0.5f;
min -= 0.5f;
}
for (int i = 0; i < src.Rows * src.Cols; i++)
{
float value = src.DataArraySingle[i];
float output = 255 * (value - min) / (max - min);
ret.DataArrayByte[i] = (byte)output;
}
return(ret);
}
private void GetEnclosingCircle(
IEnumerable<CvPoint> points, out CvPoint2D32f center, out float radius)
{
var pointsArray = points.ToArray();
using (var pointsMat = new CvMat(pointsArray.Length, 1, MatrixType.S32C2, pointsArray))
{
Cv.MinEnclosingCircle(pointsMat, out center, out radius);
}
}
/// <summary>
/// 特徴ベクトルのツリーを作成する
/// </summary>
/// <param name="desc">d 次元特徴ベクトルの n × d 行列 (CV_32FC1 or CV_64FC1).</param>
#else
/// <summary>
/// Constructs a tree of feature vectors
/// </summary>
/// <param name="desc">n x d matrix of n d-dimensional feature vectors (CV_32FC1 or CV_64FC1). </param>
#endif
public CvFeatureTree(CvMat desc)
{
if (desc == null)
throw new ArgumentNullException("desc");
ptr = NativeMethods.cvCreateFeatureTree(desc.CvPtr);
if (ptr == IntPtr.Zero)
throw new OpenCvSharpException("Failed to create CvFeatureTree");
}
public static void EdgeEnhancement(IplImage gray, ref IplImage enhancedImage)
{
float[] data = { -1, -1, -1, -1, -1, -1, 2, 2, 2, -1,
-1, 2, 8, 2, -1, -1, 2, 2, 2, -1,-1, -1, -1, -1, -1 };
CvMat kernel = new CvMat(5, 5, MatrixType.U8C1, data);
Cv.Normalize(kernel, kernel, 8, 0, NormType.L1);
Cv.Filter2D(gray, enhancedImage, kernel);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="mat"></param>
/// <param name="row"></param>
/// <param name="col"></param>
/// <returns></returns>
#else
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="mat"></param>
/// <param name="row"></param>
/// <param name="col"></param>
/// <returns></returns>
#endif
public static T CV_MAT_ELEM <T>(CvMat mat, int row, int col) where T : struct
{
unsafe
{
Type type = typeof(T);
byte *result = MAT_ELEM_PTR_FAST(mat, row, col, Marshal.SizeOf(type));
return((T)Marshal.PtrToStructure(new IntPtr(result), type));
}
}
/// <summary>
/// モデル状態を修正する. 修正された状態を kalman->state_post に保存し，これを出力として返す．
/// </summary>
/// <param name="kalman">更新されるカルマンフィルタ状態</param>
/// <param name="measurement">観測ベクトルを含むCvMat</param>
/// <returns>修正された状態を kalman->state_post に保存し，これを出力として返す．</returns>
#else
/// <summary>
/// Adjusts model state
/// </summary>
/// <param name="kalman">Kalman filter</param>
/// <param name="measurement">CvMat containing the measurement vector. </param>
/// <returns>The function stores adjusted state at kalman->state_post and returns it on output.</returns>
#endif
public static CvMat KalmanCorrect(CvKalman kalman, CvMat measurement)
{
if (kalman == null)
throw new ArgumentNullException("kalman");
if (measurement == null)
throw new ArgumentNullException("measurement");
IntPtr result = CvInvoke.cvKalmanCorrect(kalman.CvPtr, measurement.CvPtr);
return new CvMat(result, false);
}
public PixelSampling()
{
// 並進移動のためのピクセルサンプリング cvGetRectSubPix
// (1) 画像の読み込み，出力用画像領域の確保を行なう
using (IplImage srcImg = new IplImage(Const.ImageLenna, LoadMode.AnyDepth | LoadMode.AnyColor))
using (IplImage dstImg = srcImg.Clone())
{
// (2)dst_imgの画像中心になるsrc_img中の位置centerを指定する
CvPoint2D32f center = new CvPoint2D32f
{
X = srcImg.Width - 1,
Y = srcImg.Height - 1
};
// (3)centerが画像中心になるように，GetRectSubPixを用いて画像全体をシフトさせる
Cv.GetRectSubPix(srcImg, dstImg, center);
// (4)結果を表示する
using (CvWindow wSrc = new CvWindow("src"))
using (CvWindow wDst = new CvWindow("dst"))
{
wSrc.Image = srcImg;
wDst.Image = dstImg;
Cv.WaitKey(0);
}
}
// 回転移動のためのピクセルサンプリング cvGetQuadrangleSubPix
const int angle = 45;
// (1)画像の読み込み，出力用画像領域の確保を行なう
using (IplImage srcImg = new IplImage(Const.ImageLenna, LoadMode.AnyDepth | LoadMode.AnyColor))
using (IplImage dstImg = srcImg.Clone())
{
// (2)回転のための行列（アフィン行列）要素を設定し，CvMat行列Mを初期化する
float[] m = new float[6];
m[0] = (float)(Math.Cos(angle * Cv.PI / 180.0));
m[1] = (float)(-Math.Sin(angle * Cv.PI / 180.0));
m[2] = srcImg.Width * 0.5f;
m[3] = -m[1];
m[4] = m[0];
m[5] = srcImg.Height * 0.5f;
using (CvMat mat = new CvMat(2, 3, MatrixType.F32C1, m))
{
// (3)指定された回転行列により，GetQuadrangleSubPixを用いて画像全体を回転させる
Cv.GetQuadrangleSubPix(srcImg, dstImg, mat);
// (4)結果を表示する
using (CvWindow wSrc = new CvWindow("src"))
using (CvWindow wDst = new CvWindow("dst"))
{
wSrc.Image = srcImg;
wDst.Image = dstImg;
Cv.WaitKey(0);
}
}
}
}
private void ApplyTranslationAndRotationToCamera(CvMat translation, Rotation r)
{
double tx = translation[0, 0];
double ty = translation[0, 1];
double tz = translation[0, 2];
_mainCamera.transform.position = new Vector3((float)tx, (float)ty, (float)tz);
_mainCamera.transform.eulerAngles = new Vector3((float)r.X, (float)r.Y, (float)r.Z);
}
/// <summary>
/// cvEncodeImageにより、この画像をメモリ上に展開する
/// </summary>
/// <param name="ext">拡張子。.jpgや.pngなど。これによりエンコード形式が決定される。</param>
/// <param name="encodingParams">JPEGの圧縮率などのエンコード設定</param>
/// <returns></returns>
#else
/// <summary>
/// Extract this image to the memory using cvEncodeImage
/// </summary>
/// <param name="ext">Image extension to decide encoding format.</param>
/// <param name="encodingParams">Encoding options.</param>
/// <returns></returns>
#endif
public byte[] ToBytes(string ext, params ImageEncodingParam[] encodingParams)
{
using (CvMat mat = Cv.EncodeImage(ext, this, encodingParams))
{
byte[] bytes = new byte[mat.Rows * mat.Cols];
Marshal.Copy(mat.Data, bytes, 0, bytes.Length);
return(bytes);
}
}
/// <summary>
/// 縦ベクトル用の4x4平行移動行列を作成します
/// </summary>
/// <param name="translation"></param>
/// <returns></returns>
public static CvMat GetTranslation(CvPoint3D64f translation)
{
CvMat ret = CvMat.Identity(4, 4, MatrixType.F64C1);
ret[0, 3] = translation.X;
ret[1, 3] = translation.Y;
ret[2, 3] = translation.Z;
return(ret);
}
// => input = 24bit rgb
public void calcNextFrame(CvMat input)
{
++currentFrame;
// IDEA 1 :
// Get Hue out of input (get rid of lighting)
// TODO : make following functions into multi-core
// NOTE : Both below give alternatively good results for different pictures
CvMat hue = null;
CvMat normalize = null;
// no estimation of box color yet; if user hasn't set a hint himself, we'll just get input's center
if (!hintPosSet && boxEstimationType == BoxEstimationType.NONE)
{
setBoxHint(input.Cols / 2, input.Rows / 2);
}
// new hint set
if (hintPosSet)
{
hintPosSet = false; // don't ever re-enter, unless required
resetBoxEstimation(input, ref hue, ref normalize);
}
CvLineSegmentPoint[] lines;
{
// IDEA 2 :
// Before trying to extract any features, lets try to set a good ROI. The ROI returned by floodfill is certainly not good, as it may as well
// hold only part of the box. We want to keep the whole region that contains pixels close to the box's estimated.
CvMat roi = detectROI(input, ref hue, ref normalize);
// IDEA 3 (ABANDONED) :
// detect features from hue/roi (GoodFeaturesToTrack), then get lines from features
// NOTE : maybe this idea will make a comeback in combination with lines detected, although it sounds a bit OTT
#if false
lines = detectLinesFromFeatures(hue, roi);
#endif
// IDEA 4 :
// INSTEAD of "GoodFeaturesToTrack", go straight for Canny edges and HoughLinesP
lines = detectLinesFromCanny(roi);
}
// IDEA 5 :
// Distill discovered lines:
// - merge ones that are very close
// - find the top-most (higher-Y!) that form a convex quadrilateral
// - find interesction points; if we have 4 and a convex shape we are finished
// - if we only have 2, check how they can be connected to form a convex quadrilateral
lines = distillLines(lines);
// IDEA 6 :
// If we are somewhat confident about our trapezium, we can start tracking the 4 points
// instead of re-discovering them every frame.
}
/// <summary>
///
/// </summary>
/// <param name="m1"></param>
/// <param name="m2"></param>
/// <param name="model"></param>
/// <param name="maxIters"></param>
/// <returns></returns>
public override unsafe bool Refine(CvMat m1, CvMat m2, CvMat model, int maxIters)
{
CvLevMarq solver = new CvLevMarq(8, 0, new CvTermCriteria(maxIters, double.Epsilon));
int count = m1.Rows * m1.Cols;
CvPoint2D64f *M = (CvPoint2D64f *)m1.DataByte;
CvPoint2D64f *m = (CvPoint2D64f *)m2.DataByte;
CvMat modelPart = new CvMat(solver.Param.Rows, solver.Param.Cols, model.ElemType, model.Data);
Cv.Copy(modelPart, solver.Param);
for (; ;)
{
CvMat _param = null;
CvMat _JtJ = null, _JtErr = null;
double _errNorm = 0;
if (!solver.UpdateAlt(out _param, out _JtJ, out _JtErr, out _errNorm))
{
break;
}
for (int i = 0; i < count; i++)
{
double * h = _param.DataDouble;
double Mx = M[i].X, My = M[i].Y;
double ww = 1.0 / (h[6] * Mx + h[7] * My + 1.0);
double _xi = (h[0] * Mx + h[1] * My + h[2]) * ww;
double _yi = (h[3] * Mx + h[4] * My + h[5]) * ww;
double[] err = { _xi - m[i].X, _yi - m[i].Y };
if (_JtJ != null || _JtErr != null)
{
double[,] J = new double[2, 8]
{
{ Mx *ww, My *ww, ww, 0, 0, 0, -Mx *ww *_xi, -My *ww *_xi },
{ 0, 0, 0, Mx *ww, My *ww, ww, -Mx * ww * _yi, -My * ww * _yi }
};
for (int j = 0; j < 8; j++)
{
for (int k = j; k < 8; k++)
{
_JtJ.DataDouble[j * 8 + k] += J[0, j] * J[0, k] + J[1, j] * J[1, k];
}
_JtErr.DataDouble[j] += J[0, j] * err[0] + J[1, j] * err[1];
}
}
if (_errNorm != 0)
{
solver.ErrNorm += err[0] * err[0] + err[1] * err[1];
}
}
}
Cv.Copy(solver.Param, modelPart);
return(true);
}
/// <summary>
/// Конструктор вызываемый при десериализации
/// </summary>
/// <param name="info"></param>
/// <param name="context"></param>
protected CoordinatesTransformer(SerializationInfo info, StreamingContext context)
{
Type t = typeof(CvMatSerializator);
Intrinsic = ((CvMatSerializator)info.GetValue("Intrinsic", t)).BuildMatrix();
Distortion = ((CvMatSerializator)info.GetValue("Distortion", t)).BuildMatrix();
Rotation = ((CvMatSerializator)info.GetValue("Rotation", t)).BuildMatrix();
Translation = ((CvMatSerializator)info.GetValue("Translation", t)).BuildMatrix();
TransformationMatrix = ((CvMatSerializator)info.GetValue("TransformationMatrix", t)).BuildMatrix();
}
void putImage(CvMat mat, PixelFormat format)
{
if (!this.Dispatcher.CheckAccess())
{
this.Dispatcher.Invoke(new Action <CvMat, PixelFormat>(putImage), mat, format);
return;
}
CvEx.GetBmpFromMat(ref _bmp, mat, format);
imageTrack.Source = _bmp;
}
void drawUndistortedCornerFrame(CvMat displayMat, CvPoint2D32f[] corners, CvSize boardSize)
{
CvMat cornerMat = new CvMat(1, corners.Length, MatrixType.F32C2);
CvEx.FillCvMat(cornerMat, corners.Select(x => new CvScalar(x.X, x.Y)).ToList());
CvMat undistMat = CvEx.InitCvMat(cornerMat);
Cv.UndistortPoints(cornerMat, undistMat, this.UndistortionData.CameraStruct.CreateCvMat(), this.UndistortionData.DistortStruct.CreateCvMat(true), null, this.UndistortionData.CameraStruct.CreateCvMat());
CvEx.DrawChessboardCornerFrame(displayMat, boardSize, undistMat.Select(x => new CvPoint2D32f(x.Val0, x.Val1)).ToArray(), new CvScalar(216, 216, 216));
}
private void GetEnclosingCircle(
IEnumerable <CvPoint> points, out CvPoint2D32f center, out float radius)
{
var pointsArray = points.ToArray();
using (var pointsMat = new CvMat(pointsArray.Length, 1, MatrixType.S32C2, pointsArray))
{
Cv.MinEnclosingCircle(pointsMat, out center, out radius);
}
}
public static Bitmap ChangeBrighness(Bitmap src, float[] kernel)
{
using (IplImage dst = Cv.CloneImage(BitmapConverter.ToIplImage(src)))
{
CvMat kernel_matrix = Cv.Mat(3, 3, MatrixType.F32C1, kernel);
Cv.Filter2D(BitmapConverter.ToIplImage(src), dst, kernel_matrix, Cv.Point(-1, -1));
using (Mat res = new Mat(dst, true))
return(res.ToBitmap());
}
}
/// <summary>
/// 指定したバッファメモリから画像をCvMatとして読み込む
/// </summary>
/// <param name="buf">入力のbyte配列</param>
/// <param name="iscolor">出力の色を指定するフラグ</param>
/// <returns></returns>
#else
/// <summary>
/// Decode image stored in the buffer
/// </summary>
/// <param name="buf">The input array of vector of bytes</param>
/// <param name="iscolor">Specifies color type of the loaded image</param>
/// <returns></returns>
#endif
public static CvMat DecodeImageM(CvMat buf, LoadMode iscolor)
{
if (buf == null)
throw new ArgumentNullException("buf");
IntPtr ptr = NativeMethods.cvDecodeImageM(buf.CvPtr, iscolor);
if (ptr == IntPtr.Zero)
return null;
else
return new CvMat(ptr, true);
}
// Return a region of interest (_rect_roi) from within the image _image
// This doesn't need to be its own function, but I had so much trouble
// finding a method that didn't crash the program that I separated it.
CvMat GetROI(CvMat _image, CvRect rect_roi)
{
// Get the region of interest
CvMat img_roi; // Get the region of interest
// Grab the region of interest using the mouse-drawn box
_image.GetSubRect(out img_roi, rect_roi);
return(img_roi);
}
static public CvMat BGRtoHueCV(CvMat input)
{
CvMat hsl = MatOps.ConvertChannels(input, MatrixType.U8C3, ColorConversion.BgrToHsv_Full);
CvMat hue = MatOps.CopySize(input, MatrixType.U8C1);
//CvMat lum = hue.EmptyClone();
//hsl.Split( hue, null, lum, null );
hsl.Split(hue, null, null, null);
return(hue);
}
public KNearest(MainForm form)
{
this.form = form;
trainData = cvlib.cvCreateMat(train_samples * classes, size * size, cvlib.CV_32FC1);
trainClasses = cvlib.cvCreateMat(train_samples * classes, 1, cvlib.CV_32FC1);
K = int.Parse(form.txtK.Text);
p = new preprocessing(form);
}
/// <summary>
/// 学習データを与えて初期化
/// </summary>
/// <param name="layerSizes">入出力層を含む各層のニューロン数を指定する整数のベクトル</param>
/// <param name="activFunc">各ニューロンの活性化関数</param>
/// <param name="fParam1">活性化関数のフリーパラメータα</param>
/// <param name="fParam2">活性化関数のフリーパラメータβ</param>
#else
/// <summary>
/// Training constructor
/// </summary>
/// <param name="layerSizes">The integer vector specifies the number of neurons in each layer including the input and output layers. </param>
/// <param name="activFunc">Specifies the activation function for each neuron</param>
/// <param name="fParam1">Free parameter α of the activation function</param>
/// <param name="fParam2">Free parameter β of the activation function</param>
#endif
public CvANN_MLP(
CvMat layerSizes,
MLPActivationFunc activFunc = MLPActivationFunc.SigmoidSym,
double fParam1 = 0, double fParam2 = 0)
{
if (layerSizes == null)
throw new ArgumentNullException("layerSizes");
ptr = NativeMethods.ml_CvANN_MLP_new2_CvMat(
layerSizes.CvPtr, (int)activFunc, fParam1, fParam2);
}
