public IAmRequest(ObjectId iAmDeviceIdentifier, uint maxAPDULengthAccepted, Segmentation segmentationSupported, uint vendorID) { this.IAmDeviceIdentifier = iAmDeviceIdentifier; this.MaxAPDULengthAccepted = maxAPDULengthAccepted; this.SegmentationSupported = segmentationSupported; this.VendorID = vendorID; }
/// <summary> /// Constructs a new DeviceTableEntry instance /// </summary> /// <param name="instance">The device instance</param> /// <param name="address">The address of the device</param> /// <param name="maxAppgramLength">The maximum appgram length that this device can receive</param> /// <param name="segmentationSupport">The segmentation support of the device</param> /// <param name="vendorId">The vendor id of the device</param> public DeviceTableEntry(uint instance, Address address, uint maxAppgramLength, Segmentation segmentationSupport, ushort vendorId) { this.Instance = instance; this.Address = address; this.MaxAppgramLength = maxAppgramLength; this.SegmentationSupport = segmentationSupport; this.VendorId = vendorId; }
/// <summary> /// Create Countly event with provided values /// </summary> /// <param name="Key">Key attribute, must be non-empty</param> /// <param name="Count">Count parameter, must me positive number</param> /// <param name="Sum">Sum parameter, can be null</param> /// <param name="Segmentation">Segmentation parameter</param> public CountlyEvent(string Key, int Count, double? Sum, Segmentation Segmentation) { if (String.IsNullOrEmpty(Key)) { throw new ArgumentException("Event Key must be non-empty string"); } if (Count <= 0) { throw new ArgumentException("Event Count must be positive number"); } this.Key = Key; this.Count = Count; this.Sum = Sum; this.Segmentation = Segmentation; }
public Segmentation GetSegmentBuffer(BacnetMaxSegments max_segments) { if (max_segments == BacnetMaxSegments.MAX_SEG0) return null; Segmentation ret = new Segmentation(); ret.buffer = GetEncodeBuffer(m_client.HeaderLength); ret.max_segments = GetSegmentsCount(max_segments); ret.window_size = m_proposed_window_size; return ret; }
public void ReadPropertyMultipleResponse(BacnetAddress adr, byte invoke_id, Segmentation segmentation, IList<BacnetReadAccessResult> values) { SendComplexAck(adr, invoke_id, segmentation, BacnetConfirmedServices.SERVICE_CONFIRMED_READ_PROP_MULTIPLE, (b) => { Services.EncodeReadPropertyMultipleAcknowledge(b, values); }); }
internal static async Task RecordMenuItemTelemetryAsync(string?openPath, MorphicMenuItem.MenuType parentMenuType, MorphicMenuItemTelemetryType?telemetryType, string?telemetryCategory) { string?eventSource = null; switch (parentMenuType) { case MenuType.mainMenu: eventSource = "iconMenu"; break; case MenuType.contextMenu: eventSource = "contextMenu"; break; } switch (telemetryType) { case MorphicMenuItemTelemetryType.Settings: { var segmentation = new Segmentation(); var settingCategoryName = telemetryCategory; if (settingCategoryName is not null) { segmentation.Add("category", settingCategoryName); } // segmentation.Add("eventSource", eventSource); // await App.Current.Countly_RecordEventAsync("systemSettings", 1, segmentation); //await App.Current.Countly_RecordEventAsync("systemSettings" + settingCategoryName); } break; case MorphicMenuItemTelemetryType.LearnMore: { var segmentation = new Segmentation(); var settingCategoryName = telemetryCategory; if (settingCategoryName is not null) { segmentation.Add("category", settingCategoryName); } // segmentation.Add("eventSource", eventSource); // await App.Current.Countly_RecordEventAsync("learnMore", 1, segmentation); } break; case MorphicMenuItemTelemetryType.QuickDemoVideo: { var segmentation = new Segmentation(); var settingCategoryName = telemetryCategory; if (settingCategoryName is not null) { segmentation.Add("category", settingCategoryName); } // segmentation.Add("eventSource", eventSource); // await App.Current.Countly_RecordEventAsync("quickDemoVideo", 1, segmentation); } break; default: // handle menu "open settings" items // NOTE: we may want to create a separate "telemetry type" and embed it in the menu xaml itself (so that we don't have to compare against open paths here) { string?settingCategoryName = null; switch (openPath) { case "ms-settings:colors": settingCategoryName = "darkMode"; break; case "ms-settings:display": settingCategoryName = "textSize"; break; case "ms-settings:easeofaccess": case "ms-settings:easeofaccess-display": settingCategoryName = "allAccessibility"; break; case "ms-settings:easeofaccess-colorfilter": settingCategoryName = "colorFilter"; break; case "ms-settings:easeofaccess-cursorandpointersize": case "ms-settings:easeofaccess-MousePointer": settingCategoryName = "pointerSize"; break; case "ms-settings:easeofaccess-highcontrast": settingCategoryName = "highContrast"; break; case "ms-settings:easeofaccess-keyboard": settingCategoryName = "keyboard"; break; case "ms-settings:easeofaccess-magnifier": settingCategoryName = "magnifier"; break; case "ms-settings:mousetouchpad": settingCategoryName = "mouse"; break; case "ms-settings:nightlight": settingCategoryName = "nightMode"; break; case "ms-settings:regionlanguage": settingCategoryName = "language"; break; case "ms-settings:speech": settingCategoryName = "readAloud"; break; case null: // unknown (i.e. no data) break; default: Debug.Assert(false, "Unknown menu item (i.e. no telemetry)"); break; } if (settingCategoryName is not null) { var segmentation = new Segmentation(); segmentation.Add("category", settingCategoryName); segmentation.Add("eventSource", eventSource); // await App.Current.Countly_RecordEventAsync("systemSettings", 1, segmentation); //await App.Current.Countly_RecordEventAsync("systemSettings" + settingCategoryName); } } break; } }
public static SCalcRegionTask calcRegions(CancellationToken cToken, SCalcRegionTask data) { Rectangle roiRect = data.roiRect; // Flatten RGA to 1 byte pixel buffer with 1 indicating segment // if(!FlattenImage(cToken, roiRect, data.pixelData)) { // return data; // } // ******************************************************** // DETECT REGIONS // ******************************************************** // Allocate stuff List <Point> points = new List <Point>(128 * 128); SCalcRegionBuffers buffers = new SCalcRegionBuffers(); buffers.Prepare(256 * 256); bool isEDM = true; // Get regions at tags bool propertiesSet = false; int test = 0; foreach (Tag tag in data.tags) { Point posROI = new Point((int)tag.Pos.X - roiRect.Location.X, (int)tag.Pos.Y - roiRect.Location.Y); int index = posROI.Y * roiRect.Size.Width + posROI.X; uint val = data.pixelData[index]; if (val == 0x00FFFFFF) { points.Clear(); QuickFill <uint> .FloodFill(posROI, data.pixelData, roiRect.Size, val, 0, points); if (!propertiesSet) { propertiesSet = true; // Get bounds Rectangle regionBounds; Region.Transform(points, Point.Empty, out regionBounds); if (cToken.IsCancellationRequested) { return(data); } // Prepare buffers int regionsize = regionBounds.Width * regionBounds.Height; buffers.Prepare(regionsize); // Load binary map Region.loadBinaryMap(points, new Point(-regionBounds.X, -regionBounds.Y), buffers.EDMMap, regionBounds.Width); if (cToken.IsCancellationRequested) { return(data); } // Create EDM EDM.createEDM(buffers.EDMMap, regionBounds.Width, regionBounds.Height); int[] globalMinMax; Segmentation.FindGlobalMinMax(buffers.EDMMap, regionBounds.Width, regionBounds.Height, out globalMinMax); test = globalMinMax[1]; } } if (cToken.IsCancellationRequested) { return(data); } } // Create regions from segmentation map int height = roiRect.Size.Height; int width = roiRect.Size.Width; int count = height * width; float invWidth = 1.0f / (float)width; for (int index = 0; index < count; index++) { uint val = data.pixelData[index]; if (val == 0x00FFFFFF) { int x2 = index % width - 1; int y2 = (int)((float)(index - x2) * invWidth); Point pos = new Point(x2, y2); points.Clear(); // QuickFill<uint>.FloodFill(pos, data.pixelData, roiRect.Size, val, 0, points); QuickFillUint.FloodFill(pos, data.pixelData, roiRect.Size, val, 0, points); if (cToken.IsCancellationRequested) { return(data); } // Transform region points to image space Rectangle regionBounds; Region.Transform(points, roiRect.Location, out regionBounds); // Prepare buffers int regionsize = regionBounds.Width * regionBounds.Height; buffers.Prepare(regionsize); // Load binary map Region.loadBinaryMap(points, new Point(-regionBounds.X, -regionBounds.Y), buffers.EDMMap, regionBounds.Width); if (cToken.IsCancellationRequested) { return(data); } // Create EDM EDM.createEDM(buffers.EDMMap, regionBounds.Width, regionBounds.Height); if (cToken.IsCancellationRequested) { return(data); } // Debug render EDM if (data.bDebugDrawEDM) { DebugDragEDM(regionBounds, buffers, data); } if (cToken.IsCancellationRequested) { return(data); } // Find maxima int minSize = Math.Min(regionBounds.Width, regionBounds.Height); double tolerance = 20; // double findMaxThreshold = 4*EDM.ONE; double findMaxThreshold = (float)test * 0.5f; Segmentation.MaxPoint[] maxPoints; int[] globalMinMax; Segmentation.FindGlobalMinMax(buffers.EDMMap, regionBounds.Width, regionBounds.Height, out globalMinMax); Segmentation.findMaxima(buffers.EDMMap, regionBounds.Width, regionBounds.Height, tolerance, findMaxThreshold, buffers.maxMap, isEDM, globalMinMax, out maxPoints); // Count max points int iMaxPointCount = 0; foreach (Segmentation.MaxPoint maxPoint in maxPoints) { int ri = maxPoint.y * regionBounds.Width + maxPoint.x; int iVal = buffers.maxMap[ri]; if ((iVal & Segmentation.MAX_POINT) > 0) { iMaxPointCount++; } } // Skip all regions with no max if (iMaxPointCount == 0) { continue; } // Debug Render maxima if (data.bDebugDrawEDM) { DebugDragMaxima(regionBounds, buffers, data, maxPoints, iMaxPointCount); } if (cToken.IsCancellationRequested) { return(data); } if (iMaxPointCount == 1) { Region region = new Region(points, regionBounds); data.regions.Add(region); data.SendRegionAdded(region); } else { // TODO: could watershed write region map in different colors (so we dont have to quickfill) double watershedThreshold = 1; Segmentation.performWatershed(buffers.EDMMap, regionBounds.Width, regionBounds.Height, watershedThreshold, buffers.maxMap, isEDM, buffers.regionMap, maxPoints, globalMinMax); // Debug render region map if (data.bDebugDrawRegions) { int offsetX = regionBounds.X - roiRect.X; int offsetY = regionBounds.Y - roiRect.Y; int ri = 0; for (int ry = 0; ry < regionBounds.Height; ry++) { for (int rx = 0; rx < regionBounds.Width; rx++) { int iVal = buffers.regionMap[ri]; data.debugTexture.SetPixel(rx + offsetX, ry + offsetY, iVal, 0, 0, 1); ri++; } } } if (cToken.IsCancellationRequested) { return(data); } for (int ry = 0; ry < regionBounds.Height; ry++) { for (int rx = 0; rx < regionBounds.Width; rx++) { int ri = (regionBounds.Width * ry) + rx; uint iVal = (uint)(buffers.regionMap[ri] & 0xFF); if (iVal == 255) { points.Clear(); // QuickFill<byte>.FloodFill(new Point(rx, ry), buffers.regionMap, regionBounds.Size, (byte)iVal, 0, points); QuickFillByte.FloodFill(new Point(rx, ry), buffers.regionMap, regionBounds.Size, (byte)iVal, 0, points); if (cToken.IsCancellationRequested) { return(data); } Rectangle bounds; Region.Transform(points, regionBounds.Location, out bounds); Region region = new Region(points, bounds); data.regions.Add(region); data.SendRegionAdded(region); } } } } if (cToken.IsCancellationRequested) { return(data); } } } return(data); }
private void Update() { Time.timeScale = 0; currentTimeBetweenAnnotations += Time.deltaTime; //Add current delta time -> Could be higher than capture if (exportFinished && currentTimeBetweenAnnotations >= timeBetweenAnnotations) { if (segmentationDone) { Segmentation.Camera.Render(); segmentationDone = false; } //Check if segmentation camera is still rendering if (Segmentation.Camera.FinishedRender) { segmentationDone = true; } else { return; } //Segmentation rendered all objects visible EditableObjects = new HashSet <AnnotationObject>(RenderedObjects); //COPY //Count pixels or optional export Segmentation.Run(); //Annotations for each profile foreach (AnnotationProfile profile in profiles) { OutputCamera = profile.Camera; Logger.Log("[CONDITIONING]"); if (profile.Conditioning()) { Logger.Log("[PRE-ANNOTATE]"); profile.PreAnnotate(); Logger.Log("[ANNOTATE]"); OutputCamera.Render(); Logger.Log("[VALIDATE]"); bool validated = profile.Validation(); Logger.Log("[POST-ANNOTATE]"); profile.PostAnnotate(); if (validated) { //Logger.Log("POST-CONDITIONING"); StartCoroutine(AwaitExport()); exportFinished = false; currentTimeBetweenAnnotations = 0.0f; } } } } EditableObjects = null; Time.timeScale = timeScale; }
/// <summary> /// Records a custom event with the specified segmentation values, count and a sum /// </summary> /// <param name="Key">Name of the custom event, required, must not be the empty string</param> /// <param name="Count">Count to associate with the event, should be more than zero</param> /// <param name="Sum">Sum to associate with the event</param> /// /// <param name="Sum">Event duration</param> /// <param name="Segmentation">Segmentation object to associate with the event, can be null</param> /// <returns>True if event is uploaded successfully, False - queued for delayed upload</returns> public static Task <bool> RecordEvent(string Key, int Count, double?Sum, double?Duration, Segmentation Segmentation) { if (!Countly.Instance.IsInitialized()) { throw new InvalidOperationException("SDK must initialized before calling 'RecordEvent'"); } return(Countly.Instance.RecordEventInternal(Key, Count, Sum, Duration, Segmentation)); }
private double ComputeNorm(Segmentation s) { double norm = 0; foreach (int str in s.Clusters.Keys) norm += similarity(s.Clusters[str].Count, s.Clusters[str].Count, s.Clusters[str].Count); return norm; }
private EncodeBuffer EncodeSegmentHeader(BacnetAddress adr, byte invoke_id, Segmentation segmentation, BacnetConfirmedServices service, bool more_follows) { EncodeBuffer buffer; bool is_segmented = false; if (segmentation == null) buffer = GetEncodeBuffer(m_client.HeaderLength); else { buffer = segmentation.buffer; is_segmented = segmentation.sequence_number > 0 | more_follows; } buffer.Reset(m_client.HeaderLength); //encode NPDU.Encode(buffer, BacnetNpduControls.PriorityNormalMessage, adr.RoutedSource, null, DEFAULT_HOP_COUNT, BacnetNetworkMessageTypes.NETWORK_MESSAGE_WHO_IS_ROUTER_TO_NETWORK, 0); //set segments limits buffer.max_offset = buffer.offset + GetMaxApdu(); int apdu_header = APDU.EncodeComplexAck(buffer, BacnetPduTypes.PDU_TYPE_COMPLEX_ACK | (is_segmented ? BacnetPduTypes.SEGMENTED_MESSAGE | BacnetPduTypes.SERVER : 0) | (more_follows ? BacnetPduTypes.MORE_FOLLOWS : 0), service, invoke_id, segmentation != null ? segmentation.sequence_number : (byte)0, segmentation != null ? segmentation.window_size : (byte)0); buffer.min_limit = (GetMaxApdu() - apdu_header) * (segmentation != null ? segmentation.sequence_number : 0); return buffer; }
public void MultipleModelMethodfromStringTest(string val, MultipleModelMethod res) { Assert.AreEqual(res, Segmentation.MultipleModelMethodfromString(val)); }
public override double Process(Segmentation s1, Segmentation s2) { if (s1 == null || s2 == null) return 0; if (s1 == s2) return 1; double result = 0; //En cls van a estar los subconjuntos comunes en las dos particiones concatenados los nombres de los clusters por un &, ademas se guarda la cantidad de elementos del subconjunto. Dictionary<string, long> cls = new Dictionary<string, long>(); for (int i = 0; i < s1.Labels.Length; i++) { if (cls.ContainsKey(s1.Labels[i] + "&" + s2.Labels[i])) cls[s1.Labels[i] + "&" + s2.Labels[i]] += 1; else cls.Add(s1.Labels[i] + "&" + s2.Labels[i], 1); } string[] aux; //Tamanno de los cluster que contienen al subconjunto en P1 y P2 respectivamente. int c1 = 0, c2 = 0; //Calcular para cada subconjunto el valor de similaridad asociado. foreach (string str in cls.Keys) { aux = str.Split('&'); c1 = s1.Clusters[int.Parse(aux[0])].Count; c2 = s2.Clusters[int.Parse(aux[1])].Count; result += similarity(cls[str], c1, c2); } return result / Math.Sqrt(ComputeNorm(s1) * ComputeNorm(s2)); }
public AcknowledgementService send(Address address, OctetString linkService, uint maxApduLengthAccepted, Segmentation segmentationSupported, ConfirmedRequestService serviceRequest) { throw new NotImplementedException(); }
protected ConsoleHelper(PlayerStats playerStats) { this.playerStats = playerStats; segmentation = Segmentation.Instance(); }
/// <summary> /// Records a custom event with the specified values /// </summary> /// <param name="Key">Name of the custom event, required, must not be the empty string</param> /// <param name="Count">Count to associate with the event, should be more than zero</param> /// <param name="Sum">Sum to associate with the event</param> /// <param name="Segmentation">Segmentation object to associate with the event, can be null</param> /// <returns>True if event is uploaded successfully, False - queued for delayed upload</returns> protected async Task <bool> RecordEventInternal(string Key, int Count, double?Sum, double?Duration, Segmentation Segmentation) { if (!Countly.Instance.IsServerURLCorrect(ServerUrl)) { return(false); } if (!IsConsentGiven(ConsentFeatures.Events)) { return(true); } CountlyEvent cEvent = new CountlyEvent(Key, Count, Sum, Duration, Segmentation); bool saveSuccess = false; lock (sync) { Events.Add(cEvent); saveSuccess = SaveEvents(); } if (saveSuccess) { saveSuccess = await Upload(); } return(saveSuccess); }
public void ReadRangeResponse(BacnetAddress adr, byte invoke_id, Segmentation segmentation, BacnetObjectId object_id, BacnetPropertyReference property, BacnetResultFlags status, uint item_count, byte[] application_data, BacnetReadRangeRequestTypes request_type, uint first_sequence_no) { SendComplexAck(adr, invoke_id, segmentation, BacnetConfirmedServices.SERVICE_CONFIRMED_READ_RANGE, (b) => { Services.EncodeReadRangeAcknowledge(b, object_id, property.propertyIdentifier, property.propertyArrayIndex, BacnetBitString.ConvertFromInt((uint)status), item_count, application_data, request_type, first_sequence_no); }); }
public override double Process(Segmentation s1, Segmentation s2) { double ents = Entropy(s1) * Entropy(s2); if (ents != 0) return MI(s1, s2) / Math.Sqrt(ents); else return 1; }
public void WriteFileResponse(BacnetAddress adr, byte invoke_id, Segmentation segmentation, int position) { SendComplexAck(adr, invoke_id, segmentation, BacnetConfirmedServices.SERVICE_CONFIRMED_ATOMIC_WRITE_FILE, (b) => { Services.EncodeAtomicWriteFileAcknowledge(b, true, position); }); }
//Rand es (n00 + n11) / (n(n-1)/2), pero n00+n01+n10+n11 = n(n-1)/2. Por tanto n00+n11 = n(n-1)/2 - ((n11+n10) + (n11+n01) -2*n11). //Hay una forma muy facil de calcular (n11+n10) + (n11+n01) y n11 se calcula en O(n). public override double Process(Segmentation s1, Segmentation s2) { double rand = 0; double t = 0; double n11_n01 = 0, n11_n10 = 0, n11=0; foreach (List<int> cluster in s1.Clusters.Values) { t = cluster.Count; n11_n10 += t * (t-1) / 2; } foreach (List<int> cluster in s2.Clusters.Values) { t = cluster.Count; n11_n01 += t * (t - 1) / 2; } Dictionary<string, int> cls = new Dictionary<string, int>(); for (int i = 0; i < s1.Labels.Length; i++) { if (cls.ContainsKey(s1.Labels[i] + "&" + s2.Labels[i])) cls[s1.Labels[i] + "&" + s2.Labels[i]] += 1; else cls.Add(s1.Labels[i] + "&" + s2.Labels[i], 1); } foreach (int cluster in cls.Values) if (cluster >= 2) { t = cluster; n11 += t * (t - 1) / 2; } t = s1.Labels.Length; double pc = t * (t - 1) / 2; rand = ((double)(pc - n11_n10 - n11_n01 + 2*n11)) / ((double)pc); return rand; }
private void UpdateCanvas() { Bitmap dstImage = new Bitmap(srcImage.Width, srcImage.Height); GrayProcessing gp = new GrayProcessing(); Adjustment a = new Adjustment(); Effect e = new Effect(); Segmentation s = new Segmentation(); EdgeDetect ed = new EdgeDetect(); switch (support) { case SupportMethod.Brightness: dstImage = a.Brightness((Bitmap)srcImage.Clone(), this.Degree); break; case SupportMethod.Contrast: dstImage = a.Contrast((Bitmap)srcImage.Clone(), this.Degree); break; case SupportMethod.Thresholding: dstImage = gp.Thresholding((Bitmap)srcImage.Clone(), (byte)(255 - this.Degree)); break; case SupportMethod.Sharpen: dstImage = e.Sharpen((Bitmap)srcImage.Clone(), (byte)this.Degree); break; case SupportMethod.UnsharpMask: dstImage = e.UnsharpMask((Bitmap)srcImage.Clone(), (byte)this.Degree); break; case SupportMethod.AddNoise: dstImage = e.AddNoise((Bitmap)srcImage.Clone(), this.Degree); break; case SupportMethod.Sprinkle: dstImage = e.Sprinkle((Bitmap)srcImage.Clone(), this.Degree); break; case SupportMethod.Pinch: dstImage = e.Pinch((Bitmap)srcImage.Clone(), this.Degree); break; case SupportMethod.Swirl: dstImage = e.Swirl((Bitmap)srcImage.Clone(), this.Degree); break; case SupportMethod.Wave: dstImage = e.Wave((Bitmap)srcImage.Clone(), this.Degree); break; case SupportMethod.MoireFringe: dstImage = e.MoireFringe((Bitmap)srcImage.Clone(), this.Degree); break; case SupportMethod.Diffuse: dstImage = e.Diffuse((Bitmap)srcImage.Clone(), this.Degree); break; case SupportMethod.Lighting: dstImage = e.Lighting((Bitmap)srcImage.Clone(), this.Degree); break; case SupportMethod.Mosaic: dstImage = e.Mosaic((Bitmap)srcImage.Clone(), this.Degree); break; case SupportMethod.ClearSmallArea: dstImage = s.ClearSmallArea((Bitmap)srcImage.Clone(), this.Degree); break; case SupportMethod.EdgeEnhance: dstImage = ed.EdgeEnhance((Bitmap)srcImage.Clone(), this.Degree); break; case SupportMethod.EdgeHomogenize: dstImage = ed.EdgeHomogenize((Bitmap)srcImage.Clone(), this.Degree); break; default: break; } this.panel1.BackgroundImage = dstImage; this.FinalImage = (Bitmap)dstImage.Clone(); }
public abstract double Process(Segmentation s1, Segmentation s2);
//加载XML void LoadXml(string url, string password, string xmlName) { vesal_log.vesal_write_log("开始从DB库中读取XML文件"); ConnectionString connect1 = new ConnectionString(); connect1.Filename = url; connect1.LimitSize = 10000000000; connect1.Journal = false; connect1.Mode = LiteDB.FileMode.ReadOnly; using (var db = new LiteDatabase(connect1)) { bool isHavScene = db.CollectionExists(xmlName + ".xml"); if (!isHavScene) { var stream = db.FileStorage.OpenRead(xmlName + ".xml"); XmlDocument doc = new XmlDocument(); doc.Load(stream); XmlElement root = doc.DocumentElement; XmlElement animation = (XmlElement)root.FirstChild; total = float.Parse(animation.GetAttribute("total")); effective = float.Parse(animation.GetAttribute("effective")); abObjName = animation.GetAttribute("object"); try { Animation_MouseFollowRotation tmpAMF = this.GetComponent <Animation_MouseFollowRotation>(); tmpAMF.minDis = float.Parse(animation.GetAttribute("minDis")); //tmpAMF.maxDis = float.Parse(animation.GetAttribute("maxDis")); Interaction.instance.maxDistance = float.Parse(animation.GetAttribute("maxDis")); Interaction.instance.minDistance = tmpAMF.minDis; tmpAMF.distance = float.Parse(animation.GetAttribute("distance")); Debug.Log("float.Parse(animation.GetAttribute:" + tmpAMF.distance); Camera.main.GetComponent <Interaction>().RotateOpera(transform.parent.rotation.eulerAngles); if (xmlName == "SA0607004" || xmlName == "SA0607005" || xmlName == "SA0607006" || xmlName == "SA0607007") { Camera.main.GetComponent <Interaction>().SetTarget(new Vector3(0, 0, 0), 1); } else { Camera.main.GetComponent <Interaction>().SetTarget(transform.parent.position, tmpAMF.distance); } Camera.main.GetComponent <Interaction>().distance = tmpAMF.distance; try { thisCamera.farClipPlane = float.Parse(animation.GetAttribute("farClipPlane")); thisCamera.fieldOfView = float.Parse(animation.GetAttribute("fieldOfView")); } catch (Exception e) { Debug.Log(e.Message); } string color = animation.GetAttribute("color"); //主题颜色切换 switch (color) { case "白色": thisCamera.backgroundColor = Color.white; uiChange(0); tmpAMF.sprite = tmpAMF.sprite0; break; case "灰色": thisCamera.backgroundColor = new Color(50 / 255f, 50 / 255f, 50 / 255f, 1); uiChange(1); tmpAMF.sprite = tmpAMF.sprite1; break; case "黑色": thisCamera.backgroundColor = Color.black; uiChange(1); tmpAMF.sprite = tmpAMF.sprite1; break; default: break; } } catch (Exception E) { Debug.Log(E.Message); throw E; } XmlNodeList Segmentations = animation.ChildNodes; if (Segmentations.Count == 0) { vesal_log.vesal_write_log("无分段信息"); } else { //分段信息记录 for (int se = 0; se < Segmentations.Count; se++) { Segmentation seg = new Segmentation(); seg.start = float.Parse(((XmlElement)Segmentations[se]).GetAttribute("start")); seg.end = float.Parse(((XmlElement)Segmentations[se]).GetAttribute("end")); seg.count = float.Parse(((XmlElement)Segmentations[se]).GetAttribute("count")); seg.name = ((XmlElement)Segmentations[se]).GetAttribute("name"); seg.countString = ((XmlElement)Segmentations[se]).GetAttribute("countString"); list.Add(seg); } //bool color = true; //分段按钮及进度条生成 for (int s = 0; s < list.Count; s++) { GameObject game1 = Instantiate(Resources.Load <GameObject>("Prefab/PPTProgress")); GameObject game2 = Instantiate(Resources.Load <GameObject>("Prefab/Segmented")); game1.transform.SetParent(progressParent); game2.transform.SetParent(segmentedParent); game1.transform.localPosition = Vector3.zero; game2.transform.localPosition = Vector3.zero; game1.transform.localScale = Vector3.one; game2.transform.localScale = Vector3.one; game1.GetComponent <LayoutElement>().preferredWidth = (int)(1000 * list[s].count / effective) + 1; game1.transform.GetChild(3).GetComponent <Text>().text = list[s].countString; game1.GetComponent <Slider>().minValue = list[s].start / total; game1.GetComponent <Slider>().maxValue = list[s].end / total; game2.transform.GetChild(0).GetComponent <Text>().text = (s + 1).ToString() + "." + list[s].name; game2.GetComponent <SegmentedButton>().index = s; progress.Add(game1.GetComponent <Slider>()); } } LoadModels(url, pwd, aniNo); } else { vesal_log.vesal_write_log(string.Format("库中不存在此模型场景:{0}", xmlName)); } } }
public override double Process(Segmentation s1, Segmentation s2) { return Entropy(s1) + Entropy(s2) - 2 * MI(s1, s2); }
private Segmentation SimulatedAnnealing(double[] normWeights, Segmentation s0, int maxIter) { Segmentation current = s0; Segmentation next = s0; Segmentation best = s0; double e0 = DistConsensus(normWeights, s0); double eCurrent = e0; double eNext = e0; double eBest = e0; int r = 0; double temp = 0.0001428; Random random = new Random(); //int[] l0 = new int[s0.Labels.Length]; //int[] l1 = new int[s0.Labels.Length]; //for (int i = 0; i < l0.Length; i++) // l0[i] = i; //Segmentation seg0 = new Segmentation(l0); //Segmentation seg1 = new Segmentation(l1); //double au0 = DistConsensus(normWeights, seg0); //double au1 = DistConsensus(normWeights, seg1); while (r < maxIter) { next = current.GetNeighbor(Set.SPGraph); eNext = DistConsensus(normWeights, next); if (eNext < eBest) { best = next; eBest = eNext; } if (Math.Exp(-1 * (eNext - eBest) / temp) > random.NextDouble()) { current = next; eCurrent = eNext; } if (r > (maxIter * 4) / 5 && r < (maxIter * 9) / 10) temp = temp * 1.002; r++; } this.Set.DistToConsensus = eBest; return best; }
private double Entropy(Segmentation s) { double entropy = 0; double aux = 0; foreach (int i in s.Clusters.Keys) { aux = (((double)s.Clusters[i].Count) / ((double)s.Labels.Length)); entropy += aux * Math.Log(aux, 2); } return -1 * entropy; }
private static void DebugDragMaxima(Rectangle regionBounds, SCalcRegionBuffers buffers, SCalcRegionTask data, Segmentation.MaxPoint[] maxPoints, int iMaxPointCount) { Rectangle roiRect = data.roiRect; int regionROIOffsetX = regionBounds.X - roiRect.X; int regionROIOffsetY = regionBounds.Y - roiRect.Y; if (iMaxPointCount > 1) { Console.WriteLine(" ----- Max debug -----"); Console.WriteLine(" roi: pos({0},{1}) size({2},{3})", regionBounds.X, regionBounds.Y, regionBounds.Width, regionBounds.Height); Console.WriteLine(" max count:" + iMaxPointCount); } int ri = 0; for (int ry = 0; ry < regionBounds.Height; ry++) { for (int rx = 0; rx < regionBounds.Width; rx++) { int iVal = buffers.maxMap[ri]; if (iVal > 0) { if ((iVal & Segmentation.MAX_POINT) > 0) { data.debugTexture.SetPixel(rx + regionROIOffsetX, ry + regionROIOffsetY, 0, 255, 0, 1); } else { data.debugTexture.SetPixel(rx + regionROIOffsetX, ry + regionROIOffsetY, 255, 0, 0, 1); } if (iMaxPointCount > 1) { Console.WriteLine("maxMap({0},{1})={2}", rx, ry, Segmentation.GetMaxMapString(iVal)); } } ri++; } } if (iMaxPointCount > 1) { foreach (Segmentation.MaxPoint maxPoint in maxPoints) { ri = maxPoint.y * regionBounds.Width + maxPoint.x; int iVal = buffers.maxMap[ri]; Console.WriteLine("maxPoint({0},{1})={2} : {3}", maxPoint.x, maxPoint.y, maxPoint.value, Segmentation.GetMaxMapString(iVal)); } } }
private double MI(Segmentation s1, Segmentation s2) { double mi = 0; double aux = 0; Dictionary<string, long> cls = new Dictionary<string, long>(); for (int i = 0; i < s1.Labels.Length; i++) { if (cls.ContainsKey(s1.Labels[i] + "&" + s2.Labels[i])) cls[s1.Labels[i] + "&" + s2.Labels[i]] += 1; else cls.Add(s1.Labels[i] + "&" + s2.Labels[i], 1); } //foreach (int cluster in cls.Values) //{ // aux = (((double)cluster) / ((double)s1.Labels.Length)); // if (aux != 0) // mi += aux * Math.Log(aux, 2); //} foreach (int cS1 in s1.Clusters.Keys) { foreach (int cS2 in s2.Clusters.Keys) { if (cls.ContainsKey(cS1.ToString() + "&" + cS2.ToString())) { aux = (((double)cls[cS1.ToString() + "&" + cS2.ToString()]) / ((double)s1.Labels.Length)); if (aux != 0) mi += aux * Math.Log((aux * s1.Labels.Length * s1.Labels.Length) / ((double)(s1.Clusters[cS1].Count) * ((double)s2.Clusters[cS2].Count)), 2); } } } return mi; }
public void TearDownFixture() { _segmentation.Dispose(); _segmentation = null; }
public AcknowledgementService send(Address address, OctetString linkService, MaxApduLength maxAPDULength, Segmentation segmentationSupported, ConfirmedRequestService serviceRequest) { return(applicationLayer.send(address, linkService, (uint)maxAPDULength.GetMaxApduLength(), segmentationSupported, serviceRequest)); }
public void ReadFileResponse(BacnetAddress adr, byte invoke_id, Segmentation segmentation, int position, uint count, bool end_of_file, byte[] file_buffer) { SendComplexAck(adr, invoke_id, segmentation, BacnetConfirmedServices.SERVICE_CONFIRMED_ATOMIC_READ_FILE, (b) => { Services.EncodeAtomicReadFileAcknowledge(b, true, end_of_file, position, 1, new byte[][] { file_buffer }, new int[] { (int)count }); }); }
/// <summary> /// Initializes a new instance of the <see cref="DivikResultLoader"/> class. /// </summary> public DivikResultLoader() { _segmentationContext = new Segmentation(); }
public void ReadPropertyResponse(BacnetAddress adr, byte invoke_id, Segmentation segmentation, BacnetObjectId object_id, BacnetPropertyReference property, IEnumerable<BacnetValue> value) { SendComplexAck(adr, invoke_id, segmentation, BacnetConfirmedServices.SERVICE_CONFIRMED_READ_PROPERTY, (b) => { Services.EncodeReadPropertyAcknowledge(b, object_id, property.propertyIdentifier, property.propertyArrayIndex, value); }); }
public bool WaitForSegmentAck(BacnetAddress adr, byte invoke_id, Segmentation segmentation, int timeout) { bool signaled = m_last_segment_ack.Wait(adr, invoke_id, timeout); if (signaled) { segmentation.sequence_number = (byte)((m_last_segment_ack.sequence_number + 1) % 256); segmentation.window_size = m_last_segment_ack.window_size; } return signaled; }
/// <summary> /// Initializes a new instance of the <see cref="DivikService" /> class. /// Creates <see cref="Segmentation" /> (MCR) instance for the service. /// </summary> public DivikService() { _segmentation = new Segmentation(); }
private bool EncodeSegment(BacnetAddress adr, byte invoke_id, Segmentation segmentation, BacnetConfirmedServices service, out EncodeBuffer buffer, Action<EncodeBuffer> apdu_content_encode) { //encode (regular) buffer = EncodeSegmentHeader(adr, invoke_id, segmentation, service, false); apdu_content_encode(buffer); bool more_follows = (buffer.result & EncodeResult.NotEnoughBuffer) > 0; if (segmentation != null && more_follows) { //reencode in segmented EncodeSegmentHeader(adr, invoke_id, segmentation, service, true); apdu_content_encode(buffer); return true; } else if (more_follows) return true; else { return segmentation != null ? segmentation.sequence_number > 0 : false; } }
private double DistConsensus(double[] normWeights, Segmentation seg) { //Sumo 1 del primer termino y 1 del tercero..solo falta restar el 2do termino de la ecuacion (10) en el paper PR. double result = 2; for (int i = 0; i < Set.Segmentations.Count; i++) { result -= 2 * normWeights[i] * rand.Process(seg, Set.Segmentations[i]); } return result; }
private void SendComplexAck(BacnetAddress adr, byte invoke_id, Segmentation segmentation, BacnetConfirmedServices service, Action<EncodeBuffer> apdu_content_encode) { Trace.WriteLine("Sending " + System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(service.ToString().ToLower()) + " ... ", null); //encode EncodeBuffer buffer; if (EncodeSegment(adr, invoke_id, segmentation, service, out buffer, apdu_content_encode)) { //client doesn't support segments if (segmentation == null) { Trace.TraceInformation("Segmenation denied"); ErrorResponse(adr, service, invoke_id, BacnetErrorClasses.ERROR_CLASS_SERVICES, BacnetErrorCodes.ERROR_CODE_ABORT_APDU_TOO_LONG); buffer.result = EncodeResult.Good; //don't continue the segmentation return; } //first segment? validate max segments if (segmentation.sequence_number == 0) //only validate first segment { if (segmentation.max_segments != 0xFF && segmentation.buffer.offset > (segmentation.max_segments * (GetMaxApdu() - 5))) //5 is adpu header { Trace.TraceInformation("Too much segmenation"); ErrorResponse(adr, service, invoke_id, BacnetErrorClasses.ERROR_CLASS_SERVICES, BacnetErrorCodes.ERROR_CODE_ABORT_APDU_TOO_LONG); buffer.result = EncodeResult.Good; //don't continue the segmentation return; } else Trace.WriteLine("Segmentation required", null); } //increment before ack can do so (race condition) unchecked { segmentation.sequence_number++; }; } //send m_client.Send(buffer.buffer, m_client.HeaderLength, buffer.GetLength() - m_client.HeaderLength, adr, false, 0); }
//Evaluo la segmentacion con las medidas RandIndex, VI and NMI y dejo los resultados en el set. Evaluo contra el mejor ground-truth y el promedio contra todos. private void EvaluateMatrixSegmentation(Segmentation segm) { RandIndexSegSim rand = new RandIndexSegSim(); NMISegSim nmi = new NMISegSim(); VISegSim vi = new VISegSim(); //Calcular el rand double min = double.MaxValue; double ave = 0; double aux = 0; for (int i = 0; i < this.Set.GroundTruths.Count; i++) { aux = 1 - rand.Process(segm, this.Set.GroundTruths[i]); if (aux < min) min = aux; ave += aux; } ave = ave / this.Set.GroundTruths.Count; this.Set.Best_RandEvaluation = min; this.Set.Ave_RandEvaluation = ave; //Calcular NMI min = double.MaxValue; ave = 0; aux = 0; for (int i = 0; i < this.Set.GroundTruths.Count; i++) { aux = 1- nmi.Process(segm, this.Set.GroundTruths[i]); if (aux < min) min = aux; ave += aux; } ave = ave / this.Set.GroundTruths.Count; this.Set.Best_NMIEvaluation = min; this.Set.Ave_NMIEvaluation = ave; //Calcular VI min = double.MaxValue; ave = 0; aux = 0; for (int i = 0; i < this.Set.GroundTruths.Count; i++) { aux = vi.Process(segm, this.Set.GroundTruths[i]); if (aux < min) min = aux; ave += aux; } ave = ave / this.Set.GroundTruths.Count; this.Set.Best_VIEvaluation = min; this.Set.Ave_VIEvaluation = ave; }
public void SetUpClass() { _segmentation = new Segmentation(); }
public BulletInfo(double guessFactor, double power, Segmentation segments) { GuessFactor = guessFactor; Power = power; ApplicableSegments = segments; }
public async Task <bool> SetZoom(Setting setting, object?newValue) { if (newValue is int index) { // method 1: get/set zoom level based on resolution //Size[] all = this.GetResolutions(); //if (index >= 0 && index < all.Length) //{ // this.display.SetResolution(all[index]); //} // method 2: get/set zoom level based on scale percentage var all = Display.GetDPIScales(); double?newDpiScale = null; if (all is not null && index >= 0 && index < all.Count) { newDpiScale = all[index]; } // // NOTE: due to current architectural limitations, Morphic v1.x uses the mouse cursor to determine which display to zoom (instead of finding the display the MorphicBar is on) var getCurrentPositionResult = Morphic.WindowsNative.Mouse.Mouse.GetCurrentPosition(); if (getCurrentPositionResult.IsError == true) { return(false); } var currentMousePosition = getCurrentPositionResult.Value !; // var getDisplayForPointResult = Morphic.WindowsNative.Display.Display.GetDisplayForPoint(currentMousePosition); if (getDisplayForPointResult.IsError == true) { return(false); } var targetDisplay = getDisplayForPointResult.Value !; // if (newDpiScale is not null) { // capture the current scale var oldDpiScale = targetDisplay.GetMonitorScalePercentage(); // // capture the recommended scale Display.GetDpiOffsetResult?currentDpiOffsetAndRange; double?recommendedDpiScale; var getCurrentDpiOffsetAndRangeResult = targetDisplay.GetCurrentDpiOffsetAndRange(); if (getCurrentDpiOffsetAndRangeResult.IsSuccess == true) { currentDpiOffsetAndRange = getCurrentDpiOffsetAndRangeResult.Value !; var translateDpiOffsetToScalePercentageResult = Display.TranslateDpiOffsetToScalePercentage(0, currentDpiOffsetAndRange.Value.MinimumDpiOffset, currentDpiOffsetAndRange.Value.MaximumDpiOffset); if (translateDpiOffsetToScalePercentageResult.IsError == true) { recommendedDpiScale = null; } else { recommendedDpiScale = translateDpiOffsetToScalePercentageResult.Value !; } } else { currentDpiOffsetAndRange = null; recommendedDpiScale = null; } // // set the new percentage _ = await targetDisplay.SetDpiScaleAsync(newDpiScale.Value); // report the display scale (percentage) change if (oldDpiScale is not null) { var segmentation = new Segmentation(); if (recommendedDpiScale is not null) { var relativePercent = newDpiScale / recommendedDpiScale; segmentation.Add("scalePercent", ((int)(relativePercent * 100)).ToString()); var recommendedDpiIndex = -currentDpiOffsetAndRange !.Value.MinimumDpiOffset; var relativeDotOffset = index - recommendedDpiIndex; segmentation.Add("dotOffset", relativeDotOffset.ToString()); } // if (newDpiScale > oldDpiScale) { // NOTE: we can't call our main Countly logic from here (which skips Countly event recording if it's not enabled), so we just swallow any "not init'd" errors here try { await Countly.RecordEvent("textSizeIncrease", 1, segmentation); } catch (InvalidOperationException) { } } else { // NOTE: we can't call our main Countly logic from here (which skips Countly event recording if it's not enabled), so we just swallow any "not init'd" errors here try { await Countly.RecordEvent("textSizeDecrease", 1, segmentation); } catch (InvalidOperationException) { } } } } } return(true); }
public SegmentationTests() { segmentation = Segmentation.Instance(); }
//Devuelve la matriz del tamanno de la imagen final con los valores de los pixeles. private Bitmap GetFinalSegImage(Segmentation segm) { int[,] result = new int[this.Set.Image.Height, this.Set.Image.Width]; for (int i = 0; i < result.GetLength(0); i++) { for (int j = 0; j < result.GetLength(1); j++) { result[i, j] = segm.Labels[i * result.GetLength(1) + j]; } } Bitmap image = new Bitmap(this.Set.Image.Width, this.Set.Image.Height,this.Set.Image.PixelFormat); BitmapData data = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadWrite, image.PixelFormat); unsafe { byte* imgPtr = (byte*)(data.Scan0); for (int i = 0; i < data.Height; i++) { for (int j = 0; j < data.Width; j++) { imgPtr[0] = colors[Math.Min(67, result[i, j])].R; imgPtr[1] = colors[Math.Min(67, result[i, j])].G; imgPtr[2] = colors[Math.Min(67, result[i, j])].B; imgPtr += 3; } imgPtr += data.Stride - data.Width * 3; } image.UnlockBits(data); } return image; }
public void CreateObjectResponse(BacnetAddress adr, byte invoke_id, Segmentation segmentation, BacnetObjectId object_id) { SendComplexAck(adr, invoke_id, segmentation, BacnetConfirmedServices.SERVICE_CONFIRMED_CREATE_OBJECT, (b) => { Services.EncodeCreateObjectAcknowledge(b, object_id); }); }
//Esto convierte el objeto segmentacion en la real segmantacion haciendo el proceso contrario al calculo de los superpixels. //El nuevo objeto segmentacion es mucho mas grande....la cardinalidad es la cantidad de pixels y no la cantidad de superpixels. private Segmentation GetSegmentationResult(Segmentation best) { int[] result = new int[this.Set.SuperPixelMatrix.Length]; for (int i = 0; i < this.Set.SuperPixelMatrix.GetLength(0); i++) { for (int j = 0; j < this.Set.SuperPixelMatrix.GetLength(1); j++) { int sp = this.Set.SuperPixelMatrix[i, j]; result[i* this.Set.SuperPixelMatrix.GetLength(1) + j] = best.Labels[sp]; } } return new Segmentation(result); }
public static Tuple <bool, List <List <string> > > Optimize(List <List <double[, ]> > choppedContours, List <double[]> planes, ref ExternalPlanSetup plan, ref StructureSet ss, HNPlan hnPlan, ScriptContext context, List <List <Structure> > optimizedStructures, List <List <Structure> > matchingStructures, string contraName, int numIterations, List <Tuple <bool, double[], string> > features, Tuple <string, string, bool> beamParams) //return a list of strings which is the log of constraint updates during optimization. { //Only make parotid structures if that feature has been selected if (features[0].Item1 == true) { double priorityRatio = features[0].Item2[0]; Segmentation.MakeParotidStructures(choppedContours, planes, ref plan, ref ss, hnPlan, context, matchingStructures, contraName, priorityRatio); } else { //remove previously segmented structures if there foreach (Structure structure in ss.Structures.ToList()) { if (structure.Name.ToLower().Contains("cpg_subseg")) { ss.RemoveStructure(structure); } } } //Now run the first VMAT optimization. plan.SetCalculationModel(CalculationType.PhotonVMATOptimization, "PO_13623"); plan.SetCalculationModel(CalculationType.DVHEstimation, "DVH Estimation Algorithm [15.6.06]"); plan.SetCalculationModel(CalculationType.PhotonVolumeDose, "AAA_13623"); plan.OptimizationSetup.AddNormalTissueObjective(100, 3, 95, 50, 0.2); bool jawTracking = beamParams.Item3; //use jaw tracking if (jawTracking) { try { plan.OptimizationSetup.UseJawTracking = true; } catch { System.Windows.MessageBox.Show("Could not use jaw tracking. Proceeding without."); } } // plan.OptimizeVMAT(); plan.CalculateDose(); string treatmentCenter = beamParams.Item1; string treatmentArea = beamParams.Item2; string mlcId = ""; int areaNum = Int32.Parse(Regex.Match(treatmentArea, @"\d+").Value); if (treatmentCenter == "BC Cancer - Surrey") { switch (areaNum) { case 2: mlcId = ""; break; case 3: mlcId = ""; break; case 4: mlcId = ""; break; case 5: mlcId = ""; break; case 6: mlcId = ""; break; } } else if (treatmentCenter == "BC Cancer - Vancouver") { switch (areaNum) { case 1: mlcId = "1"; break; case 2: mlcId = "HHM0767"; break; case 3: mlcId = ""; break; case 4: mlcId = ""; break; case 5: mlcId = ""; break; case 6: mlcId = "HML0990"; break; case 7: mlcId = "MLC0987"; break; } } string mlcID = "HML0990"; int numCycles = 1; OptimizationOptionsVMAT oov; ; bool isPassed = false; List <List <string> > updateLog = new List <List <string> >(); for (int iter = 0; iter < numIterations; iter++) { //mlcID = plan.Beams.FirstOrDefault<Beam>().MLC.Id; oov = new OptimizationOptionsVMAT(numCycles, mlcID); plan.OptimizeVMAT(oov); plan.CalculateDose(); //Now need to perform a plan check and iteratively adjust constraints based on whether they passed or failed, and whether they passed with flying colours or failed miserably. //Going to find the percentage by which the constraint failed or passed, and adjust both the priority and dose constraint based on this. updateLog.Add(OptObjectivesEditing.UpdateConstraints(ref plan, ref ss, ref hnPlan, context, optimizedStructures, matchingStructures, numCycles)); if (features[0].Item1 == true) { Segmentation.MakeParotidStructures(choppedContours, planes, ref plan, ref ss, hnPlan, context, matchingStructures, contraName, features[0].Item2[0]); } } numCycles = 4; oov = new OptimizationOptionsVMAT(numCycles, mlcID); //Now for a maximum of 3 tries, perform 4-cycle vmat optimization followed by constraint updating until a plan is passed for (int i = 0; i < 3; i++) { plan.OptimizeVMAT(oov); plan.CalculateDose(); updateLog.Add(OptObjectivesEditing.UpdateConstraints(ref plan, ref ss, ref hnPlan, context, optimizedStructures, matchingStructures, numCycles)); if (features[0].Item1 == true) { Segmentation.MakeParotidStructures(choppedContours, planes, ref plan, ref ss, hnPlan, context, matchingStructures, contraName, features[0].Item2[0]); } isPassed = Check.EvaluatePlan(context, hnPlan, matchingStructures, optimizedStructures).Item1; if (isPassed) { break; } } return(Tuple.Create(isPassed, updateLog)); }