protected DataType(Source src, Namescope parent, string comment, Modifiers modifiers, string name) : base(src, parent, name) { DocComment = comment; Modifiers = modifiers; Interfaces = InterfaceTypes.Empty; Attributes = AttributeList.Empty; SourceFiles.Add(src.FullPath); if (!IsGenericParameter && parent is DataType && (parent as DataType).IsFlattenedDefinition) { var parentParams = (parent as DataType).FlattenedParameters; _flattenedParameters = new GenericParameterType[parentParams.Length]; for (int i = 0; i < _flattenedParameters.Length; i++) { _flattenedParameters[i] = parentParams[i]; } } if (IsIntrinsic) { Intrinsics.TryGetValue(QualifiedName, out BuiltinType); } }
static float[] ProjectPointToPixel(Intrinsics intrin, float[] point) { float[] pixel = new float[2]; //assert(intrin->model != RS2_DISTORTION_INVERSE_BROWN_CONRADY); // Cannot project to an inverse-distorted image float x = point[0] / point[2], y = point[1] / point[2]; if (intrin.model == Distortion.ModifiedBrownConrady) { float r2 = x * x + y * y; float f = 1 + intrin.coeffs[0] * r2 + intrin.coeffs[1] * r2 * r2 + intrin.coeffs[4] * r2 * r2 * r2; x *= f; y *= f; float dx = x + 2 * intrin.coeffs[2] * x * y + intrin.coeffs[3] * (r2 + 2 * x * x); float dy = y + 2 * intrin.coeffs[3] * x * y + intrin.coeffs[2] * (r2 + 2 * y * y); x = dx; y = dy; } if (intrin.model == Distortion.Ftheta) { float r = (float)Math.Sqrt(x * x + y * y); float rd = (float)(1.0f / intrin.coeffs[0] * Math.Atan((2 * r * Math.Tan(intrin.coeffs[0] / 2.0f)))); x *= rd / r; y *= rd / r; } pixel[0] = x * intrin.fx + intrin.ppx; pixel[1] = y * intrin.fy + intrin.ppy; return(pixel); }
private TypedArrayInstance( Engine engine, Intrinsics intrinsics) : base(engine) { _intrinsics = intrinsics; _viewedArrayBuffer = new ArrayBufferInstance(engine, 0); }
private void StartProcessingBlock(Action <VideoFrame> depth, Action <VideoFrame> color) { processingBlock.Start(f => { using (var frames = FrameSet.FromFrame(f)) { VideoFrame colorFrame = frames.ColorFrame.DisposeWith(frames); Intrinsics depthintr = (pp.GetStream(Stream.Depth).As <VideoStreamProfile>()).GetIntrinsics(); DepthFrame depthFrame = frames.DepthFrame.DisposeWith(frames); VideoFrame colorizedDepth = colorizer.Process <VideoFrame>(depthFrame).DisposeWith(frames); Dispatcher.Invoke(DispatcherPriority.Render, depth, colorizedDepth); Dispatcher.Invoke(DispatcherPriority.Render, color, colorFrame); } }); Task.Factory.StartNew(() => { while (true) { using (var frames = pipeline.WaitForFrames()) { // Invoke custom processing block processingBlock.Process(frames); } } }); }
public static unsafe int test_0_stobj() { byte *ptr = stackalloc byte [20]; Intrinsics.UnalignedStobj <short> (ptr + 0, 0x6688); if (ptr [0] != 0x88 || ptr [1] != 0x66) { return(1); } Intrinsics.UnalignedStobj <short> (ptr + 1, 0x6589); if (ptr [1] != 0x89 || ptr [2] != 0x65) { return(2); } Intrinsics.UnalignedStobj <int> (ptr + 1, 0x60708090); if (ptr [1] != 0x90 || ptr [2] != 0x80 || ptr [3] != 0x70 || ptr [4] != 0x60) { return(3); } Intrinsics.UnalignedStobj <long> (ptr + 1, 0x405060708090); if (ptr [1] != 0x90 || ptr [2] != 0x80 || ptr [3] != 0x70 || ptr [4] != 0x60 || ptr [5] != 0x50 || ptr [6] != 0x40) { return(4); } return(0); }
/// <summary> /// Creates a call instruction to the given method with the given arguments. /// </summary> /// <param name="method">The target method to invoke.</param> /// <param name="arguments">The call arguments.</param> private void CreateCall( MethodBase method, ImmutableArray <ValueReference> arguments) { var intrinsicContext = new InvocationContext( this, Location, Block, Method, method, arguments); // Check for internal remappings first RemappedIntrinsics.RemapIntrinsic(ref intrinsicContext); // Early rejection for runtime-dependent methods VerifyNotRuntimeMethod(intrinsicContext.Method); // Handle device functions if (!Intrinsics.HandleIntrinsic(intrinsicContext, out var result)) { var targetFunction = DeclareMethod(intrinsicContext.Method); result = Builder.CreateCall( Location, targetFunction, intrinsicContext.Arguments); } // Setup result if (result.IsValid && !result.Type.IsVoidType) { Block.Push(result); } }
public Camera(Intrinsics intrinsics, int width, int height, float metricRadius) { Intrinsics = intrinsics; Width = width; Height = height; MetricRadius = metricRadius; }
private void projectPixelToPoint(ref Vector3 o_Point, Intrinsics i_Intrin, float[] i_Pixel, float depth) { float x = (i_Pixel[0] - i_Intrin.Ppx) / i_Intrin.Fx; float y = (i_Pixel[1] - i_Intrin.Ppy) / i_Intrin.Fy; if (i_Intrin.Model == Distortion.InverseBrownConrady) { float r2 = (x * x) + (y * y); float f = 1 + (i_Intrin.Coeffs[0] * r2) + (i_Intrin.Coeffs[1] * r2 * r2) + (i_Intrin.Coeffs[4] * r2 * r2 * r2); float ux = (x * f) + (2 * i_Intrin.Coeffs[2] * x * y) + (i_Intrin.Coeffs[3] * (r2 + (2 * x * x))); float uy = (y * f) + (2 * i_Intrin.Coeffs[3] * x * y) + (i_Intrin.Coeffs[2] * (r2 + (2 * y * y))); x = ux; y = uy; } if (i_Intrin.Model == Distortion.Ftheta) { float rd = (float)Math.Sqrt((x * x) + (y * y)); if (rd < FLT_EPSILON) { rd = FLT_EPSILON; } float r = (float)Math.Tan((i_Intrin.Coeffs[0] * rd) / Math.Atan(2 * Math.Tan(i_Intrin.Coeffs[0] / 2.0f))); x *= r / rd; y *= r / rd; } o_Point.X = depth * x; o_Point.Y = depth * y; o_Point.Z = depth; }
public static long UInt64Remainder(long dividend, long divisor) { //From google-guava if (divisor < 0) // i.e., divisor >= 2^63 { if (compare(dividend, divisor) < 0) { return(dividend); // dividend < divisor } else { return(dividend - divisor); // dividend >= divisor } } // Optimization - use signed modulus if dividend < 2^63 if (dividend >= 0) { return(dividend % divisor); } /* * Otherwise, approximate the quotient, check, and correct if necessary. Our approximation is * guaranteed to be either exact or one less than the correct value. This follows from fact * that floor(floor(x)/i) == floor(x/i) for any real x and integer i != 0. The proof is not * quite trivial. */ long quotiend = (Intrinsics.lushr(dividend, 1) / divisor) << 1; long rem = dividend - quotiend * divisor; return(rem - (compare(rem, divisor) >= 0 ? divisor : 0L)); }
public static string Substring(string self, int startIndex, int length) { if (startIndex < 0) { throw new ArgumentOutOfRangeException("startIndex"); } if (startIndex > self.Length) { throw new ArgumentOutOfRangeException("startIndex"); } if (length < 0) { throw new ArgumentOutOfRangeException("length"); } if (startIndex > self.Length - length) { throw new ArgumentOutOfRangeException("length"); } if (length == 0) { return(string.Empty); } if ((startIndex == 0) && (length == self.Length)) { return(self); } return(Intrinsics.ToJavaString(self).substring(startIndex, startIndex + length)); }
public static bool RequiresReflectionMethodBodyScannerForCallSite(FlowAnnotations flowAnnotations, MethodDesc methodDefinition) { return(Intrinsics.GetIntrinsicIdForMethod(methodDefinition) > IntrinsicId.RequiresReflectionBodyScanner_Sentinel || flowAnnotations.RequiresDataflowAnalysis(methodDefinition) || methodDefinition.DoesMethodRequire(DiagnosticUtilities.RequiresUnreferencedCodeAttribute, out _) || methodDefinition.DoesMethodRequire(DiagnosticUtilities.RequiresDynamicCodeAttribute, out _) || methodDefinition.IsPInvoke); }
public static int Compare(string strA, string strB, bool ignoreCase) { if (ignoreCase) { return(Intrinsics.ToJavaString(strA).compareToIgnoreCase(strB)); } return(Intrinsics.ToJavaString(strA).compareTo(strB)); }
private void Init() { using Context ctx = new Context(); var devices = ctx.QueryDevices(); Console.WriteLine($"Found {devices.Count} RealSense devices connected."); if (devices.Count == 0) { throw new Exception("No RealSense device detected!"); } Device dev = devices[0]; Console.WriteLine($"Using device 0: {dev.Info[CameraInfo.Name]}"); Console.WriteLine("Device Sources:"); foreach (Sensor sensor in dev.Sensors) { Console.WriteLine($"Sensor found: {sensor.Info[CameraInfo.Name]}"); } var cfg = new Config(); cfg.EnableStream(Stream.Depth); cfg.EnableStream(Stream.Color, Format.Bgr8); intelPipe = new Intel.RealSense.Pipeline(); PipelineProfile profileIntelPipe = intelPipe.Start(cfg); var streamDepth = profileIntelPipe.GetStream <VideoStreamProfile>(Stream.Depth); sicsDepth = streamDepth.GetIntrinsics(); Console.WriteLine($"Depth Stream: {sicsDepth.width}X{sicsDepth.height}"); var streamRBG = profileIntelPipe.GetStream <VideoStreamProfile>(Stream.Color); sicsRBG = streamRBG.GetIntrinsics(); Console.WriteLine($"RBG Stream: {sicsRBG.width}X{sicsRBG.height}"); Task.Run(() => { while (true) { try { using FrameSet frames = intelPipe.WaitForFrames(); using Frame frDepth = frames.FirstOrDefault(Stream.Depth); qDepth.Enqueue(frDepth); using Frame frRBG = frames.FirstOrDefault(Stream.Color); qRBG.Enqueue(frRBG); } catch (Exception e) { Console.WriteLine(e.Message); } } }); }
protected override bool ReportSpecialIncompatibleMembersDiagnostic(OperationAnalysisContext operationContext, ImmutableArray <ISymbol> specialIncompatibleMembers, ISymbol member) { // Some RUC-annotated APIs are intrinsically handled by the trimmer if (member is IMethodSymbol method && Intrinsics.GetIntrinsicIdForMethod(new MethodProxy(method)) != IntrinsicId.None) { return(true); } return(false); }
private ClusterMemberId(SocketAddress address) { var hash = Intrinsics.GetHashCode64(SocketAddressByteGetter64, address.Size, address, false); Intrinsics.Bitcast(in hash, out this.address); port = Intrinsics.GetHashCode32(SocketAddressByteGetter32, address.Size, address, false); family = (int)address.Family; length = address.Size; }
/// <summary> /// Creates a new coordinate mapper with the specified intrinsics and extrinsics parameters. /// </summary> /// <param name="colorIntrinsics">The color intrinsics.</param> /// <param name="colorExtrinsics">The color extrinsics.</param> /// <param name="depthIntrinsics">The depth intrinsics.</param> /// <param name="depthExtrinsics">The depth extrinsics.</param> /// <returns>The coordinate mapper with the given intrinsics and extrinsics.</returns> public static CoordinateMapper Create(Intrinsics colorIntrinsics, Extrinsics colorExtrinsics, Intrinsics depthIntrinsics, Extrinsics depthExtrinsics) { return(new CoordinateMapper ( colorIntrinsics, colorExtrinsics, depthIntrinsics, depthExtrinsics )); }
public static unsafe int test_0_cpblk() { byte *dest = stackalloc byte [20]; byte *src = stackalloc byte [20]; for (int i = 0; i < 20; ++i) { src [i] = (byte)i; } Intrinsics.UnalignedCpblk(dest + 0, src + 0, 2); if (dest [0] != src [0] || dest [1] != src [1]) { return(1); } Intrinsics.UnalignedCpblk(dest + 1, src + 0, 2); if (dest [1] != src [0] || dest [2] != src [1]) { return(2); } Intrinsics.UnalignedCpblk(dest + 0, src + 1, 2); if (dest [0] != src [1] || dest [1] != src [2]) { return(3); } Intrinsics.UnalignedCpblk(dest + 1, src + 1, 2); if (dest [1] != src [1] || dest [2] != src [2]) { return(3); } Intrinsics.UnalignedCpblk(dest + 1, src + 1, 4); for (int i = 0; i < 4; ++i) { if (dest [i + 1] != src [i + 1]) { return(4); } } Intrinsics.UnalignedCpblk(dest + 1, src + 1, 8); for (int i = 0; i < 8; ++i) { if (dest [i + 1] != src [i + 1]) { return(5); } } return(0); }
/// <summary> /// 開啟RealSense相機並進行取像 /// </summary> internal void Open(out Image <Bgr, byte> ColorImg, out Image <Rgb, byte> DepthImg, out Image <Rgb, byte> FilteredImg, out VideoFrame color, out DepthFrame depth, out Frame filtered) { DepthImg = null; ColorImg = null; FilteredImg = null; color = null; depth = null; filtered = null; if (CamState != CameraState.Opened) { PipelineProfile = Camera.Start(cfg); // 以cfg設定並開始串流 vsp = PipelineProfile.GetStream <VideoStreamProfile>(Intel.RealSense.Stream.Depth); // 取得內部參數 intrinsics = vsp.GetIntrinsics(); sp = PipelineProfile.GetStream(Intel.RealSense.Stream.Color); // 取得外部參數 extrinsics = vsp.GetExtrinsicsTo(sp); CamState = CameraState.Opened; // 更新相機狀態 } else { try { FrameSet frames = Camera.WaitForFrames(); depth = frames.DepthFrame.DisposeWith(frames); color = frames.ColorFrame.DisposeWith(frames); filtered = depth; if (depth != null) { //Thres_Filter.Options[Option.MinDistance].Value = float.Parse(form1.textBox2.Text); //Thres_Filter.Options[Option.MaxDistance].Value = float.Parse(form1.textBox1.Text); //filtered = Thres_Filter.Process(filtered); //Spa_Filter.Options[Option.FilterMagnitude].Value = 1; //Spa_Filter.Options[Option.FilterSmoothAlpha].Value = 0.6f; //Spa_Filter.Options[Option.FilterSmoothDelta].Value = 8; //filtered = Spa_Filter.Process(filtered); Temp_Filter.Options[Option.FilterSmoothAlpha].Value = 0.5f; Temp_Filter.Options[Option.FilterSmoothDelta].Value = 20; Temp_Filter.Options[Option.HolesFill].Value = 2; filtered = Temp_Filter.Process(filtered); depColor = colorizer.Colorize(depth); filteredColor = colorizer.Colorize(filtered); ColorImg = new Image <Bgr, byte>(color.Width, color.Height, color.Stride, color.Data); DepthImg = new Image <Rgb, byte>(depColor.Width, depColor.Height, depColor.Stride, depColor.Data); FilteredImg = new Image <Rgb, byte>(filteredColor.Width, filteredColor.Height, filteredColor.Stride, filteredColor.Data); } } catch (Exception ex) { throw ex; } } }
public CameraCalibrationResult(int _width, int _height, Extrinsics __extrinsics, Intrinsics __intrinsics, Distortion __distortion, double _error) { width = _width; height = _height; this._extrinsics = __extrinsics; this._intrinsics = __intrinsics; this._distortion = __distortion; error = _error; }
public TypedReference GetNextArg() { if (current >= arglist.Length) { throw new InvalidOperationException(Local.GetText("An attempt was made to read beyond the end of the list.")); } TypedReference result = new TypedReference(Intrinsics.CreatePointerToArray(arglist, current), Intrinsics.GetClass(typeof(object))); current++; return(result); }
/// <summary> /// Concatenates the array with the specified span of elements. /// </summary> /// <typeparam name="T">The type of elements in the array.</typeparam> /// <param name="left">The array to concatenate.</param> /// <param name="right">The tail of concatenation.</param> /// <param name="startIndex">The starting index in <paramref name="left"/> at which <paramref name="right"/> should be inserted.</param> /// <returns>The array representing all elements from <paramref name="left"/> up to <paramref name="startIndex"/> exclusively including elements from <paramref name="right"/>.</returns> /// <exception cref="ArgumentOutOfRangeException"><paramref name="startIndex"/> is less than 0 or greater than length of <paramref name="left"/> array.</exception> public static T[] Concat <T>(this T[] left, T[] right, long startIndex) { if (startIndex < 0 || startIndex > Intrinsics.GetLength(left)) { throw new ArgumentOutOfRangeException(nameof(startIndex)); } var result = new T[startIndex + right.LongLength]; Array.Copy(left, result, startIndex); Array.Copy(right, 0L, result, startIndex, right.Length); return(result); }
public static int CompareTo(string self, object value) { if (value == null) { return(1); } if (!(value is string)) { throw new ArgumentException(Local.GetText("value must be string")); } return(Intrinsics.ToJavaString(self).compareTo((string)value)); }
public static string Concat(object arg0, object arg1) { if (arg0 == null) { arg0 = string.Empty; } if (arg1 == null) { arg1 = string.Empty; } return(Intrinsics.ToJavaString(arg0.ToString()).concat(arg0.ToString())); }
/// <summary> /// Pops the required arguments from the stack. /// </summary> /// <param name="location">The current location.</param> /// <param name="methodBase">The method to use for the argument types.</param> /// <param name="instanceValue">The instance value (if available).</param> public ImmutableArray <ValueReference> PopMethodArgs( Location location, MethodBase methodBase, Value instanceValue) { var parameters = methodBase.GetParameters(); var parameterOffset = methodBase.GetParameterOffset(); var result = ImmutableArray.CreateBuilder <ValueReference>( parameters.Length + parameterOffset); // Handle main params for (int i = parameters.Length - 1; i >= 0; --i) { var param = parameters[i]; var argument = Pop( Builder.CreateType(param.ParameterType), param.ParameterType.IsUnsignedInt() ? ConvertFlags.TargetUnsigned : ConvertFlags.None); result.Add(argument); } // Check instance value if (parameterOffset > 0) { if (instanceValue == null) { var declaringType = Builder.CreateType(methodBase.DeclaringType); if (!Intrinsics.IsIntrinsicArrayType(methodBase.DeclaringType)) { declaringType = Builder.CreatePointerType( declaringType, MemoryAddressSpace.Generic); } instanceValue = Pop( declaringType, ConvertFlags.None); } else { // Wire instance instanceValue = Builder.CreateAddressSpaceCast( location, instanceValue, MemoryAddressSpace.Generic); } result.Add(instanceValue); } result.Reverse(); return(result.MoveToImmutable()); }
private protected unsafe UnmanagedMemory(int length, bool zeroMem) { var size = SizeOf(length); address = Marshal.AllocHGlobal(new IntPtr(size)); GC.AddMemoryPressure(size); Length = length; if (zeroMem) { Intrinsics.ClearBits(address.ToPointer(), size); } owner = true; }
/// <summary> /// Checks whether the specified value is equal to one /// of the specified values. /// </summary> /// <remarks> /// This method uses <see cref="IEquatable{T}.Equals(T)"/> /// to check equality between two values. /// </remarks> /// <typeparam name="T">The type of object to compare.</typeparam> /// <param name="value">The value to compare with other.</param> /// <param name="values">Candidate objects.</param> /// <returns><see langword="true"/>, if <paramref name="value"/> is equal to one of <paramref name="values"/>.</returns> public static bool IsOneOf <T>(this T value, params T[] values) where T : struct, IEquatable <T> { for (nint i = 0; i < Intrinsics.GetLength(values); i++) { if (values[i].Equals(value)) { return(true); } } return(false); }
/// <summary> /// Checks whether the specified object is equal to one /// of the specified objects. /// </summary> /// <remarks> /// This method uses <see cref="object.Equals(object, object)"/> /// to check equality between two objects. /// </remarks> /// <typeparam name="T">The type of object to compare.</typeparam> /// <param name="value">The object to compare with other.</param> /// <param name="values">Candidate objects.</param> /// <returns><see langword="true"/>, if <paramref name="value"/> is equal to one of <paramref name="values"/>.</returns> public static bool IsOneOf <T>(this T value, params T?[] values) where T : class { for (nint i = 0; i < Intrinsics.GetLength(values); i++) { if (Equals(values[i], value)) { return(true); } } return(false); }
internal TypedArrayInstance( Engine engine, Intrinsics intrinsics, TypedArrayElementType type, uint length) : this(engine, intrinsics) { _arrayElementType = type; _arrayLength = length; _contentType = type != TypedArrayElementType.BigInt64 && type != TypedArrayElementType.BigUint64 ? TypedArrayContentType.Number : TypedArrayContentType.BigInt; }
public static string Concat(string str0, string str1) { if (str0 == null) { str0 = string.Empty; } if (str1 == null) { str1 = string.Empty; } return(Intrinsics.ToJavaString(str0).concat(str1)); }
private static bool ValidComputer(Intrinsics flags = Intrinsics.None) { if (!RemoteExecutor.IsSupported) { return(false); } if (flags == Intrinsics.None) { return(true); } // I realize we could do a bitwise AND operation here, but this isn't really written for performance. if (flags.HasFlag(Intrinsics.Sse) && !Sse.IsSupported) { return(false); } if (flags.HasFlag(Intrinsics.Sse2) && !Sse2.IsSupported) { return(false); } if (flags.HasFlag(Intrinsics.Sse3) && !Sse3.IsSupported) { return(false); } if (flags.HasFlag(Intrinsics.Avx) && !Avx.IsSupported) { return(false); } if (flags.HasFlag(Intrinsics.Avx2) && !Avx2.IsSupported) { return(false); } if (flags.HasFlag(Intrinsics.AdvSimd) && !AdvSimd.IsSupported) { return(false); } if (flags.HasFlag(Intrinsics.AdvSimdArm64) && !AdvSimd.IsSupported) { return(false); } return(true); }
public Camera(string name, string uuid, Size imageSize, PointF principalPointEstimate, double focalLength, double nearPlaneDistance, double farPlaneDistance, int numRadialDistortionCoefficients) { PathToIntrinsics = GetPathToIntrinsics(name, uuid); Name = name; Uuid = uuid; NumRadialDistortionCoefficients = numRadialDistortionCoefficients; World = Matrix.Identity; View = Matrix.Identity; if (!String.IsNullOrWhiteSpace(PathToIntrinsics)) if (File.Exists(PathToIntrinsics)) using (var fs = File.OpenRead(PathToIntrinsics)) Intrinsics = new Intrinsics(imageSize, nearPlaneDistance, farPlaneDistance, fs); if (Intrinsics == null) Intrinsics = new Intrinsics(imageSize, principalPointEstimate, focalLength, nearPlaneDistance, farPlaneDistance, numRadialDistortionCoefficients); Frustum = new Frustum(imageSize, this); Text = new Text(Name, World.Translation, Color.Black); }
//called when data for any output pin is requested public void Evaluate(int SpreadMax) { if (FPinInDo[0]) { int nPointsPerImage = FPinInObject.SliceCount; bool useVVVVCoords = FPinInCoordSystem[0] == TCoordinateSystem.VVVV; if (nPointsPerImage == 0) { FStatus[0] = "Insufficient points"; return; } int nImages = FPinInImage.SliceCount / nPointsPerImage; MCvPoint3D32f[][] objectPoints = new MCvPoint3D32f[nImages][]; PointF[][] imagePoints = new PointF[nImages][]; Size imageSize = new Size( (int) FPinInSensorSize[0].x, (int) FPinInSensorSize[0].y); CALIB_TYPE flags = new CALIB_TYPE(); IntrinsicCameraParameters intrinsicParam = new IntrinsicCameraParameters(); ExtrinsicCameraParameters[] extrinsicsPerView; GetFlags(out flags); if (flags.HasFlag(CALIB_TYPE.CV_CALIB_USE_INTRINSIC_GUESS)) { if (FPinInIntrinsics[0] == null) { Matrix<double> mat = intrinsicParam.IntrinsicMatrix; mat[0, 0] = FPinInSensorSize[0].x / 2.0d; mat[1, 1] = FPinInSensorSize[0].y / 2.0d; mat[0, 2] = FPinInSensorSize[0].x / 2.0d; mat[1, 2] = FPinInSensorSize[0].y / 2.0d; mat[2, 2] = 1; } else { intrinsicParam.DistortionCoeffs = FPinInIntrinsics[0].intrinsics.DistortionCoeffs.Clone(); intrinsicParam.IntrinsicMatrix = FPinInIntrinsics[0].intrinsics.IntrinsicMatrix.Clone(); } } imagePoints = MatrixUtils.ImagePoints(FPinInImage, nPointsPerImage); for (int i=0; i<nImages; i++) { objectPoints[i] = MatrixUtils.ObjectPoints(FPinInObject, useVVVVCoords); } try { FPinOutError[0] = CameraCalibration.CalibrateCamera(objectPoints, imagePoints, imageSize, intrinsicParam, flags, out extrinsicsPerView); Intrinsics intrinsics = new Intrinsics(intrinsicParam, imageSize); FPinOutIntrinsics[0] = intrinsics; if (useVVVVCoords) FPinOutProjection[0] = intrinsics.Matrix; else FPinOutProjection[0] = intrinsics.Matrix; FPinOutExtrinsics.SliceCount = nImages; FPinOutView.SliceCount = nImages; for (int i = 0; i < nImages; i++) { Extrinsics extrinsics = new Extrinsics(extrinsicsPerView[i]); FPinOutExtrinsics[i] = extrinsics; if (useVVVVCoords) FPinOutView[i] = MatrixUtils.ConvertToVVVV(extrinsics.Matrix); else FPinOutView[i] = extrinsics.Matrix; } FPinOutSuccess[0] = true; FStatus[0] = "OK"; } catch (Exception e) { FPinOutSuccess[0] = false; FStatus[0] = e.Message; } } }