/// <summary>
/// Converts std::vector to managed array
/// </summary>
/// <returns></returns>
public Point2f[] ToArray()
{
var size = Size;
if (size == 0)
{
return(Array.Empty <Point2f>());
}
var dst = new Point2f[size];
using (var dstPtr = new ArrayAddress1 <Point2f>(dst))
{
long bytesToCopy = Marshal.SizeOf <Point2f>() * dst.Length;
unsafe
{
Buffer.MemoryCopy(ElemPtr.ToPointer(), dstPtr.Pointer.ToPointer(), bytesToCopy, bytesToCopy);
}
}
GC.KeepAlive(this); // ElemPtr is IntPtr to memory held by this object, so
// make sure we are not disposed until finished with copy.
return(dst);
}
/// <summary>
/// Converts std::vector to managed array
/// </summary>
/// <typeparam name="T">structure that has two float members (ex. CvLineSegmentPolar, CvPoint2D32f, PointF)</typeparam>
/// <returns></returns>
public T[] ToArray <T>() where T : struct
{
int typeSize = MarshalHelper.SizeOf <T>();
if (typeSize != sizeof(float) * 3)
{
throw new OpenCvSharpException();
}
int arySize = Size;
if (arySize == 0)
{
return(new T[0]);
}
T[] dst = new T[arySize];
using (var dstPtr = new ArrayAddress1 <T>(dst))
{
MemoryHelper.CopyMemory(dstPtr, ElemPtr, typeSize * dst.Length);
}
return(dst);
}
/// <summary>
/// Converts std::vector to managed array
/// </summary>
/// <typeparam name="T">structure that has four int members (ex. CvLineSegmentPoint, CvRect)</typeparam>
/// <returns></returns>
public T[] ToArray <T>() where T : struct
{
int typeSize = Marshal.SizeOf(typeof(T));
if (typeSize != sizeof(int) * 4)
{
throw new OpenCvSharpException();
}
int arySize = Size;
if (arySize == 0)
{
return(new T[0]);
}
T[] dst = new T[arySize];
using (ArrayAddress1 <T> dstPtr = new ArrayAddress1 <T>(dst))
{
Util.Utility.CopyMemory(dstPtr, ElemPtr, typeSize * dst.Length);
}
return(dst);
}
/// <summary>
///
/// </summary>
/// <param name="value"></param>
public void SetFlSamples(float[,] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
int rows = SamplesNum, cols = DP;
if (value.GetLength(0) != rows || value.GetLength(1) != cols)
{
throw new ArgumentException();
}
unsafe
{
float[,] dst = new float[rows, cols];
float **src = ((WCvConDensation *)ptr)->flSamples;
using (var dstPtr = new ArrayAddress1 <float>(dst))
{
Util.CopyMemory(new IntPtr(src), dstPtr, rows * cols);
}
}
}
/// <summary>
/// Converts std::vector to managed array
/// </summary>
/// <typeparam name="T">structure that has four int members (ex. CvLineSegmentPoint, CvRect)</typeparam>
/// <returns></returns>
public T[] ToArray <T>() where T : struct
{
int typeSize = MarshalHelper.SizeOf <T>();
if (typeSize != sizeof(float) * 4)
{
throw new OpenCvSharpException();
}
int arySize = Size;
if (arySize == 0)
{
return(new T[0]);
}
T[] dst = new T[arySize];
using (var dstPtr = new ArrayAddress1 <T>(dst))
{
MemoryHelper.CopyMemory(dstPtr, ElemPtr, typeSize * dst.Length);
}
GC.KeepAlive(this); // ElemPtr is IntPtr to memory held by this object, so
// make sure we are not disposed until finished with copy.
return(dst);
}
/// <summary>
/// 複数の数値を書き込む
/// </summary>
/// <typeparam name="T">srcの要素の型</typeparam>
/// <param name="fs">ファイルストレージ</param>
/// <param name="src">書き込む配列</param>
/// <param name="dt">フォーマット</param>
#else
/// <summary>
/// Writes multiple numbers
/// </summary>
/// <typeparam name="T">Type of the elements in src</typeparam>
/// <param name="fs">File storage. </param>
/// <param name="src">Written array </param>
/// <param name="dt">Format</param>
#endif
public static void WriteRawData <T>(CvFileStorage fs, T[] src, string dt) where T : struct
{
if (fs == null)
{
throw new ArgumentNullException("fs");
}
if (src == null)
{
throw new ArgumentNullException("src");
}
if (string.IsNullOrEmpty(dt))
{
throw new ArgumentNullException("dt");
}
using (var srcPtr = new ArrayAddress1 <T>(src))
{
NativeMethods.cvWriteRawData(fs.CvPtr, srcPtr.Pointer, src.Length, dt);
}
GC.KeepAlive(fs);
GC.KeepAlive(src);
GC.KeepAlive(dt);
}
/// <summary>
///
/// </summary>
/// <param name="value"></param>
public void SetFlSamples(float[,] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
int rows = SamplesNum, cols = DP;
if (value.GetLength(0) != rows || value.GetLength(1) != cols)
{
throw new ArgumentException();
}
unsafe
{
float[,] dst = new float[rows, cols];
float** src = ((WCvConDensation*)ptr)->flSamples;
using (var dstPtr = new ArrayAddress1<float>(dst))
{
Util.CopyMemory(new IntPtr(src), dstPtr, rows * cols);
}
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public float[,] GetFlSamples()
{
unsafe
{
int rows = SamplesNum, cols = DP;
float[,] dst = new float[rows, cols];
float** src = ((WCvConDensation*)ptr)->flSamples;
using (var dstPtr = new ArrayAddress1<float>(dst))
{
Util.CopyMemory(dstPtr, new IntPtr(src), rows * cols);
}
return dst;
}
}
/// <summary>
/// 入力画像がチェスボードパターンであるかどうかを確認し，チェスボードの各コーナーの位置検出を試みる．
/// </summary>
/// <param name="image">入力のチェスボード画像．8ビットのグレースケールまたはカラー画像．</param>
/// <param name="patternSize">チェスボードの行と列ごとのコーナーの数</param>
/// <param name="corners">検出されたコーナーの配列. Length=pattern_size.Width*pattern_size.Height</param>
/// <param name="cornerCount">コーナーの数が出力される</param>
/// <param name="flags">処理フラグ</param>
/// <returns>すべてのコーナーが検出され，正しい順番（行順で，かつ各行は左から右に並ぶ）でそれらが配置されている場合には, true</returns>
#else
/// <summary>
/// Finds positions of internal corners of the chessboard
/// </summary>
/// <param name="image">Source chessboard view; it must be 8-bit grayscale or color image. </param>
/// <param name="patternSize">The number of inner corners per chessboard row and column. </param>
/// <param name="corners">The output array of corners detected. </param>
/// <param name="cornerCount">The output corner counter. If it is not null, the function stores there the number of corners found. </param>
/// <param name="flags">Various operation flags</param>
/// <returns>returns true if all the corners have been found and they have been placed in a certain order (row by row, left to right in every row), otherwise, if the function fails to find all the corners or reorder them, it returns false. </returns>
#endif
public static bool FindChessboardCorners(CvArr image, CvSize patternSize, out CvPoint2D32f[] corners, out int cornerCount, ChessboardFlag flags)
{
if (image == null)
{
throw new ArgumentNullException("image");
}
cornerCount = patternSize.Width * patternSize.Height;
corners = new CvPoint2D32f[cornerCount];
using (var cornersPtr = new ArrayAddress1<CvPoint2D32f>(corners))
{
int result = NativeMethods.cvFindChessboardCorners(image.CvPtr, patternSize, cornersPtr, ref cornerCount, flags);
return result != 0;
}
}
/// <summary>
/// Converts std::vector to managed array
/// </summary>
/// <returns></returns>
public CvRect[] ToArray()
{
int size = Size;
if (size == 0)
{
return new CvRect[0];
}
CvRect[] dst = new CvRect[size];
using (ArrayAddress1<CvRect> dstPtr = new ArrayAddress1<CvRect>(dst))
{
Util.CopyMemory(dstPtr, ElemPtr, CvRect.SizeOf * dst.Length);
}
return dst;
}
/// <summary>
/// Converts std::vector to managed array
/// </summary>
/// <returns></returns>
public KeyPoint[] ToArray()
{
int size = Size;
if (size == 0)
{
return new KeyPoint[0];
}
KeyPoint[] dst = new KeyPoint[size];
using (ArrayAddress1<KeyPoint> dstPtr = new ArrayAddress1<KeyPoint>(dst))
{
Util.CopyMemory(dstPtr, ElemPtr, Marshal.SizeOf(typeof(KeyPoint)) * dst.Length);
}
return dst;
}
