private void AddNode(ShapeNode node, State<Shape, ShapeNode> state, string id)
{
Arc<Shape, ShapeNode> arc = state.Arcs.FirstOrDefault(a => node.Annotation.FeatureStruct.ValueEquals(a.Input.FeatureStruct));
ShapeNode nextNode = node.GetNext(n => _filter(n.Annotation));
State<Shape, ShapeNode> nextState;
if (arc != null)
{
nextState = arc.Target;
if (nextNode == node.List.End)
{
nextState.IsAccepting = true;
nextState.AcceptInfos.Add(new AcceptInfo<Shape, ShapeNode>(id, (shape, match) => true, _shapeCount));
}
}
else
{
nextState = nextNode == node.List.End ? _fsa.CreateAcceptingState(id, (shape, match) => true, _shapeCount) : _fsa.CreateState();
FeatureStruct condition = node.Annotation.FeatureStruct.DeepClone();
condition.Freeze();
state.Arcs.Add(condition, nextState);
}
if (nextNode != node.List.End)
AddNode(nextNode, nextState, id);
}
public bool IsMapped(ShapeNode leftNode1, Ngram<Segment> target1, ShapeNode rightNode1, ShapeNode leftNode2, Ngram<Segment> target2, ShapeNode rightNode2)
{
if ((target1.Length == 0 || target1.First.Type == CogFeatureSystem.VowelType) && (target2.Length == 0 || target2.First.Type == CogFeatureSystem.VowelType))
return _vowelMappings.IsMapped(leftNode1, target1, rightNode1, leftNode2, target2, rightNode2);
if ((target1.Length == 0 || target1.First.Type == CogFeatureSystem.ConsonantType) && (target2.Length == 0 || target2.First.Type == CogFeatureSystem.ConsonantType))
return _consMappings.IsMapped(leftNode1, target1, rightNode1, leftNode2, target2, rightNode2);
return false;
}
public static DiagramLink CreateLink(Diagram diagramNet, ShapeNode origin, ShapeNode destination, string toolTip = "#")
{
DiagramLink link = diagramNet.Factory.CreateDiagramLink(origin, destination);
link.HeadShape = ArrowHeads.Tetragon;
link.Brush = new SolidColorBrush(Colors.Green);
link.Text = toolTip;
UnSelectLinkLook(link);
return link;
}
public override IEnumerable <Tuple <ShapeNode, ShapeNode> > Apply(Match <Word, ShapeNode> match, Word output)
{
FeatureStruct fs = _simpleCtxt.FeatureStruct.DeepClone();
fs.ReplaceVariables(match.VariableBindings);
ShapeNode newNode = output.Shape.Add(fs);
return(Tuple.Create((ShapeNode)null, newNode).ToEnumerable());
}
public static bool TryGetMatchingSoundClass(this IEnumerable <SoundClass> soundClasses, SegmentPool segmentPool, Alignment <Word, ShapeNode> alignment, int seq, int col, out SoundClass soundClass)
{
ShapeNode leftNode = alignment.GetLeftNode(seq, col);
Ngram <Segment> target = alignment[seq, col].ToNgram(segmentPool);
ShapeNode rightNode = alignment.GetRightNode(seq, col);
soundClass = soundClasses.FirstOrDefault(sc => sc.Matches(leftNode, target, rightNode));
return(soundClass != null);
}
private void styleNode(ShapeNode node)
{
node.Brush = new MindFusion.Drawing.SolidBrush(Color.White);
node.Pen = new MindFusion.Drawing.Pen(Color.FromArgb(68, 140, 255), 0.9f);
node.TextFormat.Alignment = StringAlignment.Center;
node.TextFormat.LineAlignment = StringAlignment.Center;
node.Font = new Font("Segoe UI", 12, FontStyle.Bold, GraphicsUnit.Point, 0);
node.TextBrush = new MindFusion.Drawing.SolidBrush(Color.Blue);
}
public override bool Matches(ShapeNode leftNode, Ngram<Segment> target, ShapeNode rightNode)
{
foreach (Segment seg in target)
{
if (_fs.IsUnifiable(seg.FeatureStruct))
return true;
}
return false;
}
public void LoadFromNode(ShapeNode node)
{
richTextBox1.Enabled = true;
richTextBox1.Text = node.ToolTip;
richTextBox1.Tag = node;
textBox1.Enabled = true;
textBox1.Text = node.HyperLink;
}
private static void AreEqual(ShapeNode expected, ShapeNode actual, string path)
{
Assert.AreEqual(expected == null ? "NULL" : "NOT_NULL", actual == null ? "NULL" : "NOT_NULL", path);
if (expected != null && actual != null)
{
AreEqual(expected.Appearance, actual.Appearance, $"{path}/Appearance");
AreEqual(expected.Geometry, actual.Geometry, $"{path}/Geometry");
}
}
private ShapeNode PickNextNode(ShapeNode root)
{
// TODO: Could auto-set geometry leaf nodes to Inactive.
Predicate <TreeGraphNode> pred = (node) => {
return(((ShapeNode)node).Value.Status == ShapeStatus.Active);
};
return(root.BreadthFirstSearch(pred) as ShapeNode);
}
public void AllomorphEnvironments()
{
var vowel = FeatureStruct.New(Language.PhonologicalFeatureSystem).Symbol("voc+").Value;
LexEntry headEntry = Entries["32"];
Pattern <Word, ShapeNode> envPattern = Pattern <Word, ShapeNode> .New().Annotation(vowel).Value;
var env = new AllomorphEnvironment(ConstraintType.Require, null, envPattern);
headEntry.PrimaryAllomorph.Environments.Add(env);
var word = new Word(headEntry.PrimaryAllomorph, FeatureStruct.New().Value);
ShapeNode node = word.Shape.Last;
LexEntry nonHeadEntry = Entries["40"];
word.Shape.AddRange(nonHeadEntry.PrimaryAllomorph.Segments.Shape.AsEnumerable().CloneItems());
Annotation <ShapeNode> nonHeadMorph = word.MarkMorph(word.Shape.GetNodes(node.Next, word.Shape.Last),
nonHeadEntry.PrimaryAllomorph);
Assert.That(env.IsWordValid(word), Is.True);
word.RemoveMorph(nonHeadMorph);
nonHeadEntry = Entries["41"];
word.Shape.AddRange(nonHeadEntry.PrimaryAllomorph.Segments.Shape.AsEnumerable().CloneItems());
nonHeadMorph = word.MarkMorph(word.Shape.GetNodes(node.Next, word.Shape.Last),
nonHeadEntry.PrimaryAllomorph);
Assert.That(env.IsWordValid(word), Is.False);
headEntry.PrimaryAllomorph.Environments.Clear();
env = new AllomorphEnvironment(ConstraintType.Require, envPattern, null);
headEntry.PrimaryAllomorph.Environments.Add(env);
word.RemoveMorph(nonHeadMorph);
node = word.Shape.First;
nonHeadEntry = Entries["40"];
word.Shape.AddRangeAfter(word.Shape.Begin,
nonHeadEntry.PrimaryAllomorph.Segments.Shape.AsEnumerable().CloneItems());
nonHeadMorph = word.MarkMorph(word.Shape.GetNodes(word.Shape.First, node.Prev),
nonHeadEntry.PrimaryAllomorph);
Assert.That(env.IsWordValid(word), Is.True);
word.RemoveMorph(nonHeadMorph);
nonHeadEntry = Entries["41"];
word.Shape.AddRangeAfter(word.Shape.Begin,
nonHeadEntry.PrimaryAllomorph.Segments.Shape.AsEnumerable().CloneItems());
word.MarkMorph(word.Shape.GetNodes(word.Shape.First, node.Prev), nonHeadEntry.PrimaryAllomorph);
Assert.That(env.IsWordValid(word), Is.False);
}
private static MDesign_Shape MDesign_Shape(ShapeNode shapeNode)
{
var result = new MDesign_Shape()
{
Path = MDesign_Path(shapeNode.Path),
Color = MDesign_Color(shapeNode.FabricStyle.Color)
};
return(result);
}
private static XDesign_Shape XDesign_Shape(ShapeNode shapeNode)
{
var result = new XDesign_Shape()
{
path = XDesign_Path(shapeNode.Path),
color = XDesign_Color(shapeNode.FabricStyle.Color)
};
return(result);
}
private static Match <ComplexConcParagraphData, ShapeNode> GetNextMatch(Match <ComplexConcParagraphData, ShapeNode> match)
{
ShapeNode nextNode = match.Span.GetEnd(match.Matcher.Direction);
if (((FeatureSymbol)nextNode.Annotation.FeatureStruct.GetValue <SymbolicFeatureValue>("type")).ID != "bdry")
{
nextNode = nextNode.GetNext(match.Matcher.Direction);
}
return(match.Matcher.Match(match.Input, nextNode));
}
public static bool IsComplex(this ShapeNode node)
{
SymbolicFeatureValue sfv;
if (node.Annotation.FeatureStruct.TryGetValue(CogFeatureSystem.SegmentType, out sfv))
{
var symbol = (FeatureSymbol)sfv;
return(symbol == CogFeatureSystem.Complex);
}
return(false);
}
private ShapeNode generateShapeNode(IVisualizableNode visNode, ShapeNode parent)
{
var node = generateShapeNode(visNode);
node.AttachTo(parent, AttachToNode.BottomCenter);
var link = new DiagramLink(treeDiagram, parent, node);
styleLink(link);
treeDiagram.Links.Add(link);
return(node);
}
/// <summary>
/// Move the visible space to show the specified note.
/// </summary>
public void FocusOn(ShapeNode node)
{
//float posX = node.Bounds.X;
//float posY = node.Bounds.Y;
float midX = node.Bounds.X + node.Bounds.Width / 2;
float midY = node.Bounds.Y + node.Bounds.Height / 2;
//datagramView.ScrollTo(posX, posY);
CenterPoint(midX, midY);
diagramView1.Diagram.Selection.Clear();
diagramView1.Diagram.Selection.AddItem(node);
}
public override bool Matches(ShapeNode leftNode, Ngram <Segment> target, ShapeNode rightNode)
{
foreach (Segment seg in target)
{
if (_fs.IsUnifiable(seg.FeatureStruct))
{
return(true);
}
}
return(false);
}
private void RenderShapeNodeStitch(Graphics graphics, ShapeNode shapeNode, Point origin)
{
if (shapeNode == null)
{
throw new ArgumentNullException(nameof(shapeNode));
}
var points = CreatePointArray(shapeNode.Path, origin);
graphics.DrawPolygon(Pens.Black, points);
}
public override Node Create(Vector2 pos)
{
ShapeNode node = CreateInstance <ShapeNode> ();
node.rect = new Rect(pos.x, pos.y, 150, 340);
node.name = "ShapeNode";
node.CreateOutput("Texture", "TextureParam", NodeSide.Right, 50);
return(node);
}
private void Unapply(Match <Word, ShapeNode> targetMatch, Range <ShapeNode> range, VariableBindings varBindings)
{
ShapeNode curNode = range.Start;
for (int i = 0; i < _targetCount; i++)
{
curNode.Annotation.Optional = true;
curNode.SetDirty(true);
curNode = curNode.Next;
}
}
public SamplingOffsetCalculator(IEnumerable <Point2Dmm[]> clusters)
{
_clusters = clusters.Select(c => makeDense(c.Select(OffsetCalculator.AsPoint)).ToArray()).ToList();
_shapeNodes = ShapeNode.From(_clusters).ToList();
/**/
foreach (var node in _shapeNodes)
{
var mesh = createMesh(node);
_meshes.Add(mesh);
}/**/
}
private bool CheckStemWholeWord(Match <Word, ShapeNode> match)
{
Annotation <ShapeNode> stemAnn = match.Input.Stem;
ShapeNode end = stemAnn.Range.End;
while (end.Type() == CogFeatureSystem.ToneLetterType)
{
end = end.Prev;
}
return(!match.Range.Contains(Range <ShapeNode> .Create(stemAnn.Range.Start, end)));
}
public static void UnSelectNode(ShapeNode node)
{
UnSelectNodeLook(node);
foreach (var link in node.OutgoingLinks)
{
UnSelectLinkLook(link);
}
foreach (var link in node.IncomingLinks)
{
UnSelectLinkLook(link);
}
}
public bool IsMapped(ShapeNode leftNode1, Ngram <Segment> target1, ShapeNode rightNode1, ShapeNode leftNode2, Ngram <Segment> target2, ShapeNode rightNode2)
{
if ((target1.Length == 0 || target1.First.Type == CogFeatureSystem.VowelType) && (target2.Length == 0 || target2.First.Type == CogFeatureSystem.VowelType))
{
return(_vowelMappings.IsMapped(leftNode1, target1, rightNode1, leftNode2, target2, rightNode2));
}
if ((target1.Length == 0 || target1.First.Type == CogFeatureSystem.ConsonantType) && (target2.Length == 0 || target2.First.Type == CogFeatureSystem.ConsonantType))
{
return(_consMappings.IsMapped(leftNode1, target1, rightNode1, leftNode2, target2, rightNode2));
}
return(false);
}
void NodesFromLib()
{
shapeList.Items.Clear();
foreach (var shape in shapeLibrary.Shapes)
{
var node = new ShapeNode();
node.Shape = shape;
node.Text = node.Shape.Id;
node.Resize(80, 40);
shapeList.Items.Add(node);
}
}
private void CreareNod(int index, float x, float y)
{
counter = counter + 1; //incrementam numarul de noduri (porti logice)
ShapeNode nod = diagram1.Factory.CreateShapeNode(x - 16, y - 16, 70, 70); // pozitia x, pozitia y, latima, inaltimea
nod.Transparent = true;
nod.EnabledHandles = AdjustmentHandles.Move; //sa se poata muta nodu pe diagrama fara a fi schimbata dimensiunea nodului
nod.Tag = index + "|" + counter.ToString(); // tagu contine indexul porti logice din listview1 si numarul de la counter
nod.ImageAlign = MindFusion.Drawing.ImageAlign.TopLeft;
nod.TextFormat.Alignment = StringAlignment.Center;
nod.TextFormat.LineAlignment = StringAlignment.Far;
nod.AnchorPattern = PoartaLogica.Ancorare(index); // daca modificam dimensiunea 70, 70 trebuie modificate si puncetele de ancorare
//setam imaginea si textul pentru nod (poarta logica)
if (index == 0) //AND
{
nod.Image = imageList1.Images[0];
nod.Text = "AND";
}
else if (index == 1) //OR
{
nod.Image = imageList1.Images[1];
nod.Text = "OR";
}
else if (index == 2) //XOR
{
nod.Image = imageList1.Images[2];
nod.Text = "XOR";
}
else if (index == 3) //NOT
{
nod.Image = imageList1.Images[3];
nod.Text = "NOT";
}
else if (index == 4) //INPUT 0
{
nod.Image = imageList1.Images[4];
nod.Text = labelCounter + "#IN: 0";
labelCounter = labelCounter + 1;
}
else if (index == 5) //INPUT 1
{
nod.Image = imageList1.Images[5];
nod.Text = labelCounter + "#IN: 1";
labelCounter = labelCounter + 1;
}
else if (index == 6) //terminator
{
nod.Image = imageList1.Images[6];
nod.Text = "OUTPUT";
}
}
public ShapeTrie(Term pattern)
{
Contract.Requires(pattern != null && pattern.Groundness != Groundness.Type);
Pattern = pattern;
root = CreateDontCareNodes();
//// If there are no don't care nodes, then create a dummy node.
if (root == null)
{
root = new ShapeNode();
}
}
/// <summary>
/// Gets all of the string representations that match the specified segment.
/// </summary>
/// <param name="node">The phonetic shape node.</param>
/// <returns>The string representations.</returns>
public IEnumerable <string> GetMatchingStrReps(ShapeNode node)
{
foreach (CharacterDefinition cd in this)
{
if (cd.FeatureStruct.IsUnifiable(node.Annotation.FeatureStruct))
{
foreach (string representation in cd.Representations)
{
yield return(representation);
}
}
}
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
if (RootNode == null)
{
var rootNode = new ShapeNode(treeDiagram);
rootNode.Bounds = new RectangleF(40, 15, 18, 10);
styleNode(rootNode);
rootNode.Text = $"No {nameof(RootNode)}!";
treeDiagram.Nodes.Add(rootNode);
}
}
private void RenderShapeNode(Graphics graphics, ShapeNode shapeNode, Point origin)
{
if (shapeNode == null)
{
throw new ArgumentNullException(nameof(shapeNode));
}
using var brush = new SolidBrush(ToDrawingColor(shapeNode.FabricStyle.Color));
var points = CreatePointArray(shapeNode.Path, origin);
graphics.FillPolygon(brush, points);
}
private static void MoveNodesAfter(Shape shape, ShapeNode cur, Span <ShapeNode> span)
{
foreach (ShapeNode node in shape.GetNodes(span).ToArray())
{
if (node.Type() == HCFeatureSystem.Segment)
{
node.Remove();
cur.AddAfter(node);
node.SetDirty(true);
}
cur = node;
}
}
static void Transform(int id, Vec3S32 offset, int[,] rot, Dictionary <int, Node> nodes)
{
Node node = nodes[id];
switch (node.Type)
{
// traverse the multiple children nodes
case NodeType.Group:
for (int i = 0; i < node.Children.Length; i++)
{
Transform(node.Children[i], offset, rot, nodes);
}
break;
// transform might or might not change parent transformation
case NodeType.Transform:
TransformNode trans = (TransformNode)node;
string raw;
if (trans.FrameAttribs.TryGetValue("_t", out raw))
{
string[] bits = raw.SplitSpaces(3);
offset.X += int.Parse(bits[0]);
offset.Y += int.Parse(bits[1]);
offset.Z += int.Parse(bits[2]);
}
if (trans.FrameAttribs.TryGetValue("_r", out raw))
{
byte flags = byte.Parse(raw);
rot = new int[3, 3];
rot[0, (flags >> 0) & 3] = (flags & 0x10) != 0 ? -1 : 1;
rot[1, (flags >> 2) & 3] = (flags & 0x20) != 0 ? -1 : 1;
rot[2, 2] = (flags & 0x40) != 0 ? -1 : 1;
}
Transform(node.Children[0], offset, rot, nodes);
break;
// apply transformation to model
case NodeType.Shape:
ShapeNode shape = (ShapeNode)node;
shape.Model.X = offset.X;
shape.Model.Y = offset.Y;
shape.Model.Z = offset.Z;
if (rot != null)
{
shape.Model.Rot = rot;
}
break;
}
}
/// <summary>
/// Creates nodes in the trie to capture all the don't care (unbound) locations in the pattern.
/// </summary>
private ShapeNode CreateDontCareNodes()
{
int i;
bool isExpanded;
ShapeNode n;
ShapeNode[] children;
return(Pattern.Compute <ShapeNode>(
(x, s) => x.Groundness == Groundness.Variable ? x.Args : null,
(x, ch, s) =>
{
if (x.Symbol.Arity == 0)
{
if (Executer.IsUnboundPatternVariable(x))
{
return new ShapeNode(true);
}
else
{
return null;
}
}
Contract.Assert(x.Symbol.IsDataConstructor);
isExpanded = false;
foreach (var m in ch)
{
if (m != null)
{
isExpanded = true;
break;
}
}
if (!isExpanded)
{
return null;
}
children = new ShapeNode[x.Symbol.Arity];
i = 0;
foreach (var m in ch)
{
children[i++] = m;
}
n = new ShapeNode();
n.AddRefinement((UserSymbol)x.Symbol, children);
return n;
}));
}
private void ProcessSyllableWithMaximalOnset(ShapeNode startNode, ShapeNode endNode, Shape newShape)
{
ShapeNode node = startNode;
ShapeNode onsetStart = node;
while (node.Type() == CogFeatureSystem.ConsonantType && node != endNode.Next)
{
node = node.Next;
}
ShapeNode onsetEnd = node.Prev;
if (onsetStart != node && onsetStart != onsetEnd)
{
ShapeNode n = onsetStart;
if (onsetStart != onsetEnd.List.First)
{
for (; n != onsetEnd.Next; n = n.Next)
{
string onsetStr = n.GetNodes(onsetEnd).StrRep();
if (_initialOnsets.Value.Contains(onsetStr))
{
break;
}
}
// TODO: ambiguous onset, what should we do? For now, we just assume maximal onset
if (n == onsetEnd.Next)
{
n = onsetStart;
}
}
if (n != onsetStart)
{
if (onsetStart.Prev.Type() == CogFeatureSystem.ConsonantType)
{
CombineWith(newShape.GetLast(nd => nd.Type() == CogFeatureSystem.ConsonantType), onsetStart, n.Prev);
}
else
{
Combine(CogFeatureSystem.Coda, newShape, onsetStart, n.Prev);
Annotation <ShapeNode> prevSyllableAnn = newShape.Annotations.Last(ann => ann.Type() == CogFeatureSystem.SyllableType);
prevSyllableAnn.Remove();
newShape.Annotations.Add(prevSyllableAnn.Range.Start, newShape.Last, FeatureStruct.New().Symbol(CogFeatureSystem.SyllableType).Value);
}
startNode = n;
}
}
ProcessSyllable(startNode, endNode, newShape);
}
public Segment Get(ShapeNode node)
{
if (node == null)
return null;
return _segments.GetOrAdd(node.StrRep(), s =>
{
FeatureStruct fs = node.Annotation.FeatureStruct.DeepClone();
fs.RemoveValue(CogFeatureSystem.OriginalStrRep);
fs.RemoveValue(CogFeatureSystem.SyllablePosition);
fs.Freeze();
return new Segment(fs);
});
}
private void Unapply(Match <Word, ShapeNode> targetMatch, Span <ShapeNode> span, VariableBindings varBindings)
{
int i = 0;
foreach (Constraint <Word, ShapeNode> constraint in _analysisRhs.Children.Cast <Constraint <Word, ShapeNode> >())
{
ShapeNode node = targetMatch.GroupCaptures["target" + i].Span.GetStart(targetMatch.Matcher.Direction);
FeatureStruct fs = node.Annotation.FeatureStruct.DeepClone();
fs.PriorityUnion(constraint.FeatureStruct);
node.Annotation.FeatureStruct.Union(fs, varBindings);
node.SetDirty(true);
i++;
}
}
public override bool Matches(ShapeNode leftNode, Ngram<Segment> target, ShapeNode rightNode)
{
string strRep = target.ToString();
if (_ignoreModifiers)
strRep = StripModifiers(strRep);
if (leftNode != null && leftNode.Type() == CogFeatureSystem.AnchorType && _normalizedSegments.Contains(string.Format("#{0}", strRep)))
return true;
if (rightNode != null && rightNode.Type() == CogFeatureSystem.AnchorType && _normalizedSegments.Contains(string.Format("{0}#", strRep)))
return true;
return _normalizedSegments.Contains(strRep);
}
private void rearrange(ShapeNode rootNode)
{
if (treeLayout == null)
{
treeLayout = new TreeLayout(rootNode,
TreeLayoutType.Centered,
false,
TreeLayoutLinkType.Rounded,
TreeLayoutDirections.TopToBottom,
10, 5, true, new SizeF(10, 10));
}
treeLayout.Arrange(treeDiagram);
}
public bool IsMapped(ShapeNode leftNode1, Ngram<Segment> target1, ShapeNode rightNode1, ShapeNode leftNode2, Ngram<Segment> target2, ShapeNode rightNode2)
{
if (_threshold == 0 || target1.Length == 0 || target2.Length == 0)
return false;
IWordAligner aligner = _project.WordAligners[_alignerID];
foreach (Segment seg1 in target1)
{
foreach (Segment seg2 in target2)
{
if (aligner.Delta(seg1.FeatureStruct, seg2.FeatureStruct) <= _threshold)
return true;
}
}
return false;
}
public XMLNode(ShapeNode _node)
{
node = _node;
pnode = new ProxyNode(node);
Text = node.Text;
HyperLink = node.HyperLink;
Tooltip = node.ToolTip;
NodeFont = XMLFont.FromFont(node.Font);
TextColor = System.Drawing.ColorTranslator.ToHtml(pnode.TextColor);
FillColor = System.Drawing.ColorTranslator.ToHtml(pnode.FillColor);
FrameColor = System.Drawing.ColorTranslator.ToHtml(pnode.FrameColor);
FrameThickness = (int)pnode.FrameThickness;
Width = (int)pnode.Width;
Height = (int)pnode.Height;
X = (int)pnode.X;
Y = (int)pnode.Y;
ZIndex = pnode.ZIndex;
}
/// <summary>
/// Is note1 to the right of note2?
/// </summary>
public bool Right(ShapeNode node2)
{
if (node.Bounds.X > node2.Bounds.X) return true;
else return false;
}
// отрисовка диаграммы
private void DrawDiagram()
{
FrameDiagram.ClearAll();
List<Frame> curList = ClassFactory.kBase.FrameList();
foreach (Frame frm in curList)
{
// рисование вершин
ShapeNode node = new ShapeNode { Text = frm.FrameName, Id = frm.FrameId, Brush = new SolidBrush(Color.PowderBlue), Shape = Shapes.Ellipse };
node.Font = new System.Drawing.Font("Microsoft Sans Serif", 9, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
node.TextFormat.Alignment = StringAlignment.Center;
node.TextFormat.LineAlignment = StringAlignment.Center;
node.SetBounds(new RectangleF(new PointF(frm.X, frm.Y), new SizeF(100, 30)), true, true);
FrameDiagram.Nodes.Add(node);
//if (frm.IsA != null)
//{
// DiagramNode from, destination;
// from=
// DiagramLink link=new DiagramLink(FrameDiagram, origin, destination);
// //FrameDiagram.Links.Add(
//}
}
foreach (Frame frm in curList)
{
foreach (Slot slot in frm.FrameSlots)
if (slot.SlotType == Classes.SlotType.Frame)
{
//значит, это субфрейм. Надо нарисовать дугу :)
ShapeNode nodeSubframe = findNodeById(slot.frameId);
ShapeNode nodeMainFrame = findNodeById(frm.FrameId);
DiagramLink link = new DiagramLink(FrameDiagram, nodeSubframe, nodeMainFrame);
link.Text = "Sub";
link.TextColor = Color.DarkBlue;
link.Pen.Color = Color.Blue;
FrameDiagram.Links.Add(link);
}
}
//link.HeadShape = FrameDiagram.Nodes[1];
foreach (ShapeNode node in FrameDiagram.Nodes)
{
Frame from = ClassFactory.kBase.FrameList().Find(f => f.FrameId == (int)node.Id);
if (from.IsA != null)
{
if (from.IsA.frameId != -1)
{
ShapeNode nodeTo = null;
int idTo = from.IsA.frameId;
foreach (ShapeNode innerNode in FrameDiagram.Nodes)
if (((int)innerNode.Id) == idTo)
{
nodeTo = innerNode;
break;
}
DiagramLink link = new DiagramLink(FrameDiagram, node, nodeTo);
link.Text = "Is_a";
link.TextColor = Color.DarkRed;
link.Pen.Color = Color.Red;
FrameDiagram.Links.Add(link);
}
}
//if (node.GetBounds().Contains(e.X, e.Y))
//{
// ClassFactory.kBase.FrameList().Find(f => f.FrameId == (int)node.Id).X = e.X;
// ClassFactory.kBase.FrameList().Find(f => f.FrameId == (int)node.Id).Y = e.Y;
//}
}
//FrameDiagram.Links.
}
private static void SelectNodeLook(ShapeNode node)
{
node.Brush = new LinearGradientBrush(Colors.Green, Colors.BurlyWood, 20); // Brushes.Green;
node.ZIndex = 20;
}
private static void UnSelectNodeLook(ShapeNode node)
{
node.Brush = new LinearGradientBrush(Colors.Yellow, Colors.BurlyWood, 20);// Brushes.Yellow;
node.ZIndex = 10;
}
public static bool TryGetMatchingSoundClass(this IEnumerable<SoundClass> soundClasses, SegmentPool segmentPool, ShapeNode node, out SoundClass soundClass)
{
Annotation<ShapeNode> stemAnn = ((Shape) node.List).Annotations.First(ann => ann.Type() == CogFeatureSystem.StemType);
ShapeNode left = null;
if (stemAnn.Span.Contains(node) || node.Annotation.CompareTo(stemAnn) > 0)
{
ShapeNode leftNode = node.GetPrev(NodeFilter);
if (leftNode != null)
left = stemAnn.Span.Contains(leftNode) ? leftNode : node.List.Begin;
}
Ngram<Segment> target = stemAnn.Span.Contains(node) ? segmentPool.Get(node) : Segment.Anchor;
ShapeNode right = null;
if (stemAnn.Span.Contains(node) || node.Annotation.CompareTo(stemAnn) < 0)
{
ShapeNode rightNode = node.GetNext(NodeFilter);
if (rightNode != null)
right = stemAnn.Span.Contains(rightNode) ? rightNode : node.List.End;
}
soundClass = soundClasses.FirstOrDefault(sc => sc.Matches(left, target, right));
return soundClass != null;
}
void nodeSelected_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
ShapeNode node = sender as ShapeNode;
if (_selectedLink != null)
{
DiagramHelper.UnSelectLink(_selectedLink);
_selectedLink = null;
}
if(node == _selectedNode)
{
DiagramHelper.UnSelectNode(_selectedNode);
_selectedNode = null;
return;
}
if (_selectedNode != null)
DiagramHelper.UnSelectNode(_selectedNode);
_selectedNode = node;
DiagramHelper.SelectNode(node);
}
private void AssertShapeNodeEqual(ShapeNode actualNode, string expectedStrRep, FeatureSymbol expectedType)
{
Assert.That(actualNode.StrRep(), Is.EqualTo(expectedStrRep));
Assert.That(actualNode.Type(), Is.EqualTo(expectedType));
}
public Segment GetExisting(ShapeNode node)
{
return GetExisting(node.StrRep());
}
void linkSelect_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (_selectedNode != null)
{
DiagramHelper.UnSelectNode(_selectedNode);
_selectedNode = null;
}
DiagramLink link = sender as DiagramLink;
if (link == _selectedLink)
{
DiagramHelper.UnSelectLink(link);
_selectedLink = null;
return;
}
if (_selectedLink != null)
DiagramHelper.UnSelectLink(_selectedLink);
_selectedLink = sender as DiagramLink;
DiagramHelper.SelectLink(_selectedLink);
}
private static bool NodeFilter(ShapeNode node)
{
return node.Type().IsOneOf(CogFeatureSystem.VowelType, CogFeatureSystem.ConsonantType, CogFeatureSystem.AnchorType);
}
private Shape3D TestConvShape(ShapeNode node)
{
AppearanceNode appearance = (AppearanceNode)node.appearance.node;
MaterialNode material = appearance.material.node as MaterialNode;
if (node.geometry.node is SphereNode) {
SphereNode sphereNode = (SphereNode)node.geometry.node;
Sphere3D sphere = new Sphere3D();
sphere.Position = new Graph3D.Framework.Math.Vector3D(0, 0, 0);
sphere.Radius = sphereNode.radius.value;
SetAppearance(sphere, appearance);
return sphere;
}
if (node.geometry.node is IndexedFaceSetNode) {
IndexedFaceSetNode faceSetNode = (IndexedFaceSetNode)node.geometry.node;
Shape3DComposite composite = new Shape3DComposite();
int facesCount = 0;
for (int i = 0; i < faceSetNode.coordIndex.length; i++)
if (faceSetNode.coordIndex[i] == -1) facesCount++;
MFVec3f coords = ((CoordinateNode)faceSetNode.coord.node).point;
for (int faceOffsetIndex = 0; faceOffsetIndex < faceSetNode.coordIndex.length; faceOffsetIndex++) {
Triangle3D triangle;
triangle = new Triangle3D();
SFVec3f a = coords[faceSetNode.coordIndex[faceOffsetIndex]];
SFVec3f b = coords[faceSetNode.coordIndex[faceOffsetIndex + 1]];
SFVec3f c = coords[faceSetNode.coordIndex[faceOffsetIndex + 2]];
triangle.A = new Vector3D(a.x, a.y, a.z);
triangle.B = new Vector3D(b.x, b.y, b.z);
triangle.C = new Vector3D(c.x, c.y, c.z);
SetAppearance(triangle, appearance);
composite.Add(triangle);
faceOffsetIndex += 3;
while (faceSetNode.coordIndex[faceOffsetIndex] != -1) {
faceOffsetIndex++;
}
}
triangles += facesCount;
return composite;
}
return null;
}
public abstract bool Matches(ShapeNode leftNode, Ngram<Segment> target, ShapeNode rightNode);
public bool IsMapped(ShapeNode leftNode1, Ngram<Segment> target1, ShapeNode rightNode1, ShapeNode leftNode2, Ngram<Segment> target2, ShapeNode rightNode2)
{
if (_mappings.Count == 0)
return false;
foreach (string strRep1 in GetStrReps(target1))
{
foreach (string strRep2 in GetStrReps(target2))
{
if (strRep1 == strRep2)
return true;
Dictionary<string, List<Tuple<Environment, Environment>>> segments;
List<Tuple<Environment, Environment>> contexts;
if (_mappingLookup.TryGetValue(strRep1, out segments) && segments.TryGetValue(strRep2, out contexts))
return contexts.Any(ctxt => CheckEnvironment(ctxt.Item1, leftNode1, rightNode1) && CheckEnvironment(ctxt.Item2, leftNode2, rightNode2));
}
}
return false;
}
private bool CheckEnvironment(Environment env, ShapeNode leftNode, ShapeNode rightNode)
{
return (env.LeftEnvironment == null || env.LeftEnvironment == leftNode.Type()) && (env.RightEnvironment == null || env.RightEnvironment == rightNode.Type());
}
/// <summary>
/// The default constructor.
/// </summary>
public ProxyNode(ShapeNode note)
{
node = note;
}
// закидываем создаем новый фрейм и отображаем
private void добавитьФреймшаблонToolStripMenuItem_Click(object sender, EventArgs e)
{
AddFrameFrm frm = new AddFrameFrm();
if (frm.ShowDialog()== DialogResult.OK)
{
Random rand = new Random();
Frame frame = new Frame { FrameId = ClassFactory.kBase.GetMaxNodeId(1), FrameName = frm.TextBox };
//frame.FrameSlots.Add(new Slot { SlotName = "slot" + ClassFactory.kBase.GetMaxSlotId(1), SlotId = 0, SlotInheritance = SlotInherit.Override, SlotType = Classes.SlotType.Integer });
//frame.FrameSlots.Add(new Slot { SlotName = "slo1t" + ClassFactory.kBase.GetMaxSlotId(1), SlotId = 1, SlotInheritance = SlotInherit.Same, SlotType = Classes.SlotType.Frame });
ShapeNode node = new ShapeNode { Text = frame.FrameName, Id = frame.FrameId, Brush = new SolidBrush(Color.PowderBlue), Shape = Shapes.Ellipse };
node.SetBounds(new RectangleF(new PointF(rand.Next(100, 400), rand.Next(100, 400)), new SizeF(100, 30)), true, true);
node.Font = new System.Drawing.Font("Microsoft Sans Serif", 9, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
node.TextFormat.Alignment = StringAlignment.Center;
node.TextFormat.LineAlignment = StringAlignment.Center;
ClassFactory.isSaved = false;
frame.X = node.GetBounds().X;
frame.Y = node.GetBounds().Y;
FrameDiagram.Nodes.Add(node);
ClassFactory.kBase.AddFrame(frame);
TreeNode frameitem = new TreeNode { Text = frame.FrameName };
FrameTreeView.Nodes.Add(frameitem);
}
}
/// <summary>
/// Is note1 higher than note2?
/// </summary>
public bool Higher(ShapeNode node2)
{
if (node.Bounds.Y < node2.Bounds.Y) return true;
else return false;
}
public bool IsMapped(ShapeNode leftNode1, Ngram<Segment> target1, ShapeNode rightNode1, ShapeNode leftNode2, Ngram<Segment> target2, ShapeNode rightNode2)
{
return _segmentMappingsComponents.Any(sm => sm.IsMapped(leftNode1, target1, rightNode1, leftNode2, target2, rightNode2));
}
public WordSegmentViewModel(ShapeNode node)
{
_node = node;
_strRep = node.OriginalStrRep();
}
