private void Initialize(OperandType operandType, Type type, Type dataType, Int32 length, string xmlPath, PropertyInfo propertyInstance, ComparisonMethod comparisonMethod, object value, bool isSelect, Expression expression) { // need to do a check there if it is a expression if (expression == Expression.None) { if (type == null) { throw new ApplicationException("Could not initialize selection criterion; type is null!"); } if (propertyInstance == null) { throw new ApplicationException(string.Format("Could not initialize selection criterion; property ({0}) does not exist!", m_OriginalPropertyName)); } } m_Type = type; m_DataType = dataType; m_Length = length; m_XmlPath = xmlPath; m_OperandType = operandType; m_Property = propertyInstance; m_ComparisonMethod = comparisonMethod; if (isSelect && value is string) { value = (value as string).Replace("'", "''"); } m_Value = value; m_Expression = expression; }
/// <summary> /// Calculates the ΔE of two colors, using the specified comparison method. /// This value represents the perceptual difference between the two colors. /// </summary> /// <param name="color1">The first color</param> /// <param name="color2">The second color</param> /// <param name="method"> /// The algorith to use for the comparison. /// There is an efficiency/accuracy trade-off between the different methods.</param> /// <returns>ΔE value representing the perceived difference between the two colors.</returns> public static double Compare(ColorSpace color1, ColorSpace color2, ComparisonMethod method = ComparisonMethod.Cie2000) { if (color1 == null || color2 == null) { throw new NullReferenceException("Neither color1 or color2 may be null"); } switch (method) { case ComparisonMethod.Cie1976: return(CompareCie1976(color1, color2)); case ComparisonMethod.Cie1994: return(CompareCie1994(color1, color2)); case ComparisonMethod.Cie2000: return(CompareCie2000(color1, color2)); case ComparisonMethod.Cmc1984: return(CompareCmc1984(color1, color2)); default: throw new ArgumentException("Unrecognized comparison method", nameof(method)); } }
/// <summary> /// Compare images /// </summary> /// <param name="image1"> 1st image</param> /// <param name="image2"> 2nd image</param> /// <param name="method"> method</param> /// <returns>Similarity % )</returns> public static double CompareImages(Image image1, Image image2, ComparisonMethod method) { double sim = 0; try { var mat1 = BitmapConverter.ToMat(new Bitmap(image1)); var mat2 = BitmapConverter.ToMat(new Bitmap(image2)); sim = CompareImages(mat1, mat2, method); mat1.Dispose(); mat2.Dispose(); } catch (System.AccessViolationException) { //Console.Error.WriteLine("Access Error => CompareImages {0} : \n{1}", method, e); } catch (OutOfMemoryException) { //The file does not have a valid image format. //-or- GDI+ does not support the pixel format of the file //Console.Error.WriteLine("Memory Error => CompareImages {0} : \n{1}", method, e); } catch (Exception e) { Console.Error.WriteLine("Error => CompareImages {0} : \n{1}", method, e); } return(sim); }
private void IsSolutionOrAssemblyExistingInTargetEnv() { WorkAsync(new WorkAsyncInfo { Message = $"Checking if the {ComparisonMethod.Name} name exists in the target environment...", Work = (bw, e) => { e.Result = ComparisonMethod.ExistsInTarget(Controller.DataManager, SolutionAssemblyPluginStepsName); }, PostWorkCallBack = e => { if (e.Error != null) { Log.LogData(EventType.Exception, ComparisonMethod.LogActionOnExistsInTarget, e.Error); MessageBox.Show(this, e.Error.Message, @"Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } if ((bool)e.Result) { MessageBox.Show($@"The {ComparisonMethod.Name} doesn't exist in the Target environment. \rThe compare function will return a ""Perfect match"" in this case.\r\r You will still have the possibility to copy steps from the Source to Target environment.", @"Information", MessageBoxButtons.OK, MessageBoxIcon.Warning); } }, ProgressChanged = e => { SetWorkingMessage(e.UserState.ToString()); } }); }
public WhereCondition(string columnName, ComparisonMethod comparisonMethod, object value, Predicate predicate) { ColumnName = columnName; Comparator = comparisonMethod; Value = value; Predicate = predicate; }
public override string ToString() { return(string.Format("[SelectionCriteria] - Type: {0}, OperandType: {1}, Property: {2}, Comparison: {3}, Value: {4}", (Type != null) ? Type.ToString() : "null", OperandType.ToString(), (Property != null) ? Property.Name : "null", ComparisonMethod.ToString(), (Value != null) ? Value.ToString() : "null")); }
private void CompareWithDump (ComparisonMethod cm, string dump, bool testTrue) { string testDump = CharCategoryUtils.GenerateDump (cm, testTrue); // string filename = Assembly.GetAssembly (typeof (Char)).Location + "/resources/" + dumpfile; // StreamReader sr = new StreamReader (filename); // dump = sr.ReadToEnd (); // sr.Close (); Assert.AreEqual (dump, testDump); }
/// <summary> /// Compare images /// </summary> /// <param name="image_name1"> 1st image</param> /// <param name="image_name2"> 2nd image</param> /// <param name="method"> method</param> /// <returns>Similarity % )</returns> public static double CompareImages(string image_name1, string image_name2, ComparisonMethod method) { var image1 = Image.FromFile(image_name1, true); var image2 = Image.FromFile(image_name2, true); var sim = CompareImages(image1, image2, method); image1.Dispose(); image2.Dispose(); return(sim); }
/// <summary> /// Evaluates the named count against the value using the comparison specified /// </summary> /// <param name="name"></param> /// <param name="value"></param> /// <param name="method"></param> /// <param name="modifier"></param> /// <returns></returns> public static bool EvaluateCountCondition(string name, int value, ComparisonMethod method, ComparisonModifier modifier) { var currentCount = ProfileCountProvider.Instance.GetCount(name); var result = (method.HasFlag(ComparisonMethod.Equal) && currentCount == value) || (method.HasFlag(ComparisonMethod.GreaterThan) && currentCount > value) || (method.HasFlag(ComparisonMethod.GreaterThanOrEqual) && currentCount >= value) || (method.HasFlag(ComparisonMethod.LessThan) && currentCount < value) || (method.HasFlag(ComparisonMethod.LessThanOrEqual) && currentCount <= value); return modifier == ComparisonModifier.Not ? !result : result; }
/// <summary> /// Evaluates the named count against the value using the comparison specified /// </summary> /// <param name="name"></param> /// <param name="value"></param> /// <param name="method"></param> /// <param name="modifier"></param> /// <returns></returns> public static bool EvaluateCountCondition(string name, int value, ComparisonMethod method, ComparisonModifier modifier) { var currentCount = ProfileCountProvider.Instance.GetCount(name); var result = (method.HasFlag(ComparisonMethod.Equal) && currentCount == value) || (method.HasFlag(ComparisonMethod.GreaterThan) && currentCount > value) || (method.HasFlag(ComparisonMethod.GreaterThanOrEqual) && currentCount >= value) || (method.HasFlag(ComparisonMethod.LessThan) && currentCount < value) || (method.HasFlag(ComparisonMethod.LessThanOrEqual) && currentCount <= value); return(modifier == ComparisonModifier.Not ? !result : result); }
public FilterCondition(string filterText, ComparisonMethod comparisonMethod, string targetPropertyName) { if (string.IsNullOrEmpty(targetPropertyName)) { TargetProperty = ComparisonTargetInfo.AllTargetComparison; } else { TargetPropertyId = targetPropertyName; } FilterText = filterText ?? Localisation.UninstallListEditor_NewCondition; ComparisonMethod = comparisonMethod; }
public void Search(string searchStr, ComparisonMethod method, string targetPropertyName = null, bool negate = false) { _targetFilterCondition.ComparisonMethod = method; _targetFilterCondition.InvertResults = negate; _targetFilterCondition.FilterText = searchStr; _targetFilterCondition.TargetPropertyId = targetPropertyName; searchBox1.SearchTextChanged -= searchBox1_SearchTextChanged; searchBox1.Search(searchStr); searchBox1.SearchTextChanged += searchBox1_SearchTextChanged; RefreshEditor(); OnComparisonMethodChanged(this, EventArgs.Empty); }
private void CompareWithDump (ComparisonMethod cm, string dump, bool testTrue) { StringWriter sw = new StringWriter (); int total = 0; for (int i = 0; i <= Char.MaxValue; i++) { if (cm ((char) i) == testTrue) { sw.Write (i.ToString ("x")); sw.Write (' '); total++; } } sw.Write ("found " + total + " chars."); // string filename = Assembly.GetAssembly (typeof (Char)).Location + "/resources/" + dumpfile; // StreamReader sr = new StreamReader (filename); // dump = sr.ReadToEnd (); // sr.Close (); AssertEquals (dump, sw.ToString ()); }
private void CompareWithDump(ComparisonMethod cm, string dump, bool testTrue) { StringWriter sw = new StringWriter(); int total = 0; for (int i = 0; i <= Char.MaxValue; i++) { if (cm((char)i) == testTrue) { sw.Write(i.ToString("x")); sw.Write(' '); total++; } } sw.Write("found " + total + " chars."); // string filename = Assembly.GetAssembly (typeof (Char)).Location + "/resources/" + dumpfile; // StreamReader sr = new StreamReader (filename); // dump = sr.ReadToEnd (); // sr.Close (); Assert.AreEqual(dump, sw.ToString()); }
private void LoadItems() { WorkAsync(new WorkAsyncInfo { Message = $"Loading CRM {ComparisonMethod.PluralName.Capitalize()}...", Work = (bw, e) => { if (!Controller.DataManager.UserHasPrivilege(ComparisonMethod.RequiredPrivilege, Controller.DataManager.WhoAmI())) { MessageBox.Show($@"Make sure your user has the '{ComparisonMethod.RequiredPrivilege}' privilege to load the {ComparisonMethod.PluralName}.{Environment.NewLine}Aborting action."); return; } e.Result = ComparisonMethod.GetNames(Controller.DataManager); }, PostWorkCallBack = e => { if (e.Error != null) { Log.LogData(EventType.Exception, ComparisonMethod.LogActionOnLoadItems, e.Error); MessageBox.Show(this, e.Error.Message, @"Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } var values = (string[])e.Result; comboBoxSolutionsAssembliesList.Items.Clear(); Log.LogData(EventType.Event, $"{ComparisonMethod.PluralName.Capitalize()} retrieved"); if (values != null) { comboBoxSolutionsAssembliesList.Items.AddRange(values.Cast <object>().ToArray()); } Log.LogData(EventType.Event, ComparisonMethod.LogActionOnLoadItems); }, ProgressChanged = e => { SetWorkingMessage(e.UserState.ToString()); } }); }
private void Initialize(OperandType operandType, Type type, Type dataType, Int32 length, string xmlPath, string propertyName, string wtName, ComparisonMethod comparisonMethod, object value) { if (propertyName == null) { throw new ApplicationException("Could not initialize SelectionCriterion; property name is null!"); } PropertyInfo property; if (dataType == null) { property = GetProperty(type, propertyName); } else { char[] delimiter = { '.' }; string[] xmlProperty = propertyName.Split(delimiter); property = GetProperty(type, xmlProperty[0]); } m_OriginalPropertyName = propertyName; m_WorkTypeName = wtName; Initialize(operandType, type, dataType, length, xmlPath, property, comparisonMethod, value, false, Expression.None); }
public static string ComparisonTextForParameters(DataObjectBroker dob, ComparisonMethod comparisonMethod, ref object value, int counter) { return(dob.ConnectionInfo.ComparisonTextForParameters(comparisonMethod, ref value, counter)); }
public Pair(TLeft left, TRight right, ComparisonMethod comparison) { Left = left; Right = right; Comparison = comparison; }
private static BinaryExpression GetBinaryExpression(ComparisonMethod comparisonMethod, MemberExpression memberExpression, ConstantExpression constantExpression) { switch (comparisonMethod) { case ComparisonMethod.Equal: return(Expression.Equal(memberExpression, constantExpression)); case ComparisonMethod.LessThan: return(Expression.LessThan(memberExpression, constantExpression)); case ComparisonMethod.GreaterThan: return(Expression.GreaterThan(memberExpression, constantExpression)); case ComparisonMethod.NotEqual: return(Expression.NotEqual(memberExpression, constantExpression)); case ComparisonMethod.GreaterThanEqual: return(Expression.GreaterThanOrEqual(memberExpression, constantExpression)); case ComparisonMethod.LessThanEqual: return(Expression.LessThanOrEqual(memberExpression, constantExpression)); case ComparisonMethod.IsNullOrEmpty: MethodInfo method = typeof(DynamicQueryExtensions).GetMethod(nameof(DynamicQueryIsNullOrEmpty), BindingFlags.NonPublic | BindingFlags.Static); return(Expression.MakeBinary(ExpressionType.Equal, memberExpression, constantExpression, false, method)); case ComparisonMethod.IsNotNullOrEmpty: MethodInfo method0 = typeof(DynamicQueryExtensions).GetMethod(nameof(DynamicQueryIsNotNullOrEmpty), BindingFlags.NonPublic | BindingFlags.Static); return(Expression.MakeBinary(ExpressionType.Equal, memberExpression, constantExpression, false, method0)); case ComparisonMethod.Contains: MethodInfo method1 = typeof(DynamicQueryExtensions).GetMethod(nameof(DynamicQueryContains), BindingFlags.NonPublic | BindingFlags.Static); return(Expression.MakeBinary(ExpressionType.Equal, memberExpression, constantExpression, false, method1)); case ComparisonMethod.DoesNotContain: MethodInfo method2 = typeof(DynamicQueryExtensions).GetMethod(nameof(DynamicQueryDoesNotContain), BindingFlags.NonPublic | BindingFlags.Static); return(Expression.MakeBinary(ExpressionType.Equal, memberExpression, constantExpression, false, method2)); case ComparisonMethod.StartsWith: MethodInfo method3 = typeof(DynamicQueryExtensions).GetMethod(nameof(DynamicQueryStartsWith), BindingFlags.NonPublic | BindingFlags.Static); return(Expression.MakeBinary(ExpressionType.Equal, memberExpression, constantExpression, false, method3)); case ComparisonMethod.DoesNotStartWith: MethodInfo method4 = typeof(DynamicQueryExtensions).GetMethod(nameof(DynamicQueryDoesNotStartWith), BindingFlags.NonPublic | BindingFlags.Static); return(Expression.MakeBinary(ExpressionType.Equal, memberExpression, constantExpression, false, method4)); case ComparisonMethod.EndsWith: MethodInfo method5 = typeof(DynamicQueryExtensions).GetMethod(nameof(DynamicQueryEndsWith), BindingFlags.NonPublic | BindingFlags.Static); return(Expression.MakeBinary(ExpressionType.Equal, memberExpression, constantExpression, false, method5)); case ComparisonMethod.DoesNotEndWith: MethodInfo method6 = typeof(DynamicQueryExtensions).GetMethod(nameof(DynamicQueryDoesNotEndWith), BindingFlags.NonPublic | BindingFlags.Static); return(Expression.MakeBinary(ExpressionType.Equal, memberExpression, constantExpression, false, method6)); case ComparisonMethod.Like: MethodInfo method7 = typeof(DynamicQueryExtensions).GetMethod(nameof(DynamicQueryLike), BindingFlags.NonPublic | BindingFlags.Static); return(Expression.MakeBinary(ExpressionType.Equal, memberExpression, constantExpression, false, method7)); case ComparisonMethod.NotLike: MethodInfo method8 = typeof(DynamicQueryExtensions).GetMethod(nameof(DynamicQueryNotLike), BindingFlags.NonPublic | BindingFlags.Static); return(Expression.MakeBinary(ExpressionType.Equal, memberExpression, constantExpression, false, method8)); default: return(null); } }
/// <summary> /// Comparisons the text. /// </summary> /// <param name="method">The method.</param> /// <param name="value">The value.</param> /// <returns></returns> //private string ComparisonText(ComparisonMethod method, object value) public static string ComparisonText(DataObjectBroker dob, ComparisonMethod method, object value, Type type) { return(dob.ConnectionInfo.ComparisonText(method, GetValueString(dob, value), type)); }
public SelectionCriterion(OperandType operandType, Type type, Type dataType, Int32 length, string xmlPath, string propertyName, string workTypeName, ComparisonMethod comparisonMethod, object value) { Initialize(operandType, type, dataType, length, xmlPath, propertyName, workTypeName, comparisonMethod, value); }
public SelectionCriterion(OperandType operandType, Type type, Type dataType, Int32 length, string xmlPath, PropertyInfo propertyInstance, ComparisonMethod comparisonMethod, object value) { Initialize(operandType, type, dataType, length, xmlPath, propertyInstance, comparisonMethod, value, false, Expression.None); }
/// <summary> /// Calculates the ΔE of this color compared to another color, using the specified comparison method. /// This value represents the perceptual difference between the two colors. /// </summary> /// <param name="other">The color to compare to this color</param> /// <param name="method"> /// The algorith to use for the comparison. /// There is an efficiency/accuracy trade-off between the different methods. /// </param> /// <returns> /// ΔE value representing the perceived difference between this color and the comparison color. /// </returns> public double Compare(ColorSpace other, ComparisonMethod method = ComparisonMethod.Cie2000) { return(Compare(this, other, method)); }
/// <summary> /// Adds single criterion to the filter expression. /// </summary> /// <param name="type">The type.</param> /// <param name="combineInstruction">The combine instruction.</param> /// <param name="propertyName">Name of the property.</param> /// <param name="compareMethod">The compare method.</param> /// <param name="value">The value.</param> /// public FilterCriteria AddFilter(Type type, OperandType combineInstruction, string propertyName, ComparisonMethod compareMethod, object value) { return(AddXmlFilter(type, null, 0, string.Empty, combineInstruction, propertyName, compareMethod, value)); }
/// <summary> /// Sorts an array using specified comparison method for comparing keys in reverse order. /// </summary> /// <param name="ctx">Current runtime context.</param> /// <param name="array">The array to be sorted.</param> /// <param name="comparisonMethod">The method to be used for comparison of keys.</param> /// <remarks>Resets <paramref name="array"/>'s intrinsic enumerator.</remarks> /// <returns>True on success, False on failure.</returns> public static bool krsort(Context ctx, [In, Out] PhpArray array, ComparisonMethod comparisonMethod = ComparisonMethod.Regular) { if (array == null) { //PhpException.ReferenceNull("array"); //return false; throw new ArgumentNullException(); } array.Sort(GetComparer(ctx, comparisonMethod, SortingOrder.Descending, true)); array.RestartIntrinsicEnumerator(); return true; }
/// <summary> /// Gets an instance of PHP comparer parametrized by specified method, order, and compared item type. /// </summary> /// <param name="method">The <see cref="ComparisonMethod"/>.</param> /// <param name="order">The <see cref="SortingOrder"/>.</param> /// <param name="keyComparer">Whether to compare keys (<B>false</B> for value comparer).</param> /// <returns>A comparer (either a new instance or existing singleton instance).</returns> public static IComparer<KeyValuePair<IntStringKey, object>>/*!*/ GetComparer(ComparisonMethod method, SortingOrder order, bool keyComparer) { if (keyComparer) { switch (method) { case ComparisonMethod.Numeric: return (order == SortingOrder.Descending) ? KeyComparer.ReverseNumeric : KeyComparer.Numeric; case ComparisonMethod.String: return (order == SortingOrder.Descending) ? KeyComparer.ReverseString : KeyComparer.String; case ComparisonMethod.LocaleString: return new KeyComparer(Locale.GetStringComparer(false), order == SortingOrder.Descending); default: return (order == SortingOrder.Descending) ? KeyComparer.Reverse : KeyComparer.Default; } } else { switch (method) { case ComparisonMethod.Numeric: return (order == SortingOrder.Descending) ? ValueComparer.ReverseNumeric : ValueComparer.Numeric; case ComparisonMethod.String: return (order == SortingOrder.Descending) ? ValueComparer.ReverseString : ValueComparer.String; case ComparisonMethod.LocaleString: return new ValueComparer(Locale.GetStringComparer(false), order == SortingOrder.Descending); default: return (order == SortingOrder.Descending) ? ValueComparer.Reverse : ValueComparer.Default; } } }
public Pair(ComparisonMethod comparison) : this(default(TLeft), default(TRight), comparison) { }
public SelectionCriterion(OperandType operandType, Type type, Type dataType, Int32 length, string xmlPath, string propertyName, ComparisonMethod comparisonMethod, object value) : this(operandType, type, dataType, length, xmlPath, propertyName, null, comparisonMethod, value) { }
public static String GenerateDump (ComparisonMethod cm, bool testTrue) { StringWriter sw = new StringWriter (); int total = 0; for (int i = 0; i <= Char.MaxValue; i++) { if (cm ((char) i) == testTrue) { sw.Write (i.ToString ("x")); sw.Write (' '); total++; } } sw.Write ("found " + total + " chars."); return sw.ToString(); }
public WhereCondition(string columnName, ComparisonMethod comparator, object value) { ColumnName = columnName; Comparator = comparator; Value = value; }
public FilterCriteria AddXmlFilter(Type type, Type dataType, Int32 length, string xmlPath, OperandType combineInstruction, string propertyName, ComparisonMethod compareMethod, object value) { return(AddXmlFilter(type, dataType, length, xmlPath, combineInstruction, propertyName, null, compareMethod, value)); }
private void Compare() { if (ComparisonMethod.RequiresItemSelection && SolutionAssemblyPluginStepsName == null) { MessageBox.Show($@"Please select a {ComparisonMethod.Name} first."); return; } string[] diffCrmSourceTarget = null; string[] diffCrmTargetSource = null; StepsCrmSource.Clear(); StepsCrmTarget.Clear(); WorkAsync(new WorkAsyncInfo { Message = $"Comparing the 2 {ComparisonMethod.PluralName.Capitalize()}...", Work = (bw, e) => { SendMessageToStatusBar?.Invoke(this, new StatusBarMessageEventArgs(0, "Fetching steps from source environment...")); StepsCrmSource = ComparisonMethod.GetSteps(SourceService, Settings, SolutionAssemblyPluginStepsName); SendMessageToStatusBar?.Invoke(this, new StatusBarMessageEventArgs(30, "Fetching steps from target environment...")); StepsCrmTarget = ComparisonMethod.GetSteps(TargetService, Settings, SolutionAssemblyPluginStepsName); foreach (var step in StepsCrmTarget) { step.Environment = "Target"; } SendMessageToStatusBar?.Invoke(this, new StatusBarMessageEventArgs(60, "Comparing steps...")); Comparer.Compare(StepsCrmSource, StepsCrmTarget); SendMessageToStatusBar?.Invoke(this, new StatusBarMessageEventArgs(90, "Finding Differences...")); diffCrmSourceTarget = StepsCrmSource.Select(x => x.StepName).Except(StepsCrmTarget.Select(x => x.StepName)).ToArray(); diffCrmTargetSource = StepsCrmTarget.Select(x => x.StepName).Except(StepsCrmSource.Select(x => x.StepName)).ToArray(); SendMessageToStatusBar?.Invoke(this, new StatusBarMessageEventArgs(100, "Done!")); }, PostWorkCallBack = e => { if (e.Error != null) { Log.LogData(EventType.Exception, ComparisonMethod.LogActionOnCompare, e.Error); MessageBox.Show(this, e.Error.Message, @"Error", MessageBoxButtons.OK, MessageBoxIcon.Error); toolStripButtonExport.Enabled = false; return; } toolStripButtonExport.Enabled = true; if (diffCrmSourceTarget.Length == 0) { listViewSourceTarget.Items.Clear(); labelSourceTargetMatch.Visible = true; } else // there are steps in source but not target { labelSourceTargetMatch.Visible = false; listViewSourceTarget.Visible = true; FillListViewItems(listViewSourceTarget, StepsCrmSource, diffCrmSourceTarget); } if (diffCrmTargetSource.Count() == 0) { listViewTargetSource.Items.Clear(); labelTargetSourceMatch.Visible = true; } else // there are steps in source but not target { labelTargetSourceMatch.Visible = false; listViewTargetSource.Visible = true; FillListViewItems(listViewTargetSource, StepsCrmTarget, diffCrmTargetSource); } Log.LogData(EventType.Event, ComparisonMethod.LogActionOnCompare); }, ProgressChanged = e => { SetWorkingMessage(e.UserState.ToString()); } }); }
public FilterCriteria AddXmlFilter(Type type, Type dataType, Int32 length, string xmlPath, OperandType combineInstruction, string propertyName, string workTypeName, ComparisonMethod compareMethod, object value) { // Create a new SelectionCriterion object. SelectionCriterion selectionCriterion = new SelectionCriterion(combineInstruction, type, dataType, length, xmlPath, propertyName, workTypeName, compareMethod, value); m_Criteria.AddCriteria(selectionCriterion); ValidateCriteria(m_Criteria); return(this); }
/// <summary> /// Removes duplicate values from an array. /// </summary> /// <param name="ctx">Current runtime context.</param> /// <param name="array">The array which duplicate values to remove.</param> /// <param name="sortFlags">Specifies how the values are compared to be identical.</param> /// <returns>A copy of <paramref name="array"/> without duplicated values.</returns> /// <remarks> /// Values are compared using string comparison method (<see cref="ValueComparer.String"/>). /// </remarks> /// <exception cref="PhpException"><paramref name="array"/> is a <B>null</B> reference.</exception> //[return: PhpDeepCopy] public static PhpArray array_unique(Context ctx, PhpArray array, ComparisonMethod sortFlags = ComparisonMethod.String) { if (array == null) { //PhpException.ArgumentNull("array"); //return null; throw new ArgumentNullException(); } IComparer<PhpValue> comparer; switch (sortFlags) { case ComparisonMethod.Regular: comparer = PhpComparer.Default; break; case ComparisonMethod.Numeric: comparer = PhpNumericComparer.Default; break; case ComparisonMethod.String: comparer = new PhpStringComparer(ctx); break; case ComparisonMethod.LocaleString: //comparer = new PhpLocaleStringComparer(ctx); break; default: //PhpException.ArgumentValueNotSupported("sortFlags", (int)sortFlags); //return null; throw new ArgumentException(nameof(sortFlags)); } var result = new PhpArray(array.Count); var/*!*/identitySet = new HashSet<object>(); // get only unique values - first found using (var enumerator = array.GetFastEnumerator()) while (enumerator.MoveNext()) { if (identitySet.Add(enumerator.CurrentValue.GetValue())) { result.Add(enumerator.Current); } } //result.InplaceCopyOnReturn = true; return result; }
/// <summary> /// Compare images /// </summary> /// <param name="image1"> 1st image</param> /// <param name="image2"> 2nd image</param> /// <param name="method"> method</param> /// <returns>Similarity % )</returns> public static double CompareImages(Mat image1, Mat image2, ComparisonMethod method) { double sim = 0; switch (method) { case ComparisonMethod.None: break; case ComparisonMethod.TopColors: var bmp1 = (Image)BitmapConverter.ToBitmap(image1); var bmp2 = (Image)BitmapConverter.ToBitmap(image2); sim = Images.ColorExtract.CompareTop(bmp1, bmp2); bmp1.Dispose(); bmp2.Dispose(); break; case ComparisonMethod.MainColor: bmp1 = (Image)BitmapConverter.ToBitmap(image1); bmp2 = (Image)BitmapConverter.ToBitmap(image2); var main1 = Images.ColorExtract.MainColor(bmp1); var main2 = Images.ColorExtract.MainColor(bmp2); sim = Images.ColorExtract.Compare(main1, main2); bmp1.Dispose(); bmp2.Dispose(); break; case ComparisonMethod.PixelsDifference: sim = ComparePixels(image1, image2); break; case ComparisonMethod.PixelsDifferenceSorted: sim = ComparePixelsSorted(image1, image2); break; case ComparisonMethod.PixelsDistance: sim = ComparePixelsDistance(image1, image2); break; case ComparisonMethod.PixelsDistanceSorted: sim = ComparePixelsDistanceSorted(image1, image2); break; case ComparisonMethod.Feature: double feature; double matchs; Bitmap view; try { sim = CompareFeatures(image1, image2, out feature, out matchs, out view); } catch (System.AccessViolationException e) { Console.Error.WriteLine("Access Error => CompareImages {0} : \n{1}", method, e); } catch (Exception e) { Console.Error.WriteLine("Error => CompareImages {0} : \n{1}", method, e); } break; case ComparisonMethod.RGBHistogramHash: sim = Images.ImageHistogramHash.Compare(image1, image2); break; default: break; } return(sim); }
public static bool KeyReverseSort([PhpRw] PhpArray array, ComparisonMethod comparisonMethod) { if (array == null) { PhpException.ReferenceNull("array"); return false; } array.Sort(GetComparer(comparisonMethod, SortingOrder.Descending, true)); array.RestartIntrinsicEnumerator(); return true; }
public FilterCriteria AddXmlFilter(Type type, Type dataType, string xmlPath, string propertyName, ComparisonMethod compareMethod, object value) { return(AddXmlFilter(type, dataType, 0, xmlPath, OperandType.None, propertyName, compareMethod, value)); }