Mat calc_simil(Mat pts) { float[] pts_float = new float[pts.total()]; MatUtils.copyFromMat <float>(pts, pts_float); int pts_cols = pts.cols(); //compute translation int n = pts.rows() / 2; float mx = 0, my = 0; for (int i = 0; i < n; i++) { mx += pts_float[(2 * pts_cols) * i]; my += pts_float[((2 * pts_cols) * i) + 1]; } using (Mat p = new Mat(2 * n, 1, CvType.CV_32F)) { float[] p_float = new float[p.total()]; MatUtils.copyFromMat <float>(p, p_float); int p_cols = p.cols(); mx /= n; my /= n; for (int i = 0; i < n; i++) { p_float[(2 * p_cols) * i] = pts_float[(2 * pts_cols) * i] - mx; p_float[((2 * p_cols) * i) + 1] = pts_float[((2 * pts_cols) * i) + 1] - my; } MatUtils.copyToMat(p_float, p); //compute rotation and scale float[] reference_float = new float[reference.total()]; MatUtils.copyFromMat <float>(reference, reference_float); int reference_cols = reference.cols(); float a = 0, b = 0, c = 0; for (int i = 0; i < n; i++) { a += reference_float[(2 * reference_cols) * i] * reference_float[(2 * reference_cols) * i] + reference_float[((2 * reference_cols) * i) + 1] * reference_float[((2 * reference_cols) * i) + 1]; b += reference_float[(2 * reference_cols) * i] * p_float[(2 * p_cols) * i] + reference_float[((2 * reference_cols) * i) + 1] * p_float[((2 * p_cols) * i) + 1]; c += reference_float[(2 * reference_cols) * i] * p_float[((2 * p_cols) * i) + 1] - reference_float[((2 * reference_cols) * i) + 1] * p_float[(2 * p_cols) * i]; } b /= a; c /= a; float scale = (float)Math.Sqrt(b * b + c * c), theta = (float)Math.Atan2(c, b); float sc = scale * (float)Math.Cos(theta), ss = scale * (float)Math.Sin(theta); Mat returnMat = new Mat(2, 3, CvType.CV_32F); returnMat.put(0, 0, sc, -ss, mx, ss, sc, my); return(returnMat); } }
public void CaptureFrame(Mat matrix) { if (uprightBuffer == null) { return; } MatUtils.copyToMat(uprightBuffer, matrix); Core.flip(matrix, matrix, 0); }
public static double CalcError(SMat3 origA, Vector3 x, Vector3 b) { var A = new Mat3(); A.SetSymmetric(origA); var vtmp = MatUtils.VMul(A, x); vtmp = b - vtmp; return(vtmp.Dot(vtmp)); }
private static float calcError(SMat3 origA, Vec3 x, Vec3 b) { Mat3 A = new Mat3(); Vec3 vtmp; A.setSymmetric(origA); MatUtils.vmul(out vtmp, A, x); VecUtils.sub(out vtmp, b, vtmp); return(VecUtils.dot(vtmp, vtmp)); }
public static float calcError(SMat3 origA, Vector3 x, Vector3 b) { Mat3 A = new Mat3(); Vector3 vtmp; A.setSymmetric(origA); MatUtils.vmul(out vtmp, A, x); vtmp = b - vtmp; return(Vector3.Dot(vtmp, vtmp)); }
public void read(object root_json) { IDictionary smodel_json = (IDictionary)root_json; IDictionary V_json = (IDictionary)smodel_json ["V"]; V = new Mat((int)(long)V_json ["rows"], (int)(long)V_json ["cols"], CvType.CV_32F); // Debug.Log ("V " + V.ToString ()); IList V_data_json = (IList)V_json ["data"]; float[] V_data = new float[V.rows() * V.cols()]; for (int i = 0; i < V_data_json.Count; i++) { V_data [i] = (float)(double)V_data_json [i]; } MatUtils.copyToMat(V_data, V); // Debug.Log ("V dump " + V.dump ()); IDictionary e_json = (IDictionary)smodel_json ["e"]; e = new Mat((int)(long)e_json ["rows"], (int)(long)e_json ["cols"], CvType.CV_32F); // Debug.Log ("e " + e.ToString ()); IList e_data_json = (IList)e_json ["data"]; float[] e_data = new float[e.rows() * e.cols()]; for (int i = 0; i < e_data_json.Count; i++) { e_data [i] = (float)(double)e_data_json [i]; } MatUtils.copyToMat(e_data, e); // Debug.Log ("e dump " + e.dump ()); IDictionary C_json = (IDictionary)smodel_json ["C"]; C = new Mat((int)(long)C_json ["rows"], (int)(long)C_json ["cols"], CvType.CV_32S); // Debug.Log ("C " + C.ToString ()); IList C_data_json = (IList)C_json ["data"]; int[] C_data = new int[C.rows() * C.cols()]; for (int i = 0; i < C_data_json.Count; i++) { C_data [i] = (int)(long)C_data_json [i]; } MatUtils.copyToMat(C_data, C); // Debug.Log ("C dump " + C.dump ()); p = Mat.zeros(e.rows(), 1, CvType.CV_32F); }
// Update is called once per frame void Update() { if (webCamTextureToMatHelper.IsPlaying() && webCamTextureToMatHelper.DidUpdateThisFrame()) { Mat rgbaMat = webCamTextureToMatHelper.GetMat(); Imgproc.cvtColor(rgbaMat, grayMat, Imgproc.COLOR_RGBA2GRAY); Imgproc.equalizeHist(grayMat, grayMat); // detect faces cascade.detectMultiScale(grayMat, faces, 1.1, 2, 2, // TODO: objdetect.CV_HAAR_SCALE_IMAGE new Size(grayMat.cols() * 0.2, grayMat.rows() * 0.2), new Size()); if (faces.total() > 0) { // fit landmarks for each found face List <MatOfPoint2f> landmarks = new List <MatOfPoint2f>(); facemark.fit(grayMat, faces, landmarks); Rect[] rects = faces.toArray(); for (int i = 0; i < rects.Length; i++) { //Debug.Log ("detect faces " + rects [i]); Imgproc.rectangle(rgbaMat, new Point(rects[i].x, rects[i].y), new Point(rects[i].x + rects[i].width, rects[i].y + rects[i].height), new Scalar(255, 0, 0, 255), 2); } // draw them for (int i = 0; i < landmarks.Count; i++) { MatOfPoint2f lm = landmarks[i]; float[] lm_float = new float[lm.total() * lm.channels()]; MatUtils.copyFromMat <float>(lm, lm_float); DrawFaceLandmark(rgbaMat, ConvertArrayToPointList(lm_float), new Scalar(0, 255, 0, 255), 2); //for (int j = 0; j < lm_float.Length; j = j + 2) //{ // Point p = new Point(lm_float[j], lm_float[j + 1]); // Imgproc.circle(rgbaMat, p, 2, new Scalar(255, 0, 0, 255), 1); //} } } // rgbaMat.convertTo(rgbaMat, CvType.CV_8UC3); // Debug.Log(rgbaMat.type()); // OpenCVForUnity.XphotoModule.Xphoto.applyChannelGains(rgbaMat, effectsMat, 1.0f,220.0f, 1.0f); // OpenCVForUnity.XphotoModule.Xphoto.oilPainting(effects, effects, 10, 10); Utils.fastMatToTexture2D(rgbaMat, texture); } }
public static float solveLeastSquares(Mat3 a, Vector3 b, Vector3 x, float svd_tol, int svd_sweeps, float pinv_tol) { Mat3 at; SMat3 ata; Vector3 atb; MatUtils.transpose(out at, a); MatUtils.mmul_ata(out ata, a); MatUtils.vmul(out atb, at, b); return(solveSymmetric(ata, atb, x, svd_tol, svd_sweeps, pinv_tol)); }
public static float solveSymmetric(SMat3 A, Vector3 b, Vector3 x, float svd_tol, int svd_sweeps, float pinv_tol) { Mat3 pinv; Mat3 V = new Mat3(); SMat3 VTAV = new SMat3(); getSymmetricSvd(A, VTAV, V, svd_tol, svd_sweeps); pseudoinverse(out pinv, VTAV, V, pinv_tol); MatUtils.vmul(out x, pinv, b); return(calcError(A, x, b)); }
void DoProcess() { if (!(mat.Value is OpenCVForUnityPlayMakerActions.Mat)) { LogError("mat is not initialized. Add Action \"newMat\"."); return; } OpenCVForUnity.CoreModule.Mat wrapped_mat = OpenCVForUnityPlayMakerActionsUtils.GetWrappedObject <OpenCVForUnityPlayMakerActions.Mat, OpenCVForUnity.CoreModule.Mat>(mat); MatUtils.copyToMat <int>(array.intValues, wrapped_mat); }
public static double SolveSymmetric(SMat3 A, Vector3 b, out Vector3 x, double svd_tol, int svd_sweeps, double pinv_tol) { var V = new Mat3(); var VTAV = new SMat3(); GetSymmetricSvd(A, VTAV, V, svd_tol, svd_sweeps); var pinv = PseudoInverse(VTAV, V, pinv_tol); x = MatUtils.VMul(pinv, b); return(CalcError(A, x, b)); }
public static float solveSymmetric(SMat3 A, Vec3 b, out Vec3 x, float svd_tol, int svd_sweeps, float pinv_tol) { Mat3 mtmp, pinv, V; SMat3 VTAV; getSymmetricSvd(A, out VTAV, out V, svd_tol, svd_sweeps); psuedoinverse(out pinv, VTAV, V, pinv_tol); MatUtils.vmul(out x, pinv, b); return(calcError(A, x, b)); }
public double GetError(Vector3 pos) { if (!hasSolution) { SetAta(); SetAtb(); } Vector3 atax = MatUtils.VMuSymmetric(ata, pos); return(pos.Dot(atax) - 2 * pos.Dot(atb) + QefData.btb); }
// ------------------------------------------------------------------------------- public float GetError(Vector3 pos) { if (!this.hasSolution) { this.SetAta(); this.SetAtb(); } Vector3 atax = MatUtils.Vmul_symmetric(this.ata, pos); return(VecUtils.Dot(pos, atax) - 2 * VecUtils.Dot(pos, this.atb) + this.data.btb); }
public Point[] calc_peaks(Mat im, Point[] points, Size ssize) { int n = points.Length; using (Mat pt = (new MatOfPoint2f(points)).reshape(1, 2 * n)) using (Mat S = calc_simil(pt)) using (Mat Si = inv_simil(S)) { float[] pt_float = new float[pt.total()]; MatUtils.copyFromMat <float>(pt, pt_float); int pt_cols = pt.cols(); float[] S_float = new float[S.total()]; MatUtils.copyFromMat <float>(S, S_float); int S_cols = S.cols(); float[] A_float = new float[2 * 3]; Point[] pts = apply_simil(Si, points); for (int i = 0; i < n; i++) { Size wsize = new Size(ssize.width + patches[i].patch_size().width, ssize.height + patches[i].patch_size().height); using (Mat A = new Mat(2, 3, CvType.CV_32F)) { MatUtils.copyFromMat <float>(A, A_float); int A_cols = A.cols(); A_float[0] = S_float[0]; A_float[1] = S_float[1]; A_float[1 * A_cols] = S_float[1 * S_cols]; A_float[(1 * A_cols) + 1] = S_float[(1 * S_cols) + 1]; A_float[2] = (float)(pt_float[(2 * pt_cols) * i] - (A_float[0] * (wsize.width - 1) / 2 + A_float[1] * (wsize.height - 1) / 2)); A_float[(1 * A_cols) + 2] = (float)(pt_float[((2 * pt_cols) * i) + 1] - (A_float[1 * A_cols] * (wsize.width - 1) / 2 + A_float[(1 * A_cols) + 1] * (wsize.height - 1) / 2)); MatUtils.copyToMat(A_float, A); using (Mat I = new Mat()) { Imgproc.warpAffine(im, I, A, wsize, Imgproc.INTER_LINEAR + Imgproc.WARP_INVERSE_MAP); using (Mat R = patches[i].calc_response(I, false)) { Core.MinMaxLocResult minMaxLocResult = Core.minMaxLoc(R); pts[i].x = pts[i].x + minMaxLocResult.maxLoc.x - 0.5 * ssize.width; pts[i].y = pts[i].y + minMaxLocResult.maxLoc.y - 0.5 * ssize.height; } } } } return(apply_simil(S, pts)); } }
public static void getSymmetricSvd(SMat3 a, SMat3 vtav, Mat3 v, float tol, int max_sweeps) { vtav.setSymmetric(a); v.set(1, 0, 0, 0, 1, 0, 0, 0, 1); float delta = tol * MatUtils.fnorm(vtav); for (int i = 0; i < max_sweeps && MatUtils.off(vtav) > delta; ++i) { rotate01(vtav, v); rotate02(vtav, v); rotate12(vtav, v); } }
public float getError(Vector3 pos) { if (!hasSolution) { setAta(); setAtb(); } Vector3 atax; MatUtils.vmul_symmetric(out atax, ata, pos); return(Vector3.Dot(pos, atax) - 2 * Vector3.Dot(pos, atb) + data.btb); }
void DoProcess() { System.Int64[] wrapped_array = OpenCVForUnityPlayMakerActionsUtils.GetWrappedObject <OpenCVForUnityPlayMakerActions.LongArray, System.Int64[]>(array); if (!(mat.Value is OpenCVForUnityPlayMakerActions.Mat)) { LogError("mat is not initialized. Add Action \"newMat\"."); return; } OpenCVForUnity.CoreModule.Mat wrapped_mat = OpenCVForUnityPlayMakerActionsUtils.GetWrappedObject <OpenCVForUnityPlayMakerActions.Mat, OpenCVForUnity.CoreModule.Mat>(mat); MatUtils.copyToMat <long>(wrapped_array, wrapped_mat); }
public static void GetSymmetricSvd(SMat3 a, SMat3 vtav, Mat3 v, double tol, int max_sweeps) { vtav.SetSymmetric(a); v.Set(1, 0, 0, 0, 1, 0, 0, 0, 1); double delta = tol * MatUtils.Norm(vtav); for (int i = 0; i < max_sweeps && MatUtils.off(vtav) > delta; ++i) { Rotate01(vtav, v); Rotate02(vtav, v); Rotate12(vtav, v); } }
void DoProcess() { if (!(mat.Value is OpenCVForUnityPlayMakerActions.Mat)) { LogError("mat is not initialized. Add Action \"newMat\"."); return; } OpenCVForUnity.CoreModule.Mat wrapped_mat = OpenCVForUnityPlayMakerActionsUtils.GetWrappedObject <OpenCVForUnityPlayMakerActions.Mat, OpenCVForUnity.CoreModule.Mat>(mat); System.Double[] wrapped_array = OpenCVForUnityPlayMakerActionsUtils.GetWrappedObject <OpenCVForUnityPlayMakerActions.DoubleArray, System.Double[]>(array); MatUtils.copyFromMat <double>(wrapped_mat, wrapped_array); }
/// <summary> /// Handles the event of a new image getting captured. /// </summary> /// <param name="imageData">The raw data of the image.</param> private void OnCaptureRawImageComplete(byte[] imageData) { lock (_cameraLockObject) { _isCapturing = false; } //// Initialize to 8x8 texture so there is no discrepency //// between uninitalized captures and error texture //Texture2D texture = new Texture2D(8, 8); //bool status = texture.LoadImage(imageData); //if (status && (texture.width != 8 && texture.height != 8)) //{ // _previewObject.SetActive(true); // Renderer renderer = _previewObject.GetComponent<Renderer>(); // if (renderer != null) // { // renderer.material.mainTexture = texture; // } //} Mat buff = new Mat(1, imageData.Length, CvType.CV_8UC1); MatUtils.copyToMat <byte>(imageData, buff); Mat imgMat = Imgcodecs.imdecode(buff, Imgcodecs.IMREAD_COLOR); // Debug.Log ("imgMat.ToString() " + imgMat.ToString ()); buff.Dispose(); Run(imgMat); Imgproc.cvtColor(imgMat, imgMat, Imgproc.COLOR_BGR2RGB); Texture2D outputTexture = new Texture2D(imgMat.width(), imgMat.height(), TextureFormat.RGBA32, false); Utils.matToTexture2D(imgMat, outputTexture); imgMat.Dispose(); //if (status && (texture.width != 8 && texture.height != 8)) //{ _previewObject.SetActive(true); Renderer renderer = _previewObject.GetComponent <Renderer>(); if (renderer != null) { renderer.material.mainTexture = outputTexture; } //} }
public void calc_params(Point[] pts, Mat weight, float c_factor) { int n = pts.Length; //assert(V.rows == 2*n); //Debug.Log ("V.rows == 2*n " + V.rows () + " " + 2 * n); using (Mat s = (new MatOfPoint2f(pts)).reshape(1, 2 * n)) { //point set to vector format if (weight.total() == 0) { Core.gemm(V.t(), s, 1, new Mat(), 0, p); //simple projection } else { //scaled projection if (weight.rows() != n) { Debug.Log("Invalid weighting matrix"); } float[] weight_float = new float[weight.total()]; MatUtils.copyFromMat <float>(weight, weight_float); int weight_cols = weight.cols(); int K = V.cols(); using (Mat H = Mat.zeros(K, K, CvType.CV_32F)) using (Mat g = Mat.zeros(K, 1, CvType.CV_32F)) { for (int i = 0; i < n; i++) { using (Mat v = new Mat(V, new OpenCVForUnity.CoreModule.Rect(0, 2 * i, K, 2))) using (Mat tmpMat1 = new Mat()) using (Mat tmpMat2 = new Mat()) using (Mat tmpMat3 = new Mat()) { float w = weight_float[i * weight_cols]; Core.multiply(v.t(), new Scalar(w), tmpMat1); Core.gemm(tmpMat1, v, 1, new Mat(), 0, tmpMat2); Core.add(H, tmpMat2, H); Core.gemm(tmpMat1, new MatOfPoint2f(pts[i]).reshape(1, 2), 1, new Mat(), 0, tmpMat3); Core.add(g, tmpMat3, g); } } Core.solve(H, g, p, Core.DECOMP_SVD); } } } clamp(c_factor); //clamp resulting parameters }
public float getError(Vec3 pos) { if (!this.hasSolution) { this.setAta(); this.setAtb(); } Vec3 atax; MatUtils.vmul_symmetric(out atax, this.ata, pos); return(VecUtils.dot(pos, atax) - 2.0f * VecUtils.dot(pos, this.atb) + this.data.btb); }
public Point[] getConnections() { Point[] c = new Point[smodel.C.rows()]; int[] data = new int[c.Length * 2]; MatUtils.copyFromMat <int> (smodel.C, data); int len = c.Length; for (int i = 0; i < len; i++) { c [i] = new Point(data [i * 2], data [(i * 2) + 1]); } return(c); }
void Update() { if (reader != null) { ColorFrame frame = reader.AcquireLatestFrame(); if (frame != null) { frame.CopyConvertedFrameDataToArray(data, ColorImageFormat.Rgba); frame.Dispose(); frame = null; } } else { return; } MatUtils.copyToMat(data, rgbaMat); if (filterType == FilterTypePreset.NONE) { Imgproc.putText(rgbaMat, "Filter Type: NONE " + texture.width + "x" + texture.height, new Point(5, texture.height - 5), Imgproc.FONT_HERSHEY_PLAIN, 4.0, new Scalar(255, 0, 0, 255), 3); } else if (filterType == FilterTypePreset.SEPIA) { Core.transform(rgbaMat, rgbaMat, sepiaKernel); Imgproc.putText(rgbaMat, "Filter Type: SEPIA " + texture.width + "x" + texture.height, new Point(5, texture.height - 5), Imgproc.FONT_HERSHEY_PLAIN, 4.0, new Scalar(255, 0, 0, 255), 3); } else if (filterType == FilterTypePreset.PIXELIZE) { Imgproc.resize(rgbaMat, pixelizeIntermediateMat, pixelizeSize0, 0.1, 0.1, Imgproc.INTER_NEAREST); Imgproc.resize(pixelizeIntermediateMat, rgbaMat, rgbaMat.size(), 0.0, 0.0, Imgproc.INTER_NEAREST); Imgproc.putText(rgbaMat, "Filter Type: PIXELIZE " + texture.width + "x" + texture.height, new Point(5, texture.height - 5), Imgproc.FONT_HERSHEY_PLAIN, 4.0, new Scalar(255, 0, 0, 255), 3); } else if (filterType == FilterTypePreset.COMIC) { comicFilter.Process(rgbaMat, rgbaMat); Imgproc.putText(rgbaMat, "Filter Type: COMIC " + texture.width + "x" + texture.height, new Point(5, texture.height - 5), Imgproc.FONT_HERSHEY_PLAIN, 4.0, new Scalar(255, 0, 0, 255), 3); } Utils.matToTexture2D(rgbaMat, texture); }
public static void getSymmetricSvd(SMat3 a, out SMat3 vtav, out Mat3 v, float tol, int max_sweeps) { vtav = new SMat3(); v = new Mat3(); vtav.setSymmetric(a); v.set(1, 0, 0, 0, 1, 0, 0, 0, 1); float delta = tol * MatUtils.fnorm(vtav); for (int i = 0; i < max_sweeps && MatUtils.off(vtav) > delta; ++i) { Schur2.rotate01(out vtav, out v, vtav, v); Schur2.rotate02(out vtav, out v, vtav, v); Schur2.rotate12(out vtav, out v, vtav, v); } }
Point[] apply_simil(Mat S, Point[] points) { float[] S_float = new float[S.total()]; MatUtils.copyFromMat <float> (S, S_float); int S_cols = S.cols(); int n = points.Length; Point[] p = new Point[n]; for (int i = 0; i < n; i++) { p [i] = new Point(); p [i].x = S_float [0] * points [i].x + S_float [1] * points [i].y + S_float [2]; p [i].y = S_float [1 * S_cols] * points [i].x + S_float [(1 * S_cols) + 1] * points [i].y + S_float [(1 * S_cols) + 2]; } return(p); }
public void read(object root_json) { IDictionary pmodel_json = (IDictionary)root_json; IDictionary P_json = (IDictionary)pmodel_json["P"]; P = new Mat((int)(long)P_json["rows"], (int)(long)P_json["cols"], CvType.CV_32F); //Debug.Log ("P " + P.ToString ()); IList P_data_json = (IList)P_json["data"]; float[] P_data = new float[P.rows() * P.cols()]; for (int i = 0; i < P_data_json.Count; i++) { P_data[i] = (float)(double)P_data_json[i]; } MatUtils.copyToMat(P_data, P); }
/// <summary> /// Processes the received frame, converts the image to grayscale if requested, and invokes the next photo request. /// </summary> private void OnCapturedPhotoToMemory(PhotoCapture.PhotoCaptureResult result, PhotoCaptureFrame photoCaptureFrame) { if (_stopped?.Task != null) { return; } if (result.resultType == PhotoCapture.CaptureResultType.UnknownError) { return; } if (photoCaptureFrame == null) { return; } Size size = new Size(FrameWidth, (double)FrameHeight * 3 / 2); // Luminance (grayscale) of the NV12 format requires image height, chrominance is stored in half resolution. <see href="https://docs.microsoft.com/en-us/windows/win32/medfound/recommended-8-bit-yuv-formats-for-video-rendering#nv12"/>. _image = new Mat(size, CvType.CV_8UC1); List <byte> imageBuffer = new List <byte>(); photoCaptureFrame?.CopyRawImageDataIntoBuffer(imageBuffer); MatUtils.copyToMat(imageBuffer.ToArray(), _image); if (_format == ColorFormat.Grayscale) { Imgproc.cvtColor(_image, _image, Imgproc.COLOR_YUV2GRAY_NV12); } Matrix4x4 cameraToWorldMatrix = Matrix4x4.identity; photoCaptureFrame?.TryGetCameraToWorldMatrix(out cameraToWorldMatrix); CameraExtrinsic extrinsic = new CameraExtrinsic(cameraToWorldMatrix); Matrix4x4 projectionMatrix = Matrix4x4.identity; photoCaptureFrame?.TryGetProjectionMatrix(out projectionMatrix); CameraIntrinsic intrinsic = new CameraIntrinsic(projectionMatrix); CameraFrame cameraFrame = new CameraFrame(_image, intrinsic, extrinsic, FrameWidth, FrameHeight, FrameCount++, _format); FrameArrivedEventArgs args = new FrameArrivedEventArgs(cameraFrame); FrameArrived?.Invoke(this, args); _photoCaptureObject?.TakePhotoAsync(OnCapturedPhotoToMemory); }
void DoProcess() { if (!(mat.Value is OpenCVForUnityPlayMakerActions.Mat)) { LogError("mat is not initialized. Add Action \"newMat\"."); return; } OpenCVForUnity.CoreModule.Mat wrapped_mat = OpenCVForUnityPlayMakerActionsUtils.GetWrappedObject <OpenCVForUnityPlayMakerActions.Mat, OpenCVForUnity.CoreModule.Mat>(mat); int[] tmpArray = new int[array.Length]; MatUtils.copyFromMat <int>(wrapped_mat, tmpArray); for (int i = 0; i < tmpArray.Length; i++) { array.Set(i, (float)tmpArray[i]); } array.SaveChanges(); }