public void IsInRange(object value, string dtoName, ValidationIssues issues) { if (!HasRange) { return; } RangeResult result = Range.IsInRange(value); if (result != RangeResult.ValueInRange) { string insert = (result == RangeResult.ValueBelowMinimum) ? "below the minimum allowed value" : "above the maximum allowed value"; string message = string.Format("The {0} has {1} which is {2}.", dtoName, ColumnName, insert); issues.Add(ValidationIssue.Code.ValueOutOfRange, message); } }
public RangeResult IsInRange(object value) { DateTime? dateValue = (DateTime?)value; RangeResult result = RangeResult.ValueInRange; DateTime? dateMinimum = (DateTime?)Minimum; if (dateValue < dateMinimum) { result = RangeResult.ValueBelowMinimum; } DateTime?dateMaximum = (DateTime?)Maximum; if (dateValue > dateMaximum) { result = RangeResult.ValueAboveMaximum; } return(result); }
public RangeResult IsInRange(object value) { uint? uintValue = (uint?)value; RangeResult result = RangeResult.ValueInRange; uint? uintMinimum = (uint?)Minimum; if (uintValue < uintMinimum) { result = RangeResult.ValueBelowMinimum; } uint?uintMaximum = (uint?)Maximum; if (uintValue > uintMaximum) { result = RangeResult.ValueAboveMaximum; } return(result); }
public RangeResult IsInRange(object value) { double? doubleValue = (double?)value; RangeResult result = RangeResult.ValueInRange; double? doubleMinimum = (double?)Minimum; if (doubleValue < doubleMinimum) { result = RangeResult.ValueBelowMinimum; } double?doubleMaximum = (double?)Maximum; if (doubleValue > doubleMaximum) { result = RangeResult.ValueAboveMaximum; } return(result); }
private static RangeResult GetRangeBlock(LdapConnection conn, string entryDn, string attrName, int start, int? end, bool extendedDns) { SearchRequest req = new SearchRequest(); req.DistinguishedName = entryDn; req.Scope = SearchScope.Base; req.Filter = "(&(objectClass=*))"; req.Attributes.Add(attrName + ";range=" + start + "-" + (end == null ? "*" : end.ToString())); if (extendedDns) req.Controls.Add(new ExtendedDNControl(ExtendedDNFlag.StandardString)); SearchResponse resp = (SearchResponse)conn.SendRequest(req); if (resp.Entries.Count == 0) return null; SearchResultEntry e = resp.Entries[0]; foreach (string s in e.Attributes.AttributeNames) if (s.StartsWith(attrName, StringComparison.InvariantCultureIgnoreCase)) { RangeResult res = new RangeResult(); DirectoryAttribute attr = e.Attributes[s]; res.Values = (string[])attr.GetValues(typeof(string)); if (s.EndsWith("*")) res.IsFinal = true; int pos = s.IndexOf('='); int hyp = s.IndexOf('-', pos + 1); res.Start = int.Parse(s.Substring(pos + 1, hyp - pos - 1)); if (!res.IsFinal) res.End = int.Parse(s.Substring(hyp + 1)); return res; } return null; }
public RangeResult CalculateParameterRangeResult(double parameterValue) { var result = new RangeResult { Parameter = _parameter, Status = ParameterStatus.Normal, Level = BreachLevel.Safe }; for (var i = 0; i < _map.Length; i++) { if (!IsParameterInRange(_map[i].LowerLimit, _map[i].UpperLimit, parameterValue)) { continue; } result.Status = _map[i].Status; result.Level = _map[i].Level; OnParameterRangeBreach(result); break; } return(result); }
/// <summary> /// Try to parse an IRange<T> from a string. /// Returns RangeResult<T> to avoid throwing an exception. public static RangeResult <T> GetResultFromString <T>(string value) where T : struct { var range = new Range <T>(); /** * This expression is very cumbersome due to its requirement of handling * several formats. Please take note of the lookbehind assertion and its preceeding * word-boundary. The former lets us define a max-value using simple-syntax while * the latter accounts for the min-value (due to the assertion). * Valid formats (not exhaustive): * [123,456] * [123, * [123,456 * 123 * 123,456 * 123, */ var parsedValue = Regex.Match( value + ",", @"(?<startSyntax>[\[\(])?(?<minValue>[^,[(]+?)?(?:[\W])(?<=,)(?<maxValue>[^,\]\)]+)?(?<endSyntax>[\]\)])?"); if (!parsedValue.Success) { return(RangeResult <T> .Error("value does not match expected format.")); } else { var groups = parsedValue.Groups; var parsedMinValue = groups["minValue"].Value; /** * If we using short-range syntax, then we * want to set the max-value if not provided. */ var parsedMaxValue = string.IsNullOrEmpty( groups["maxValue"].Value + groups["startSyntax"].Value + groups["endSyntax"].Value) ? parsedMinValue : groups["maxValue"].Value; var isMinInclusive = (groups["startSyntax"].Value == "[" || string.IsNullOrEmpty(groups["startSyntax"].Value)) ? true : false; var isMaxInclusive = (groups["endSyntax"].Value == "]" || string.IsNullOrEmpty(groups["endSyntax"].Value)) ? true : false; var isMinInfinite = parsedMinValue == "-∞" ? true : false; var isMaxInfinite = parsedMaxValue == "+∞" ? true : false; if (string.IsNullOrWhiteSpace(parsedMinValue) && string.IsNullOrWhiteSpace(parsedMaxValue)) { return(RangeResult <T> .Error("value cannot be open-ended for both min and max-values.")); } if (isMinInclusive && isMinInfinite) { return(RangeResult <T> .Error("value cannot have inclusive infinite lower-bound.")); } if (isMaxInclusive && isMaxInfinite) { return(RangeResult <T> .Error("value cannot have inclusive infinite upper-bound.")); } T?minValue = default(T?); T?maxValue = default(T?); if (!string.IsNullOrWhiteSpace(parsedMinValue) && !isMinInfinite) { try { minValue = SmartConverter.Convert <T>( parsedMinValue, isMinInclusive ? ConvertingKind.MinInclusive : ConvertingKind.MinExclusive ); } catch (Exception) { return(RangeResult <T> .Error( string.Format("parsed minimum value `{0}` does not match expected type of `{1}`.", groups["minValue"].Value, typeof(T).Name))); } } if (!string.IsNullOrWhiteSpace(parsedMaxValue) && !isMaxInfinite) { try { maxValue = SmartConverter.Convert <T>(parsedMaxValue, isMaxInclusive ? ConvertingKind.MaxInclusive : ConvertingKind.MaxExclusive ); } catch (Exception) { return(RangeResult <T> .Error( string.Format("parsed maximum value `{0}` does not match expected type of `{1}`.", groups["maxValue"].Value, typeof(T).Name))); } } range.MinValue = minValue; range.MaxValue = maxValue; range.IsMinInclusive = isMinInclusive; range.IsMaxInclusive = isMaxInclusive; } if (range.MinValue.HasValue && range.MaxValue.HasValue) { var anyInclusiveRanges = range.IsMinInclusive || range.IsMaxInclusive; var compareResult = Comparer <T> .Default.Compare(range.MinValue.Value, range.MaxValue.Value); if (anyInclusiveRanges && compareResult > 0) { return(RangeResult <T> .Error( "Minimum value of range must be less than or equal to maximum value.")); } if (!anyInclusiveRanges && compareResult >= 0) { return(RangeResult <T> .Error( "Minimum value of range must be less than maximum value when range is non-inclusive.")); } } return(RangeResult <T> .Success(range)); }
private void OnParameterRangeBreach(RangeResult result) { _parameterRangeBreached?.Invoke(_parameter, result.Status, result.Level); }
public Frame MakeFrame() { Frame result = new Frame(); float deltaFrameTime = Time.time - lastFrameTime; lastFrameTime = Time.time; seq++; Vector3 thisPosition = transform.position; Vector3 thisRotation = transform.eulerAngles; result.posX = thisPosition.x; result.posY = thisPosition.y; result.posZ = thisPosition.z; result.rotX = thisRotation.x; result.rotY = thisRotation.y; result.rotZ = thisRotation.z; result.accX = thisPosition.x - lastPosition.x; result.accY = thisPosition.y - lastPosition.y; result.accZ = thisPosition.z - lastPosition.z; result.gyrX = thisRotation.x - lastRotation.x; result.gyrY = thisRotation.y - lastRotation.y; result.gyrZ = thisRotation.z - lastRotation.z; result.angle_increment = readingInterval; result.angle_min = Mathf.Min(readingRange.x, readingRange.y) * Mathf.Deg2Rad; result.angle_max = Mathf.Max(readingRange.x, readingRange.y) * Mathf.Deg2Rad; result.range_min = min_range; result.range_max = max_range; RangeResult rangeResult = GenerateRanges(); result.ranges = (rangeResult == null) ? new float[0] : rangeResult.ranges; result.intensities = (rangeResult == null) ? new float[0] : rangeResult.intensities; result.seq = seq; result.timestamp = Time.time; result.img = GenerateImage(); result.imgfmt = (result.img == null) ? "none" : "png"; result.frameid = "unity"; return(result); RangeResult GenerateRanges() { if (readingInterval <= 0.0001f) { if (!errorAlreadyShown) { errorAlreadyShown = true; Debug.LogError("Cannot record with a reading interval of less than 0.0001 degrees as this will take forever to compute."); } return(null); } List <Vector3> baseVectors = new List <Vector3>(); for (float deg = Mathf.Min(readingRange.x, readingRange.y); deg <= Mathf.Max(readingRange.x, readingRange.y); deg += readingInterval) { baseVectors.Add(new Vector3(Mathf.Cos(Mathf.Deg2Rad * deg), 0f, Mathf.Sin(Mathf.Deg2Rad * deg))); } List <Vector3> rotatedVectors = new List <Vector3>(); foreach (Vector3 baseVector in baseVectors) { float alpha = thisRotation.x * Mathf.Deg2Rad; float beta = thisRotation.y * Mathf.Deg2Rad; float gamma = thisRotation.z * Mathf.Deg2Rad; float cosa = Mathf.Cos(alpha); float sina = Mathf.Sin(alpha); float cosb = Mathf.Cos(beta); float sinb = Mathf.Sin(beta); float cosc = Mathf.Cos(gamma); float sinc = Mathf.Sin(gamma); float axx = cosa * cosb; float axy = (cosa * sinb * sinc) - (sina * cosc); float axz = (cosa * sinb * cosc) + (sina * sinc); float ayx = sina * cosb; float ayy = (sina * sinb * sinc) + (cosa * cosc); float ayz = (sina * sinb * cosc) - (cosa * sinc); float azx = -sinb; float azy = cosb * sinc; float azz = cosb * cosc; float mx = (baseVector.x * axx) + (baseVector.y * axy) + (baseVector.z * axz); float my = (baseVector.x * ayx) + (baseVector.y * ayy) + (baseVector.z * ayz); float mz = (baseVector.x * azx) + (baseVector.y * azy) + (baseVector.z * azz); rotatedVectors.Add(new Vector3(mx, my, mz)); } List <float> rangeReadings = new List <float>(); List <float> intensityReadings = new List <float>(); foreach (Vector3 direction in rotatedVectors) { Ray ray = new Ray(transform.position, direction); RaycastHit[] hits = Physics.RaycastAll(ray, max_range); float distance = max_range; float intensity = 0f; RaycastHit closestHit = new RaycastHit(); float minDistance = float.MaxValue; foreach (RaycastHit hit in hits) { if (minDistance > hit.distance) { minDistance = hit.distance; closestHit = hit; } if (showRays) { Debug.DrawLine(transform.position, hit.point, Color.green); } if (hit.distance < min_range) { continue; } distance = hit.distance; switch (intensityMetric) { case IntensityMetric.None: intensity = 0f; break; case IntensityMetric.Success: intensity = 1f; break; case IntensityMetric.Noise: intensity = 1f - (distance / max_range); break; } break; } rangeReadings.Add(distance); intensityReadings.Add(intensity); } return(new RangeResult() { intensities = intensityReadings.ToArray(), ranges = rangeReadings.ToArray() }); } byte[] GenerateImage() { if (camera == null) { camera = GetComponent <Camera>(); } if (camera == null) { return(null); } byte[] ba = new byte[0]; if (camera.targetTexture == null) { camera.targetTexture = new RenderTexture(Screen.width, Screen.height, 24); } RenderTexture active = RenderTexture.active; RenderTexture.active = camera.targetTexture; camera.Render(); Texture2D texture = new Texture2D(camera.targetTexture.width, camera.targetTexture.height, TextureFormat.RGB24, false); texture.ReadPixels(new Rect(0, 0, camera.targetTexture.width, camera.targetTexture.height), 0, 0); texture.Apply(); RenderTexture.active = active; ba = texture.EncodeToPNG(); Destroy(texture); return(ba); } }
public RegisterCompareResult(int dummy = 0) { RangeResult = RangeResult.NotAvailable; EqualityResult = EqualityResult.Incompatible; }