public void MergeTo(VDWidget targetWidget, ElementGroup elementGroup)
{
targetWidget.Children.Add(this);
VDCodeSnippetBody body = this.Store.ElementFactory.CreateElement(VDCodeSnippetBody.DomainClassId) as VDCodeSnippetBody;
this.Body = body;
}
public void CreateSpriteFromGroup()
{
var group = new ElementGroup(0);
group.CreateSprite("");
Assert.AreEqual(1, group.ElementList.Count);
}
/// <summary>
/// Generate an outer glow for the provided rendering element. The glow is defined by the glow
/// width and the stroke size.
/// </summary>
/// <param name="element">rendering element</param>
/// <param name="color">color of the glow</param>
/// <param name="glowWidth">the width of the glow</param>
/// <param name="stroke">the stroke width</param>
/// <returns>generated outer glow</returns>
internal static IRenderingElement OuterGlow(IRenderingElement element, Color color, double glowWidth, double stroke)
{
switch (element)
{
case ElementGroup orgGroup:
var newGroup = new ElementGroup();
foreach (var child in orgGroup)
{
newGroup.Add(OuterGlow(child, color, glowWidth, stroke));
}
return(newGroup);
case LineElement lineElement:
return(new LineElement(lineElement.FirstPoint, lineElement.SecondPoint, stroke + (2 * (glowWidth * stroke)), color));
case GeneralPath org:
if (org.Fill)
{
return(org.Outline(2 * (glowWidth * stroke)).Recolor(color));
}
else
{
return(org.Outline(stroke + (2 * (glowWidth * stroke))).Recolor(color));
}
default:
throw new ArgumentException($"Cannot generate glow for rendering element,{element.GetType()}");
}
}
/// <summary>
/// Allows the model element to configure itself immediately after the Merge process has related it to the target element.
/// </summary>
/// <param name="elementGroup">The group of source elements that have been added back into the target store.</param>
protected override void MergeConfigure(ElementGroup elementGroup)
{
base.MergeConfigure(elementGroup);
LayerPackage.Level = Level;
DomainClassInfo.SetUniqueName(this,
StrategyManager.GetInstance(Store).NamingStrategy.CreateLayerName(
LayerPackage, this, Name));
Namespace =
StrategyManager.GetInstance(Store).NamingStrategy.CreateNamespace(Component.Namespace, Name, this);
Layer mainLayer = SoftwareComponent.GetMainLayer();
if (mainLayer == null)
{
mainLayer = SoftwareComponent.SuggestMainLayer(null);
if (mainLayer == this)
{
mainLayer.StartupProject = true;
mainLayer.HostingContext = HostingContext.Standalone;
}
}
else if (mainLayer.Level < Level)
{
HostingContext = mainLayer.HostingContext;
}
}
/// <summary>
/// Override to use our own name handling
/// </summary>
protected override void MergeConfigure(ElementGroup elementGroup)
{
// UNDONE: Consider providing an ElementNameProvider tied into the
// appropriate named element dictionary.
// Do nothing here. The base calls SetUniqueName, but we want
// all unique name handling to go through our NamedElementDictionary
}
private static T CreateChildElement <T>(ModelElement parent, bool raiseInstantiateEvents) where T : ModelElement
{
var childClass = parent.Partition.DomainDataDirectory.DomainClasses
.FirstOrDefault(dci => typeof(T).IsAssignableFrom(dci.ImplementationClass) && !dci.ImplementationClass.IsAbstract);
var elementOperations = new ElementOperations(parent.Store, parent.Partition);
if (elementOperations != null)
{
var elementGroupPrototype = new ElementGroupPrototype(parent.Partition, childClass.Id);
var partition = elementOperations.ChooseMergeTarget(parent, elementGroupPrototype).Partition;
var element = (T)partition.ElementFactory.CreateElement(childClass);
var elementGroup = new ElementGroup(partition);
elementGroup.Add(element);
elementGroup.MarkAsRoot(element);
elementOperations.MergeElementGroup(parent, elementGroup);
// Flag the element in the state so that the ProductStore class sees it and doesn't
// raise the instantiation event.
if (!raiseInstantiateEvents)
{
element.Store.PropertyBag.Add(element, null);
}
return(element);
}
return(default(T));
}
private string GetUIStatusCss()
{
string matchmodeCSS = GameState.Value.MatchType switch
{
MatchType.PlaceTheName => "--place-the-name",
MatchType.PlaceTheSymbol => "--place-the-symbol",
_ => throw new NotImplementedException(GameState.Value.MatchType.ToString())
};
string sceneTypeCss = NavigationState.Value.Scene switch
{
SceneType.ElementsMatchGameOver => "--game-over",
SceneType.TransitionFromElementsMatchGameToGameOver => "--game-over-sequence",
SceneType.ElementsMatchGame => "--gameplay",
SceneType.MainMenu => "",
_ => throw new NotImplementedException(NavigationState.Value.Scene.ToString())
};
string highlightedElementGroup = "";
byte? expectedAtomicNumber = GameState.Value.ExpectedElement;
if (GameState.Value.HighlighElementsInExpectedGroup && expectedAtomicNumber.HasValue)
{
ElementGroup expectedElementGroup =
TableOfElementsData.ElementByNumber[expectedAtomicNumber.Value].Group;
highlightedElementGroup = "--highlight-group" + expectedElementGroup.GetAsCssClass();
}
return($"{matchmodeCSS} {sceneTypeCss} {highlightedElementGroup}");
}
/// <inheritdoc/>
public IRenderingElement Generate(IAtomContainer container, RendererModel model)
{
ElementGroup numbers = new ElementGroup();
if (!model.GetWillDrawAtomNumbers())
{
return(numbers);
}
var _offset = model.GetAtomNumberOffset();
Vector2 offset = new Vector2(_offset.X, -_offset.Y);
offset *= (1 / model.GetScale());
int number = 1;
foreach (var atom in container.Atoms)
{
Vector2 point = atom.Point2D.Value + offset;
numbers.Add(
new TextElement(ToPoint(point), number.ToString(),
model.GetAtomNumberColorByType() ?
model.GetAtomNumberColorer().GetAtomColor(atom) :
model.GetAtomNumberTextColor()));
number++;
}
return(numbers);
}
/// <inheritdoc/>
public IRenderingElement Generate(IReaction reaction, RendererModel model)
{
if (!model.GetShowReactionBoxes())
{
return(null);
}
var separation = model.GetBondLength() / model.GetScale();
var totalBounds = BoundsCalculator.CalculateBounds(reaction);
if (totalBounds.IsEmpty)
{
return(null);
}
var diagram = new ElementGroup();
var foregroundColor = model.GetForegroundColor();
diagram.Add(new RectangleElement(new Rect(totalBounds.Left - separation, totalBounds.Top - separation,
totalBounds.Right + separation, totalBounds.Bottom + separation),
foregroundColor));
if (reaction.Id != null)
{
diagram.Add(new TextElement(new Point((totalBounds.Left + totalBounds.Right) / 2, totalBounds.Top - separation),
reaction.Id, foregroundColor));
}
return(diagram);
}
/// <inheritdoc/>
public IRenderingElement Generate(IReaction reaction, RendererModel model)
{
if (!model.GetShowReactionBoxes())
{
return(null);
}
if (reaction.Reactants.Count == 0)
{
return(new ElementGroup());
}
double separation = model.GetBondLength() / model.GetScale() / 2;
var totalBounds = BoundsCalculator.CalculateBounds(reaction.Reactants);
ElementGroup diagram = new ElementGroup();
double minX = totalBounds.Left;
double minY = totalBounds.Top;
double maxX = totalBounds.Right;
double maxY = totalBounds.Bottom;
var foregroundColor = model.GetForegroundColor();
diagram.Add(new RectangleElement(new Rect(minX - separation, minY - separation, maxX + separation, maxY + separation), foregroundColor));
diagram.Add(new TextElement(new Point((minX + maxX) / 2, minY - separation), "Reactants", foregroundColor));
return(diagram);
}
/// <summary>
/// Override to use our own name handling
/// </summary>
protected override void MergeConfigure(ElementGroup elementGroup)
{
// UNDONE: Consider providing an ElementNameProvider tied into the
// appropriate named element dictionary.
// Do nothing here. The base calls SetUniqueName, but we want
// all unique name handling to go through our NamedElementDictionary
}
/// <summary>
/// Called by the Merge process to create a relationship between
/// this target element and the specified source element.
/// Typically, a parent-child relationship is established
/// between the target element (the parent) and the source element
/// (the child), but any relationship can be established.
/// </summary>
/// <param name="sourceElement">The element that is to be related to this model element.</param>
/// <param name="elementGroup">The group of source ModelElements that have been rehydrated into the target state.</param>
/// <remarks>
/// This method is overriden to create the relationship between the target element and the specified source element.
/// The base method does nothing.
/// </remarks>
protected override void MergeRelate(ModelElement sourceElement, ElementGroup elementGroup)
{
Guard.NotNull(() => sourceElement, sourceElement);
Guard.NotNull(() => elementGroup, elementGroup);
if (sourceElement is AbstractElementSchema)
{
var component = sourceElement as AbstractElementSchema;
this.Store.GetCurrentDiagram().GetRepresentedView().Elements.Add(component);
return;
}
else if (sourceElement is ExtensionPointSchema)
{
var component = sourceElement as ExtensionPointSchema;
this.Store.GetCurrentDiagram().GetRepresentedView().ExtensionPoints.Add(component);
return;
}
else if (sourceElement is ExtensionElement)
{
////TODO: \o/ Remove this once DSL team fixes merging of MEXes
return;
}
base.MergeRelate(sourceElement, elementGroup);
}
private static void internalEventHandler(FeedbackInput sender, ElementGroup group, object value, Func <ButtonPressedEvent, ColorCode> handler)
{
var ret = new ButtonPressedEvent()
{
Sender = sender,
Value = value,
ComponentGroup = group,
SystemTime = DateTime.Now,
UnityTime = new Time()
};
switch (handler(ret))
{
case ColorCode.Success:
group.VisibleText.color = SuccessColor;
break;
case ColorCode.Hint:
group.VisibleText.color = HintColor;
break;
default:
group.VisibleText.color = MistakeColor;
break;
}
}
/// <inheritdoc/>
public override IRenderingElement GenerateRingElements(IBond bond, IRing ring, RendererModel model)
{
if (RingIsAromatic(ring) &&
model.GetShowAromaticity() &&
ring.Atoms.Count < model.GetMaxDrawableAromaticRing())
{
var pair = new ElementGroup();
if (model.GetCDKStyleAromaticity())
{
pair.Add(GenerateBondElement(bond, BondOrder.Single, model));
base.SetOverrideColor(WPF.Media.Colors.LightGray);
pair.Add(GenerateInnerElement(bond, ring, model));
base.SetOverrideColor(null);
}
else
{
pair.Add(GenerateBondElement(bond, BondOrder.Single, model));
if (!painted_rings.Contains(ring))
{
painted_rings.Add(ring);
pair.Add(GenerateRingRingElement(bond, ring, model));
}
}
return(pair);
}
else
{
return(base.GenerateRingElements(bond, ring, model));
}
}
private static List <Element> MakeGroup(List <Element> element_list)
{
List <Element> grouping_list = new List <Element>();
for (int i = 0; i < element_list.Count; ++i)
{
int j;
for (j = i + 1; j < element_list.Count; ++j)
{
if (!element_list[j].IsContinue())
{
break;
}
}
if (j > i + 1) // Group を作る
{
ElementGroup group = new ElementGroup();
group.AddElementRange(element_list.GetRange(i, j - i));
grouping_list.Add(group);
i = j - 1;
}
else // Group を作らない
{
grouping_list.Add(element_list[i]);
}
}
return(grouping_list);
}
public static void GetMotiffs(GetMotiffsParams pars, ElementGroup[] elPeaks, ElementGroup[] elNoise, out Motiff[] mfPeaks, out Motiff[] mfNoise)
{
var peakClustering = new Clustering(elPeaks);
var emptyClustering = new Clustering(elNoise);
var peakClusters = peakClustering.Work3(pars.CutWeight, pars.Seed, pars.SetCoreWeights);
var emptyClusters = emptyClustering.Work3(pars.CutWeight, pars.Seed, pars.SetCoreWeights);
var peakClusters2 = peakClusters.Where(p => p.TotalCount > pars.SkipClusterSize).Select(p => p.Align()).ToArray();
var emptyClusters2 = emptyClusters.Where(p => p.TotalCount > pars.SkipClusterSize).Select(p => p.Align()).ToArray();
var peakMotifs = peakClusters2.Select(p => Motiff.ExtractMotiff(p.Map, p.MapFactors)).ToArray();
var emptyMotifs = emptyClusters2.Select(p => Motiff.ExtractMotiff(p.Map, p.MapFactors)).ToArray();
if (pars.CrossTest)
{
TransMotiffTest(peakMotifs, peakClusters2, "peaks vs peaks");
TransMotiffTest(peakMotifs, emptyClusters2, "peaks vs empty");
TransMotiffTest(emptyMotifs, emptyClusters2, "empty vs empty");
TransMotiffTest(emptyMotifs, peakClusters2, "empty vs peaks");
}
mfPeaks = peakMotifs;
mfNoise = emptyMotifs;
}
public void MergeTo(VDWidget targetWidget, ElementGroup elementGroup)
{
targetWidget.Children.Add(this);
// the order of creating children is import, why??
// first children, then grand-children???
VDHoriContainer headContainer = this.Store.ElementFactory.CreateElement(VDHoriContainer.DomainClassId,
new PropertyAssignment(VDContainer.TagDomainPropertyId, HEADS_CONTAINER_TAG),
new PropertyAssignment(VDContainer.HasLeftAnchorDomainPropertyId, true),
new PropertyAssignment(VDContainer.HasRightAnchorDomainPropertyId, true),
new PropertyAssignment(VDContainer.HasTopAnchorDomainPropertyId, true)) as VDHoriContainer;
VDFullFilledContainer bodyContainer = this.Store.ElementFactory.CreateElement(VDFullFilledContainer.DomainClassId,
new PropertyAssignment(VDContainer.TagDomainPropertyId, BODYS_CONTAINER_TAG),
new PropertyAssignment(VDContainer.HasLeftAnchorDomainPropertyId, true),
new PropertyAssignment(VDContainer.HasRightAnchorDomainPropertyId, true),
new PropertyAssignment(VDContainer.HasBottomAnchorDomainPropertyId, true)) as VDFullFilledContainer;
VDHoriSeparator hSeparator = this.Store.ElementFactory.CreateElement(VDHoriSeparator.DomainClassId,
new PropertyAssignment(VDHoriSeparator.DefaultYDomainPropertyId, 0.5)) as VDHoriSeparator;
hSeparator.TopWidget = headContainer;
hSeparator.BottomWidget = bodyContainer;
this.Children.Add(headContainer);
this.Children.Add(bodyContainer);
this.Children.Add(hSeparator);
VDTabHead head = this.Store.ElementFactory.CreateElement(
VDTabHead.DomainClassId,
new PropertyAssignment(VDTabHead.TabTitleDomainPropertyId, "New Tab")) as VDTabHead;
VDTabBody body = this.Store.ElementFactory.CreateElement(VDTabBody.DomainClassId) as VDTabBody;
this.ActiveHead = head;
head.Body = body;
headContainer.Children.Add(head);
bodyContainer.Children.Add(body);
}
/// <summary>
/// Called on copy, cut or drag.
/// For a copy or cut, the supplied elements are the model elements, and the call comes, via AddGroupFormat, from ClipboardCommands.ProcessOnMenuCopy().
/// For a drag operation, the elements are the selected shapes and connectors, and the call comes from Diagram.DoDragDrop, if CanMove or CanCopy are true.
/// In the drag case, we want to add the model elements so that we can do a copy
/// if the user presses CTRL while dragging.
///
/// See http://msdn.microsoft.com/library/ff521398.aspx
/// </summary>
/// <param name="shapeOrModelElements">The shape or model elements being copied - usually the current selection.</param>
/// <param name="closureType">Copy or Delete</param>
/// <returns>Group to be stored in the clipboard.</returns>
protected override ElementGroup CreateElementGroup(ICollection <ModelElement> shapeOrModelElements, ClosureType closureType)
{
// CreateElementGroup respects the settings of PropagateCopy.
// Notice that we have set PropagateCopy on the roles from components to the terminals,
// so that terminals will always be copied along with their parents.
// Add the specified group of shapes or elements:
ElementGroup group = base.CreateElementGroup(shapeOrModelElements, closureType);
// If this a set of shapes, add their model elements:
if (shapeOrModelElements.FirstOrDefault() is PresentationElement)
{
// Get the model elements of the shapes:
ICollection <ModelElement> modelElements =
shapeOrModelElements.OfType <PresentationElement>()
// Filter out shapes such as labels that don't have model elements:
.Where(pel => pel.ModelElement != null)
.Select(pel => pel.ModelElement).ToList();
ElementGroup melGroup = base.CreateElementGroup(modelElements, closureType);
group.AddRange(melGroup.GetElements());
}
return(group);
// 2011-03-21 Thanks to Joeul in VMSDK Forum for a bug fix here.
// http://social.msdn.microsoft.com/Forums/en-US/dslvsarchx/thread/0b0b16d4-6014-4b35-9e5a-e27ea02e0ee3
}
private static ElementGroupPrototype MakePrototype(GadgeteerHardware element)
{
var elementGroup = new ElementGroup(element.Store.DefaultPartition);
elementGroup.AddGraph(element, true);
return(elementGroup.CreatePrototype());
}
/// <summary>
/// Merges the relate interface layer.
/// </summary>
/// <param name="sourceElement">The source element.</param>
/// <param name="elementGroup">The element group.</param>
private void MergeRelateInterfaceLayer(ModelElement sourceElement, ElementGroup elementGroup)
{
InterfaceLayer iLayer = sourceElement as InterfaceLayer;
InterfaceLayer = iLayer;
iLayer.Level = LayerLevel;
Component.Layers.Add(iLayer);
}
/// <summary>
/// Generate the Sgroup elements for the provided atom contains.
/// </summary>
/// <param name="container">molecule</param>
/// <returns>Sgroup rendering elements</returns>
IRenderingElement GenerateSgroups(IAtomContainer container, AtomSymbol[] symbols)
{
var result = new ElementGroup();
var sgroups = container.GetCtabSgroups();
if (sgroups == null || !sgroups.Any())
{
return(result);
}
var symbolMap = new Dictionary <IAtom, AtomSymbol>();
for (int i = 0; i < symbols.Length; i++)
{
if (symbols[i] != null)
{
symbolMap[container.Atoms[i]] = symbols[i];
}
}
foreach (var sgroup in sgroups)
{
switch (sgroup.Type)
{
case SgroupType.CtabAbbreviation:
result.Add(GenerateAbbreviationSgroup(container, sgroup));
break;
case SgroupType.CtabMultipleGroup:
result.Add(GenerateMultipleSgroup(sgroup));
break;
case SgroupType.CtabAnyPolymer:
case SgroupType.CtabMonomer:
case SgroupType.CtabCrossLink:
case SgroupType.CtabCopolymer:
case SgroupType.CtabStructureRepeatUnit:
case SgroupType.CtabMer:
case SgroupType.CtabGraft:
case SgroupType.CtabModified:
result.Add(GeneratePolymerSgroup(sgroup, symbolMap));
break;
case SgroupType.CtabComponent:
case SgroupType.CtabMixture:
case SgroupType.CtabFormulation:
result.Add(GenerateMixtureSgroup(sgroup));
break;
case SgroupType.CtabGeneric:
// not strictly a polymer but okay to draw as one
result.Add(GeneratePolymerSgroup(sgroup, null));
break;
}
}
return(result);
}
/// <summary>
/// Provide default name of element, based upon the DisplayName property.
/// </summary>
protected override void MergeConfigure(ElementGroup elementGroup)
{
if (DomainClassInfo.HasNameProperty(this))
{
DomainClassInfo.SetUniqueName(this, SanitizeName(this.GetDomainClass().DisplayName));
}
base.MergeConfigure(elementGroup);
}
/// <summary>
/// Provide default name of element, based upon the DisplayName property.
/// </summary>
protected override void MergeConfigure(ElementGroup elementGroup)
{
if (DomainClassInfo.HasNameProperty(this))
{
DomainClassInfo.SetUniqueName(this, SanitizeName(this.GetDomainClass().DisplayName));
}
base.MergeConfigure(elementGroup);
}
private IRenderingElement GenerateAbbreviationSgroup(IAtomContainer mol, Sgroup sgroup)
{
string label = sgroup.Subscript;
// already handled by symbol remapping
if (sgroup.Bonds.Count > 0 || string.IsNullOrEmpty(label))
{
return(new ElementGroup());
}
if (!CheckAbbreviationHighlight(mol, sgroup))
{
return(new ElementGroup());
}
// we're showing a label where there were no atoms before, we put it in the
// middle of all of those which were hidden
var sgroupAtoms = sgroup.Atoms;
Debug.Assert(sgroupAtoms.Any());
var highlight = sgroupAtoms.First().GetProperty <Color>(StandardGenerator.HighlightColorKey);
var style = parameters.GetHighlighting();
var glowWidth = parameters.GetOuterGlowWidth();
Vector2 labelCoords = GeometryUtil.Get2DCenter(sgroupAtoms);
ElementGroup labelgroup = new ElementGroup();
foreach (var outline in atomGenerator.GenerateAbbreviatedSymbol(label, HydrogenPosition.Right)
.Resize(1 / scale, 1 / -scale)
.GetOutlines())
{
if (highlight != null && style == HighlightStyle.Colored)
{
labelgroup.Add(GeneralPath.ShapeOf(outline, highlight));
}
else
{
labelgroup.Add(GeneralPath.ShapeOf(outline, foreground));
}
}
if (highlight != null && style == HighlightStyle.OuterGlow)
{
ElementGroup group = new ElementGroup
{
// outer glow needs to be being the label
StandardGenerator.OuterGlow(labelgroup, highlight, glowWidth, stroke),
labelgroup
};
return(group);
}
else
{
return(MarkedElement.MarkupAtom(labelgroup, null));
}
}
/// <summary>
/// The main method of the renderer, that uses each of the generators
/// to create a different set of <see cref="IRenderingElement"/>s grouped
/// together into a tree.
/// </summary>
/// <param name="obj">the object of type T to draw</param>
/// <returns>the diagram as a tree of <see cref="IRenderingElement"/>s</returns>
public virtual IRenderingElement GenerateDiagram(T obj)
{
var diagram = new ElementGroup();
foreach (var generator in this.generators)
{
diagram.Add(generator.Generate(obj, this.rendererModel));
}
return(diagram);
}
/// <inheritdoc/>
public virtual IRenderingElement Generate(IAtomContainer container, RendererModel model)
{
ElementGroup elementGroup = new ElementGroup();
foreach (var atom in container.Atoms)
{
elementGroup.Add(MarkedElement.MarkupAtom(this.Generate(container, atom, model), atom));
}
return(elementGroup);
}
/// <inheritdoc/>
public override IRenderingElement GenerateDiagram(IChemObjectSet <IAtomContainer> molecules)
{
ElementGroup diagram = new ElementGroup();
foreach (var molecule in molecules)
{
diagram.Add(atomContainerRenderer.GenerateDiagram(molecule));
}
return(diagram);
}
public void LoadStoryboard(string dir, OsuFile osu)
{
ClearLayer();
List <Element> backEle = null;
List <Element> foreEle = null;
Stopwatch sw = new Stopwatch();
Console.WriteLine(@"Parsing..");
sw.Start();
string osbFile = Path.Combine(dir, osu.OsbFileName);
if (osu.Events.ElementGroup != null)
{
var osb = osu.Events.ElementGroup;
sw.Restart();
osb.Expand();
Console.WriteLine($@"Osu's osb expanded done in {sw.ElapsedMilliseconds} ms");
FillLayerList(ref backEle, ref foreEle, osb);
}
if (File.Exists(osbFile))
{
sw.Restart();
var osb = ElementGroup.Parse(osbFile);
Console.WriteLine($@"Parse osb done in {sw.ElapsedMilliseconds} ms");
sw.Restart();
osb.Expand();
Console.WriteLine($@"Osb expanded done in {sw.ElapsedMilliseconds} ms");
FillLayerList(ref backEle, ref foreEle, osb);
}
sw.Stop();
Directory = dir;
if (backEle == null && foreEle == null)
{
return;
}
StoryboardTiming.Reset();
if (foreEle != null)
{
backEle?.AddRange(foreEle);
}
HwndRenderBase.AddLayers(new CustomLayer[]
{
new StoryboardLayer(HwndRenderBase.RenderTarget, backEle ?? foreEle, StoryboardTiming),
new FpsLayer(HwndRenderBase.RenderTarget),
});
StoryboardTiming.Start();
}
/// <inheritdoc/>
public IRenderingElement Generate(IAtomContainer ac, RendererModel model)
{
ElementGroup diagram = new ElementGroup
{
this.sceneGenerator.Generate(ac, model),
this.bondGenerator.Generate(ac, model),
this.atomGenerator.Generate(ac, model)
};
return(diagram);
}
/// <summary>
/// Called by the Merge process to create a relationship between
/// this target element and the specified source element.
/// Typically, a parent-child relationship is established
/// between the target element (the parent) and the source element
/// (the child), but any relationship can be established.
/// </summary>
/// <param name="sourceElement">The element that is to be related to this model element.</param>
/// <param name="elementGroup">The group of source ModelElements that have been rehydrated into the target state.</param>
/// <remarks>
/// This method is overriden to create the relationship between the target element and the specified source element.
/// The base method does nothing.
/// </remarks>
protected override void MergeRelate(ModelElement sourceElement, ElementGroup elementGroup)
{
////TODO: \o/ Remove this once DSL team fixes merging of MEXes
if (sourceElement is ExtensionElement)
{
return;
}
base.MergeRelate(sourceElement, elementGroup);
}
/// <summary>
/// Allows the model element to configure itself immediately after the Merge process has related it to the target element.
/// </summary>
/// <param name="elementGroup">The group of source elements that have been added back into the target store.</param>
protected override void MergeConfigure(ElementGroup elementGroup)
{
base.MergeConfigure(elementGroup);
if (Layer.Packages.Count == 1)
{
Name = Layer.Namespace;
}
else
{
Name = String.Format("{0}.{1}", Layer.Namespace, Name);
}
}
protected override void SolveInstance(IGH_DataAccess DA)
{
ElementGroup elementGroup = null;
DA.GetData(0, ref elementGroup);
DA.SetData(0, elementGroup.Amount);
DA.SetData(1, elementGroup.Material);
DA.SetData(2, elementGroup.Volume);
DA.SetData(3, elementGroup.Mass);
DA.SetData(4, elementGroup.ElementType);
}
/// <summary>
/// 将元素编组
/// </summary>
/// <param name="elements">需要编组的元素</param>
/// <param name="host">当前的layoutHost</param>
/// <returns></returns>
public static IElementGroup ElementsToGroup(IElement[] elements, ILayoutHost host)
{
if (elements == null || elements.Length == 0)
{
return(null);
}
int count = elements.Length;
IElementGroup group = new ElementGroup();
IElement[] parents = new IElement[count];
IElement parent;
//将所选element从其父节点中移除
for (int i = 0; i < count; i++)
{
parent = host.LayoutRuntime.Layout.FindParent(elements[i]);
//parent = group.FindParent(elements[i]);
if (parent == null)
{
return(null);
}
parents[i] = parent;
(parents[i] as IElementGroup).Elements.Remove(elements[i]);
group.Elements.Add(elements[i]);
}
//统计所选element的父节点的深度级数
int[] levels = new int[count];
IElement[] parentClon = parents.Clone() as IElement[];
for (int i = 0; i < count; i++)
{
while (parentClon[i] != null)
{
parentClon[i] = (parentClon[i] as IElementGroup).FindParent(parentClon[i]);
levels[i]++;
}
}
//查找深度最大的父节点
int maxLevelIndex = 0;
for (int i = 0; i < count - 1; i++)
{
if (levels[i] < levels[i + 1])
{
maxLevelIndex = i + 1;
}
maxLevelIndex = i;
}
//将group加入深度最大的父节点中
(parents[maxLevelIndex] as IElementGroup).Elements.Add(group);
return(group);
}
public static async Task <string> SerializeObjectAsync(ElementGroup group)
{
var sb = new StringBuilder();
foreach (var element in group.ElementList)
{
var result = await SerializeObjectAsync(element);
sb.AppendLine(result);
}
return(sb.ToString().TrimEnd('\n', '\r'));;
}
/// <summary>
/// Для регионов активности и неактивности строит по своему суф.массиву и в результате получает слитые цепочки.
/// </summary>
private static void GetCandidateElements(GetCandidateElementsParams pars, IEnumerable<Region> peaks, IEnumerable<Region> noises,
out ElementGroup[] elPeaks, out ElementGroup[] elNoise)
{
var t = DateTime.Now;
var chrDic = new Dictionary<ChromosomeEnum, Chromosome>();
// peaks
var peaksTmp = peaks.Select(p =>
{
if (!chrDic.ContainsKey(p.Chr))
chrDic.Add(p.Chr, ChrManager.GetChromosome(p.Chr));
return chrDic[p.Chr].GetPack(p.Start, p.Size);
}).ToArray();
TextComparer sfxPeaks = SuffixBuilder.BuildMany2(peaksTmp, pars.MinGroupSize);
elPeaks = sfxPeaks.GetElementGroups().ToArray();
Console.WriteLine("Peaks sfx build, dt=" + (DateTime.Now - t) + ", size=" + sfxPeaks.StrokeSize +
", elCnt=" + elPeaks.Length + ", elTotal=" + elPeaks.Sum(p => p.Count));
// noise
var noiseTmp = noises.Select(p =>
{
if (!chrDic.ContainsKey(p.Chr))
chrDic.Add(p.Chr, ChrManager.GetChromosome(p.Chr));
return chrDic[p.Chr].GetPack(p.Start, p.Size);
}).ToArray();
TextComparer sfxNoise = SuffixBuilder.BuildMany2(noiseTmp, pars.MinGroupSize);
elNoise = sfxNoise.GetElementGroups().ToArray();
Console.WriteLine("Noise sfx build, dt=" + (DateTime.Now - t) + ", size=" + sfxNoise.StrokeSize +
", elCnt=" + elNoise.Length + ", elTotal=" + elNoise.Sum(p => p.Count));
Array.Sort(elPeaks);
Array.Sort(elNoise);
if (pars.PrintCross)
{
Console.WriteLine("TransTest (peaks on peaks)");
TransTest(sfxPeaks.StrokeSize, elPeaks.Take(10), sfxPeaks);
Console.WriteLine("TransTest (peaks on empty)");
TransTest(sfxPeaks.StrokeSize, elPeaks.Take(10), sfxNoise);
Console.WriteLine("TransTest (empty on peaks)");
TransTest(sfxNoise.StrokeSize, elNoise.Take(10), sfxPeaks);
}
if (pars.DropCross)
{
var pc = elPeaks.Length;
var nc = elNoise.Length;
Console.WriteLine("Drop cross elements:");
//elPeaks = elPeaks.Where(p => sfxNoise.GetAllCites(p.Chain, p.Chain.Length).Count() < p.Count/2).ToArray();
//Console.WriteLine("\tpeaks - was:" + pc + ", now:" + elPeaks.Length + ", dropped=" + (pc - elPeaks.Length));
elNoise = elNoise.Where(p => sfxPeaks.GetAllCites(p.Chain, p.Chain.Length).Count() < /*p.Count / 2*/1).ToArray();
Console.WriteLine("\tnoise - was:" + nc + ", now:" + elNoise.Length + ", dropped=" + (nc - elNoise.Length));
}
}
/// <summary>See <see cref="ORMShapeToolboxHelperBase.CreateElementToolPrototype"/>.</summary>
protected sealed override ElementGroupPrototype CreateElementToolPrototype(Store store, Guid domainClassId)
{
// WARNING: This method is _extremely_ order-sensitive. If the order that the toolbox items are listed
// in the .dsl file changes, or if the DSL Tools text template that is used to generate ORMShapeModelToolboxHelperBase
// changes, this method will most likely need to be changed as well.
ElementGroup group = null;
bool unknownItem = false;
if (domainClassId.Equals(ObjectType.DomainClassId))
{
group = new ElementGroup(store);
ObjectType objectType = new ObjectType(store);
group.AddGraph(objectType, true);
switch (myObjectTypeCount++)
{
case 0:
// EntityType - We don't need to do anything else...
break;
case 1:
// ValueType
// Do not try to set the IsValueType property here. IsValueType picks
// up the default data type for the model, which can only be done
// when the model is known. Instead, flag the element so that it
// can be set during MergeRelate on the model.
group.UserData = ORMModel.ValueTypeUserDataKey;
break;
case 2:
// ObjectifiedFactType
group.AddGraph(new Objectification(objectType, AddFactType(store, group, 2)), false);
break;
default:
unknownItem = true;
break;
}
}
else if (domainClassId.Equals(FactType.DomainClassId))
{
group = new ElementGroup(store);
Debug.Assert(myFactTypeCount < 3);
AddFactType(store, group, ++myFactTypeCount);
}
else if (domainClassId.Equals(ExclusiveOrConstraintCoupler.DomainClassId))
{
group = new ElementGroup(store);
MandatoryConstraint mandatory = new MandatoryConstraint(store, null);
group.AddGraph(mandatory, true);
ExclusionConstraint exclusion = new ExclusionConstraint(store, null);
group.AddGraph(exclusion, true);
group.AddGraph(new ExclusiveOrConstraintCoupler(mandatory, exclusion), false);
}
else if (domainClassId.Equals(UniquenessConstraint.DomainClassId))
{
group = new ElementGroup(store);
if (myUniquenessConstraintCount == 0)
{
// Add this here so that we can distinguish between internal and external uniqueness
// constraints without unpacking the model. We want to merge internals into a fact
// and externals into the model.
group.UserData = ORMModel.InternalUniquenessConstraintUserDataKey;
group.AddGraph(UniquenessConstraint.CreateInternalUniquenessConstraint(store), true);
}
else
{
Debug.Assert(myUniquenessConstraintCount == 1);
group.AddGraph(new UniquenessConstraint(store), true);
}
myUniquenessConstraintCount++;
}
return (group == null || unknownItem) ? base.CreateElementToolPrototype(store, domainClassId) : group.CreatePrototype();
}
/// <summary>
/// Creates a new <see cref="FactType"/> with the specified <paramref name="arity"/>.
/// </summary>
/// <param name="store">
/// The <see cref="Store"/> in which the new <see cref="FactType"/> should be created.
/// </param>
/// <param name="group">
/// The <see cref="ElementGroup"/> to which the new <see cref="FactType"/> and its <see cref="Role"/>s should
/// be added.
/// </param>
/// <param name="arity">
/// The number of <see cref="Role"/>s that the new <see cref="FactType"/> should contain.
/// </param>
/// <returns>
/// The newly created <see cref="FactType"/>.
/// </returns>
/// <remarks>
/// The new <see cref="FactType"/> is added to <paramref name="group"/> as a root element.
/// </remarks>
private static FactType AddFactType(Store store, ElementGroup group, int arity)
{
FactType factType = new FactType(store, null);
group.AddGraph(factType, true);
LinkedElementCollection<RoleBase> roles = factType.RoleCollection;
for (int i = 0; i < arity; i++)
{
Role role = new Role(store);
roles.Add(role);
group.AddGraph(role);
}
return factType;
}
public List<Cluster> Work3(int cut = 3, int seed = 1, bool setCoreWeights = false)
{
InitEdges();
Console.WriteLine("Запущена кластеризация второго типа для " + _nodes.Length + " узлов");
var sw = Stopwatch.StartNew();
var weights = new int[_nodes.Length][];
for (int i = 0; i < weights.Length; i++)
{
weights[i] = new int[_nodes.Length];
for (int j = 0; j < _nodes.Length; j++)
weights[i][j] = i != j ? GetEdge(i, j).Weight - cut : (setCoreWeights ? _nodes[i].Count : 0);//_nodes[i].Chain.Length;
}
var m = new Modularity(_nodes, weights, seed);
Console.WriteLine("Start with:" + m.CalcTotalModularity());
var iter = 1;
while (m.Iterate())
Console.WriteLine("Iter[" + iter++ + "]:" + m.CalcTotalModularity());
Console.WriteLine("Result:" + m.CalcTotalModularity());
sw.Stop();
Console.WriteLine("Кластеризация завершена за " + sw.Elapsed);
var clusterIds = m.ClasterIds;
var ret = new List<Cluster>();
for (int i = 0; i < m.NodesCount; i++)
{
// переобозначим элементы каждого кластера
int id = 0;
var dic = new Dictionary<int, int>();
for (int j = 0; j < clusterIds.Length; j++)
{
if(clusterIds[j] != i)
continue;
dic.Add(id++,j);
}
var nodes = new ElementGroup[dic.Count];
var edges = new AlignmentResult[dic.Count][];
for (int j = 0; j < dic.Count; j++)
{
nodes[j] = _nodes[dic[j]];
edges[j] = new AlignmentResult[j];
for (int k = 0; k < j; k++)
{
edges[j][k] = _edges[dic[j]][dic[k]];
if (k == 0)
{
var tt = Alignment.Align(nodes[j].NucleoChain, nodes[k].NucleoChain, 0, 0);
Debug.Assert(tt.Mask == edges[j][k].Mask);
}
}
}
ret.Add(new Cluster(ret.Count, nodes, edges));
}
return ret;
}
public static void Bind(UIElement owner, ElementGroup target)
{
owner.MouseClick += (o, e) => ElementGroup.NavigateTo(target);
}
public Cluster(int clusterId, ElementGroup[] nodes, AlignmentResult[][] edges)
{
ClusterId = clusterId;
Nodes = nodes;
Edges = edges;
}
private void ProcessGroup(LcpTree interval)
{
var size = interval.Lcp; // размер совпадения
var cnt = interval.RightBound - interval.LeftBound + 1; // число совпавших
if (size < _minGroupSize || size > 100)
return;
Debug.Assert(cnt > 1);
// определим позиции совпавших кусков ДНК
var pos = new uint[cnt];
Array.Copy(_suftab, interval.LeftBound, pos, 0, cnt);
// определим сам совпавший кусок
var str = CutAndCheck(pos[0], size);
if (str == null)
return;
if (_elementGroups.Count > 0)
{
// проверим, не стоит ли слить с предыдущей группой
var last = _elementGroups.Last();
if (last.Count < cnt && str.Length < last.Chain.Length && str.SequenceEqual(last.Chain.Take(str.Length)))
{
_elementGroups[_elementGroups.Count-1] =new ElementGroup(str, pos);
return;
}
}
// сформируем группу и сохраним её
var group = new ElementGroup(str, pos);
_elementGroups.Add(group);
}
