private void RemovePlacementBasedReferencesToInstanceFromOtherComponents(GeometricRelationship _gr) { if (this.ReferencedBy == null || this.ReferencedBy.Count == 0) { return; } // check if _gr is the only placement in the geometry with id _gr.GeomIDs.X List <GeometricRelationship> other_placements = this.R2GInstances.FindAll(x => x.ID != _gr.ID && x.State.Type == _gr.State.Type && x.GeomIDs.X == _gr.GeomIDs.X).ToList(); if (other_placements == null && other_placements.Count > 0) { return; } List <Component> holding_placement_based_refs = this.ReferencedBy.Where(x => x.R2GInstances[0].State.Type == Relation2GeomType.DESCRIBES && x.R2GInstances[0].GeomIDs.X == _gr.GeomIDs.X).ToList(); if (holding_placement_based_refs == null || holding_placement_based_refs.Count == 0) { return; } foreach (Component c in holding_placement_based_refs) { c.RemoveReferencedComponent_Level0(this, true, ComponentManagerType.ADMINISTRATOR); } }
public bool AddGeometricRelationship(GeometricRelationship _gr, ComponentManagerType _user) { // check if the user has writing access bool success = this.RecordWritingAccess(_user); if (!success) { return(false); } // perform the operation if (_gr == null) { return(false); } if (this.R2GInstances == null) { return(false); } foreach (GeometricRelationship instance in this.R2GInstances) { if (GeometricRelationship.ReferenceSameGeometry(instance, _gr)) { return(false); } } this.R2GInstances.Add(_gr); return(true); }
/// <summary> /// <para>For calculating with the parameter slots in instances w/o affecting the component and its parameters.</para> /// <para>Performed recursively in case the sub-components contain calculations themselves.</para> /// </summary> /// <param name="_container"></param> internal void ExecuteCalculationChainWoArtefacts(FlNetElement _container) { if (_container == null) { return; } GeometricRelationship instance = this.R2GInstances.FirstOrDefault(x => x.InstanceNWElementID == _container.ID); if (instance == null) { return; } // populate the parameter values if (instance.InstanceParamValues == null || instance.InstanceParamValues.Count == 0) { this.UpdateInstanceIn(_container, new Point(0, 0), false); } // recursion this.ExecuteCalculationChainForInstance(instance); // result transfer params -> size, if necessary instance.ApplySizeTransferSettings(); }
internal GeometricRelationship UpdateInstanceIn(FlNetElement _container, Point _offset, bool _reset) { if (_container == null) { return(null); } GeometricRelationship gr = this.R2GInstances.FirstOrDefault(x => x.InstanceNWElementID == _container.ID); if (gr == null) { return(null); } if (gr.InstanceNWElementID != _container.ID) { return(null); } // assemble parameters to pass to the instance Dictionary <string, double> param_slots = this.ExtractParameterValues(); // size is a special case !!! param_slots[Parameter.Parameter.RP_HEIGHT_MIN] = gr.InstanceSize[0]; param_slots[Parameter.Parameter.RP_WIDTH_MIN] = gr.InstanceSize[1]; param_slots[Parameter.Parameter.RP_LENGTH_MIN] = gr.InstanceSize[2]; param_slots[Parameter.Parameter.RP_HEIGHT_MAX] = gr.InstanceSize[3]; param_slots[Parameter.Parameter.RP_WIDTH_MAX] = gr.InstanceSize[4]; param_slots[Parameter.Parameter.RP_LENGTH_MAX] = gr.InstanceSize[5]; // controlled reset if (gr.InstanceParamValues == null) { gr.InstanceParamValues = param_slots; return(gr); } if (_reset) { gr.InstanceParamValues = param_slots; gr.UpdatePositionFrom(_container, _offset, Component.SCALE_PIXEL_TO_M); return(gr); } else { foreach (var entry in param_slots) { if (!(gr.InstanceParamValues.ContainsKey(entry.Key))) { gr.InstanceParamValues.Add(entry.Key, entry.Value); } } gr.ApplySizeTransferSettings(); } return(gr); }
internal GeometricRelationship UpdateInstanceToContainerBinding(long _container_id, long _container_new_id, string _container_new_name) { GeometricRelationship gr = this.R2GInstances.FirstOrDefault(x => x.InstanceNWElementID == _container_id); if (gr == null) { return(null); } gr.UpdateContainerInfo(_container_new_id, _container_new_name); return(gr); }
protected static StructureNode CreateFrom(GeometricRelationship _node_source, StructureNode _sn_parent) { if (_node_source == null) { return(null); } List <HierarchicalContainer> g_content = _node_source.GeometricContent; if (g_content.Count == 0) { return(null); } // a geometric relationship node cannot exist w/o parent component if (_sn_parent == null) { return(null); } if (!_sn_parent.ContentType_Used || _sn_parent.ContentType == null) { return(null); } if (_sn_parent.ContentType != typeof(Component.Component)) { return(null); } // create the node StructureNode node = new StructureNode(); // content node.IDAsLong = _node_source.ID; node.IDAsLong_Used = true; node.ContentType = typeof(GeometricRelationship); node.ContentType_Used = true; // structure node.ParentNode = _sn_parent; foreach (Point3DContainer p3dc in g_content) { StructureNode p3dc_sn = StructureNode.CreateFrom(p3dc, node); if (p3dc_sn != null) { node.children_nodes.Add(p3dc_sn); } } return(node); }
public CompRepInfo FindByGeomId(long _id_volume, int _id_surface) { foreach (CompRep record in this.comp_rep_record_flat) { CompRepInfo cri = record as CompRepInfo; if (cri == null) { continue; } GeometricRelationship geom_rel = cri.GR_Relationships.FirstOrDefault(x => x.GrIds.X == _id_volume && x.GrIds.Y == _id_surface); if (geom_rel != null) { return(cri); } } return(null); }
internal void UpdateInstancePositionIn(FlNetElement _container, Point _offset) { if (_container == null) { return; } GeometricRelationship gr = this.R2GInstances.FirstOrDefault(x => x.InstanceNWElementID == _container.ID); if (gr == null) { return; } if (gr.InstanceNWElementID != _container.ID) { return; } gr.UpdatePositionFrom(_container, new Point(0, 0), Component.SCALE_PIXEL_TO_M); }
internal GeometricRelationship UpdateInstanceConnectivityInfo(FlNetEdge _edge) { if (_edge == null) { return(null); } GeometricRelationship gr = this.R2GInstances.FirstOrDefault(x => x.InstanceNWElementID == _edge.ID); if (gr == null) { return(null); } if (_edge.Start != null && _edge.End != null) { gr.InstancePath[0] = new System.Windows.Media.Media3D.Point3D(_edge.Start.ID, _edge.End.ID, -1); } return(gr); }
/// <summary> /// Executes calculations in all subcomponents and saves the result in the input instance. Uses depth-first sub-component search. /// </summary> /// <param name="_instance"></param> protected void ExecuteCalculationChainForInstance(GeometricRelationship _instance) { foreach (var entry in this.ContainedComponents) { Component subC = entry.Value; if (subC == null) { continue; } subC.ExecuteCalculationChainForInstance(_instance); } foreach (Calculation c in this.ContainedCalculations) { Dictionary <string, double> instance_param_values = _instance.InstanceParamValues; c.PerformCalculationWoArtefacts(ref instance_param_values); _instance.InstanceParamValues = new Dictionary <string, double>(instance_param_values); } }
public static List <MappingObject> CreateMultipleFrom(Component _comp, TypeNode _tn, bool _as_example, List <KeyValuePair <string, TypeNode> > _correspondencies, out MappingError err) { err = MappingError.NONE; List <MappingObject> created_mappings = new List <MappingObject>(); if (_comp == null || _tn == null || _correspondencies == null || _correspondencies.Count < 2) { err = MappingError.MISSING_MAPPING_END; return(created_mappings); } Component current_comp = _comp; MappingError tmp_err = MappingError.NONE; foreach (var entry in _correspondencies) { string[] key_comps = entry.Key.Split(new char[] { '_' }, StringSplitOptions.RemoveEmptyEntries); if (key_comps == null || key_comps.Length < 2) { err = MappingError.MISSING_MAPPING_END; return(created_mappings); } if ((key_comps[0] + "_") == MappingComponent.PREFIX_COMP) { // -------------------------- COMPONENTS --------------------------- // long comp_id = -1; bool success = long.TryParse(key_comps[1], out comp_id); if (!success) { err = MappingError.MISSING_MAPPING_END; return(created_mappings); } if (comp_id != current_comp.ID) { // look for the component in the children of current_comp List <Component> all_sub_comps = current_comp.GetFlatSubCompList(); Component next = all_sub_comps.FirstOrDefault(x => x.ID == comp_id); if (next == null) { err = MappingError.MISSING_MAPPING_END; return(created_mappings); } else { current_comp = next; } } } else if ((key_comps[0] + "_") == MappingComponent.PREFIX_ID) { // ------------------------ COMPONENT IDS -------------------------- // MappingString ms = MappingString.Create(current_comp, entry.Key, entry.Value, _as_example, out tmp_err); if (tmp_err != MappingError.NONE) { err = tmp_err; return(created_mappings); } else { created_mappings.Add(ms); } } else if ((key_comps[0] + "_") == MappingComponent.PREFIX_PARAM) { // -------------------------- PARAMETERS --------------------------- // long param_id = -1; bool success = long.TryParse(key_comps[1], out param_id); if (!success || !current_comp.ContainedParameters.ContainsKey(param_id)) { err = MappingError.MISSING_MAPPING_END; return(created_mappings); } Parameter p = current_comp.ContainedParameters[param_id]; MappingParameter mp = MappingParameter.Create(p, current_comp, entry.Value, _as_example, false, out tmp_err); if (tmp_err != MappingError.NONE) { err = tmp_err; return(created_mappings); } else { created_mappings.Add(mp); } } else if ((key_comps[0] + "_") == MappingComponent.PREFIX_P3DC) { // --------------------------- GEOMETRY ---------------------------- // if (key_comps.Length < 3) { err = MappingError.MISSING_MAPPING_END; return(created_mappings); } long id_primary = -1; int id_second = -1; bool success_1 = long.TryParse(key_comps[1], out id_primary); bool success_2 = int.TryParse(key_comps[2], out id_second); if (!success_1 || !success_2) { err = MappingError.MISSING_MAPPING_END; return(created_mappings); } GeometricRelationship gr = current_comp.R2GInstances.FirstOrDefault(x => x.ID == id_primary); if (gr == null) { err = MappingError.MISSING_MAPPING_END; return(created_mappings); } Point3DContainer p3dc = gr.GeometricContent.FirstOrDefault(x => x.ID_primary == id_primary && x.ID_secondary == id_second) as Point3DContainer; if (p3dc == null) { err = MappingError.MISSING_MAPPING_END; return(created_mappings); } MappingSinglePoint msp = MappingSinglePoint.Create(p3dc, current_comp, entry.Value, _as_example, out tmp_err); if (tmp_err != MappingError.NONE) { err = tmp_err; return(created_mappings); } else { created_mappings.Add(msp); } } } return(created_mappings); }
/// <summary> /// Called when placing a component in a NW element. It creates a new instance of the component. /// </summary> /// <param name="_container"></param> internal void CreateInstance(FlNetElement _container) { if (_container == null) { return; } // check for the proper type of geometric relationship if (this.R2GMainState.Type != Relation2GeomType.CONTAINED_IN && this.R2GMainState.Type != Relation2GeomType.CONNECTS) { return; } // check if the user has writing access if (this.Factory != null) { bool success = this.RecordWritingAccess(this.Factory.Caller); if (!success) { return; } } else { return; } // check for duplicates foreach (GeometricRelationship gr in this.R2GInstances) { if (gr.InstanceNWElementID == _container.ID) { return; } } // check for previous instancing: bool first_instancing = (this.R2GInstances.Count == 1 && this.R2GInstances[0].InstanceNWElementID < 0); // add an automatically generated sub-component containing the size parameters // add an automatically generated sub-component containing the cumulative parameters if (!this.ContainsValidAutoSubcomponentForSize()) { this.AutoAddSubcomponentForSize(); } if (!this.ContainsValidAutoSubcomponentForCumulation()) { this.AutoAddSubcomponentForCumulation(); } // assemble parameters to pass to the instance Dictionary <string, double> param_slots = this.ExtractParameterValues(); // if there has not been any assignment so far, use the first and only GeometricRelationship if (first_instancing) { this.R2GInstances[0].PlaceInFlowNetworkElement(_container, new Point(0, 0), Component.SCALE_PIXEL_TO_M, new List <double> { 0, 0, 0, 0, 0, 0 }, param_slots); } else { this.R2GInstances.Add(GeometricRelationship.CreateAndPlaceInFlowNetworkElement(_container, new Point(0, 0), Component.SCALE_PIXEL_TO_M, param_slots)); } this.UpdateCumulativeValuesFromInstances(); // for the instance counter }