public ConvertToHsv()
 {
     _input = new InputPin("Input", PinMediaType.Image);
     AddPin(_input);
     _output = new OutputPin("HSV", PinMediaType.Image);
     AddPin(_output);
 }
Example #2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="InPins"></param>
        /// <returns></returns>
        public static string GetSimulationResult(bool[] InPins)
        {
            string Result = string.Empty;

            Result = "Simulation Result:\n";
            PrivtFieldName(ref Result);

            // 設定input value至input pins,並輸出input value
            for (int i = 1; i < InPins.Length; i++)
            {
                iPins[i].iPins = InPins[i];
                Result        += Convert.ToInt32(InPins[i]) + " ";
            }

            // 輸出結果
            Result += "|";
            foreach (OPin OutputPin in oPins)
            {
                Result += (" " + Convert.ToInt32(OutputPin.GetOutput()));
            }

            Result += ("\n");

            return(Result);
        }
Example #3
0
        private void OnChangedCountOfCopies(object obj)
        {
            if (!(obj is int))
            {
                return;
            }

            int copies = (int)obj;

            if (_outputs.Count == copies)
            {
                return;
            }

            lock (_outputs)
            {
                foreach (IPin outputPin in _outputs)
                {
                    outputPin.Disconnect();
                    RemovePin(outputPin);
                }
                _outputs.Clear();

                for (uint i = 0; i < copies; i++)
                {
                    var outputPin = new OutputPin("Copy № " + (i + 1), PinMediaType.Image);
                    _outputs.Add(outputPin);
                    AddPin(outputPin);
                }
            }
        }
Example #4
0
        public DynamicAdder(int bits)
        {
            fullAdders = new FullAdder[bits];
            var inputPinSeriesA    = new InputPin[bits];
            var inputPinSeriesB    = new InputPin[bits];
            var outputPinSeriesSum = new OutputPin[bits];

            FullAdder previousFullAdder = null;

            for (var i = 0; i < bits; i++)
            {
                var fullAdder = new FullAdder();

                if (previousFullAdder != null)
                {
                    previousFullAdder.CarryOver.ConnectTo(fullAdder.CarryIn);
                }

                fullAdders[i]         = fullAdder;
                inputPinSeriesA[i]    = fullAdder.InputA;
                inputPinSeriesB[i]    = fullAdder.InputB;
                outputPinSeriesSum[i] = fullAdder.Sum;

                previousFullAdder = fullAdder;
            }

            Overflow = previousFullAdder.CarryOver;

            InputA = new InputPinSeries(inputPinSeriesA);
            InputB = new InputPinSeries(inputPinSeriesB);
            Sum    = new OutputPinSeries(outputPinSeriesSum);
        }
Example #5
0
        public void SetOutput(OutputPin outputPin, double voltage, double vRef)
        {
            byte control = LoadA | LoadB;

            switch (outputPin)
            {
            case OutputPin.DAC0:
                control |= SelectA;
                break;

            case OutputPin.DAC1:
                control |= SelectB;
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(outputPin), outputPin, null);
            }

            ushort volt16Bit = Get16BitVoltage(voltage, vRef);

            byte[] data =
            {
                control,
                (byte)(volt16Bit >> 8),
                (byte)(volt16Bit & 0xff)
            };

            SpiComm.Operate(spiDevice => spiDevice.Write(data));
        }
Example #6
0
        public void ChangeCircutState(OutputPin pin)
        {
            LogHelper.LogMessage("GpioInterface ChangeCircutState invoked: {0} - {1}", DateTime.Now, pin);

            var connectorPin = MapOutputPin(pin);

            gpioConnection.Blink(connectorPin, BlinkDurationMilis);
        }
Example #7
0
        public Not()
        {
            _input = new InputPin("Input", PinMediaType.Image);
            AddPin(_input);

            _output = new OutputPin("Not", PinMediaType.Image);
            AddPin(_output);
        }
Example #8
0
 public override void _Process(float delta)
 {
     if (LastInputPinPressed != null && LastOutputPinPressed != null)
     {
         LastInputPinPressed.ConnectedPin = LastOutputPinPressed;
         LastInputPinPressed  = null;
         LastOutputPinPressed = null;
     }
 }
Example #9
0
        private void ChangePortState(OutputPin outputPin, PortStates portState)
        {
            var gpioPinValue = PortStateToGpioPinValue(portState);

            if (gpioPinValue.HasValue)
            {
                outputPin.GpioPinValue = gpioPinValue.Value;
            }
        }
Example #10
0
        public MSER()
        {
            var mserDetector = new MSERDetector();

            _deltaProperty = new IntegerProperty("Delta", 1, 100, 1)
            {
                Value = mserDetector.Delta
            };
            _maxAreaProperty = new IntegerProperty("MaxArea", 10, 288000, 250)
            {
                Value = mserDetector.MaxArea
            };
            _minAreaProperty = new IntegerProperty("MinArea", 1, 16000, 100)
            {
                Value = mserDetector.MinArea
            };
            _maxVariationProperty = new FloatProperty("MaxVariation", 0, 1, (decimal)0.01f, 2)
            {
                Value = mserDetector.MaxVariation
            };
            _minDiversityProperty = new FloatProperty("MinDiversity", 0, 1, (decimal)0.01f, 2)
            {
                Value = mserDetector.MinDiversity
            };
            _maxEvolutionProperty = new IntegerProperty("MaxEvolution", 0, 1000, 1)
            {
                Value = mserDetector.MaxEvolution
            };
            _areaThresholdProperty = new FloatProperty("AreaThreshold", 0, 5, (decimal)0.01f, 2)
            {
                Value = (float)mserDetector.AreaThreshold
            };
            _minMarginProperty = new FloatProperty("MinMargin", 0, 1, (decimal)0.001f, 3)
            {
                Value = (float)mserDetector.MinMargin
            };
            _edgeBlurSizeProperty = new IntegerProperty("EdgeBlurSize", 0, 100, 1)
            {
                Value = mserDetector.EdgeBlurSize
            };
            AddProperty(_deltaProperty);
            AddProperty(_maxAreaProperty);
            AddProperty(_minAreaProperty);
            AddProperty(_maxVariationProperty);
            AddProperty(_minDiversityProperty);
            AddProperty(_maxEvolutionProperty);
            AddProperty(_areaThresholdProperty);
            AddProperty(_minMarginProperty);
            AddProperty(_edgeBlurSizeProperty);

            _input  = new InputPin("Image", PinMediaType.Image);
            _output = new OutputPin("Contours", PinMediaType.ContoursArray);
            AddPin(_input);
            AddPin(_output);
        }
Example #11
0
        public Clone()
        {
            _countProperty = new IntegerProperty("Count of copies", 0, 10, 1);
            _countProperty.OnValueChanged += OnChangedCountOfCopies;
            AddProperty(_countProperty);

            _input = new InputPin("Input", PinMediaType.Image);
            AddPin(_input);
            _originalOutput = new OutputPin("Original", PinMediaType.Image);
            AddPin(_originalOutput);
        }
        public FastNlMeansDenoisingColored()
        {
            _areaSizeProperty = new IntegerProperty("Area size", 0, 10, 1);
            AddProperty(_areaSizeProperty);

            _input = new InputPin("Input 0", PinMediaType.Image);
            AddPin(_input);

            _output = new OutputPin("And", PinMediaType.Image);
            AddPin(_output);
        }
Example #13
0
 public Merge()
 {
     _output = new OutputPin("Output", PinMediaType.Image);
     _inputB = new InputPin("B", PinMediaType.Image);
     _inputG = new InputPin("G", PinMediaType.Image);
     _inputR = new InputPin("R", PinMediaType.Image);
     AddPin(_output);
     AddPin(_inputR);
     AddPin(_inputG);
     AddPin(_inputB);
 }
Example #14
0
 public FullSubtracter()
 {
     InputA = halfSubtracter1.InputA;
     InputB = halfSubtracter1.InputB;
     halfSubtracter1.Sub.ConnectTo(halfSubtracter2.InputA);
     CarryIn = halfSubtracter2.InputB;
     or.InputA.ConnectTo(halfSubtracter1.CarryOver);
     or.InputB.ConnectTo(halfSubtracter2.CarryOver);
     CarryOver = or.Output;
     Sub       = halfSubtracter2.Sub;
 }
        public SourceFileImage()
        {
            _filepathProperty = new Property("FilePath", FilterPropertyType.String)
            {
                Value = "filename.png"
            };
            AddProperty(_filepathProperty);

            _outputPin = new OutputPin("Image", PinMediaType.Image);
            AddPin(_outputPin);
        }
Example #16
0
 public SplitRgb()
 {
     _input   = new InputPin("Input", PinMediaType.Image);
     _outputB = new OutputPin("B", PinMediaType.Image);
     _outputG = new OutputPin("G", PinMediaType.Image);
     _outputR = new OutputPin("R", PinMediaType.Image);
     AddPin(_input);
     AddPin(_outputR);
     AddPin(_outputG);
     AddPin(_outputB);
 }
Example #17
0
        public Or()
        {
            _input0 = new InputPin("Input 0", PinMediaType.Image);
            AddPin(_input0);

            _input1 = new InputPin("Input 1", PinMediaType.Image);
            AddPin(_input1);

            _output = new OutputPin("Or", PinMediaType.Image);
            AddPin(_output);
        }
Example #18
0
 public SplitHsv()
 {
     _input   = new InputPin("Input", PinMediaType.Image);
     _outputH = new OutputPin("H", PinMediaType.Image);
     _outputS = new OutputPin("S", PinMediaType.Image);
     _outputV = new OutputPin("V", PinMediaType.Image);
     AddPin(_input);
     AddPin(_outputH);
     AddPin(_outputS);
     AddPin(_outputV);
 }
Example #19
0
 public FullAdder()
 {
     InputA = halfAdder1.InputA;
     InputB = halfAdder1.InputB;
     halfAdder1.Sum.ConnectTo(halfAdder2.InputA);
     CarryIn = halfAdder2.InputB;
     or.InputA.ConnectTo(halfAdder1.CarryOver);
     or.InputB.ConnectTo(halfAdder2.CarryOver);
     CarryOver = or.Output;
     Sum       = halfAdder2.Sum;
 }
Example #20
0
        private ConnectorPin MapOutputPin(OutputPin outputPin)
        {
            var pin = _outputPins.SingleOrDefault(ip => ip.Item1 == outputPin);

            if (pin == null)
            {
                var errMsg = $"Invalid value: {outputPin}";
                throw new ArgumentOutOfRangeException(errMsg);
            }

            return(pin.Item2);
        }
Example #21
0
        public InRange()
        {
            _minProperty = new IntegerProperty("Min value", 0, 255, 1);
            AddProperty(_minProperty);
            _maxProperty = new IntegerProperty("Max value", 0, 255, 1);
            AddProperty(_maxProperty);

            _input = new InputPin("Input", PinMediaType.Image);
            AddPin(_input);

            _output = new OutputPin("Filtered", PinMediaType.Image);
            AddPin(_output);
        }
        /// <summary>
        /// Versucht den DVB.NET Datenstrom direkt mit dem zugehörigen Decoder zu verbinden.
        /// </summary>
        /// <param name="decoder">Ein manuell angelegter Decoder.</param>
        /// <param name="source">Der zu verwendende Ausgang.</param>
        /// <param name="mediaType">Das verwendete Format.</param>
        /// <returns>Gesetzt, wenn die Verbindung aufgebaut wurde.</returns>
        private bool TryDirectConnect(TypedComIdentity <IBaseFilter> decoder, OutputPin source, MediaType mediaType)
        {
            // In normal cases we should directly connect to the filter so try
            var connected = false;

            // Try manual connect
            decoder.InspectAllPins(p => p.QueryDirection() == PinDirection.Input,
                                   pin =>
            {
                // Skip on error
                try
                {
                    // Get the raw interface for the media type
                    var type = mediaType.GetReference();

                    // Process
                    using (var iFace = ComIdentity.Create <IPin>(pin))
                        source.Connect(iFace.Interface, type);

                    // Did it
                    connected = true;
                }
                catch (Exception)
                {
                }

                // First pin only - even if it can not be used!
                return(false);
            });

            // Failed
            if (!connected)
            {
                return(false);
            }

            // Find the output of the decoder and render it
            decoder.InspectAllPins(p => p.QueryDirection() == PinDirection.Output,
                                   pin =>
            {
                // Create helper
                using (var pinWrapper = ComIdentity.Create <IPin>(pin))
                    DirectShowObject.Render(pinWrapper.Interface);

                // Did it
                return(false);
            });

            // Report
            return(connected);
        }
Example #23
0
        public override void Process()
        {
            FireProcessingStateChanged(ProcessingState.Started);
            var frame = (IImage)_input.GetData();

            lock (_outputs)
            {
                for (int index = 0; index < _outputs.Count; index++)
                {
                    OutputPin outputPin = _outputs[index];
                    object    clone     = frame.Clone();
                    outputPin.SetData(clone);
                    FireProcessingProgressChanged((index + 1) / (double)_outputs.Count);
                }
            }
            _originalOutput.SetData(frame);
            FireProcessingStateChanged(ProcessingState.Finished);
        }
Example #24
0
        private static void Main(string[] args)
        {
            var pin11 = new OutputPin(GpioPinNumber.Gpio11);
            var pin2  = new OutputPin(GpioPinNumber.Gpio17);

            Console.WriteLine("Press ESC to stop");

            while (!(Console.KeyAvailable && Console.ReadKey(true).Key == ConsoleKey.Escape))
            {
                pin11.Write(State.Low);
                pin2.Write(State.High);
                Thread.Sleep(750);
                pin11.Write(State.High);
                pin2.Write(State.Low);
                Thread.Sleep(750);
            }

            pin11.Cleanup();
            pin2.Cleanup();
        }
Example #25
0
            public async Task SET(OutputPin Pin)
            {
                if (GPIOCOM != null)
                {
                    if ((Pin.GPIOBitmask & OutputRegister) == 0)
                    {
                        await GPIOIOLock.WaitAsync();

                        var resp = await GPIOCOM.GPIOWriteAsync(GPIOStation, Flag.GetIOInPut, null);

                        if (resp != null)
                        {
                            InputRegister   = BitConverter.ToUInt16(resp, 3);
                            OutputRegister  = BitConverter.ToUInt16(resp, 5);
                            OutputRegister |= (Pin.GPIOBitmask);
                            await GPIOCOM.GPIOWriteAsync(GPIOStation, Flag.SetIOOutput, BitConverter.GetBytes(OutputRegister));
                        }
                        GPIOIOLock.Release();
                    }
                }
            }
Example #26
0
        private void CreateAppendAndConfigure(IEnumerable <PinConfiguration> pinConfigurations, RaspyberryPiPort[] raspyberryPiPorts)
        {
            foreach (var pinConfiguration in pinConfigurations)
            {
                var port = raspyberryPiPorts.First(p => p.PinId == pinConfiguration.PinId);
                switch (pinConfiguration.PortType)
                {
                case PortTypes.Switch:
                    _outputPins.Add(OutputPin.CreateSwitch(pinConfiguration.PinId));
                    break;

                case PortTypes.Pulse:
                    var defaultGpioValue = PortStateToGpioPinValue(port.DefaultPortState);
                    _outputPins.Add(OutputPin.CreatePulse(pinConfiguration.PinId, defaultGpioValue.Value, port.PulseLength));
                    break;
                }

                _pinConfigurations.Add(pinConfiguration);
                ChangePortState(port.PortName, port.PortState);
            }
        }
Example #27
0
        public Subtracter8Bit()
        {
            InputA = new InputPinSeries(fullSubtracter1.InputA, fullSubtracter2.InputA, fullSubtracter3.InputA, fullSubtracter4.InputA,
                                        fullSubtracter5.InputA, fullSubtracter6.InputA, fullSubtracter7.InputA, fullSubtracter8.InputA);

            InputB = new InputPinSeries(fullSubtracter1.InputB, fullSubtracter2.InputB, fullSubtracter3.InputB, fullSubtracter4.InputB,
                                        fullSubtracter5.InputB, fullSubtracter6.InputB, fullSubtracter7.InputB, fullSubtracter8.InputB);

            Sub = new OutputPinSeries(fullSubtracter1.Sub, fullSubtracter2.Sub, fullSubtracter3.Sub, fullSubtracter4.Sub,
                                      fullSubtracter5.Sub, fullSubtracter6.Sub, fullSubtracter7.Sub, fullSubtracter8.Sub);

            fullSubtracter1.CarryOver.ConnectTo(fullSubtracter2.CarryIn);
            fullSubtracter2.CarryOver.ConnectTo(fullSubtracter3.CarryIn);
            fullSubtracter3.CarryOver.ConnectTo(fullSubtracter4.CarryIn);
            fullSubtracter4.CarryOver.ConnectTo(fullSubtracter5.CarryIn);
            fullSubtracter5.CarryOver.ConnectTo(fullSubtracter6.CarryIn);
            fullSubtracter6.CarryOver.ConnectTo(fullSubtracter7.CarryIn);
            fullSubtracter7.CarryOver.ConnectTo(fullSubtracter8.CarryIn);

            Overflow = fullSubtracter8.CarryOver;
        }
Example #28
0
        /// <summary>
        /// Versucht den DVB.NET Datenstrom direkt mit dem zugehörigen Decoder zu verbinden.
        /// </summary>
        /// <param name="decoder">Ein manuell angelegter Decoder.</param>
        /// <param name="source">Der zu verwendende Ausgang.</param>
        /// <param name="mediaType">Das verwendete Format.</param>
        /// <returns>Gesetzt, wenn die Verbindung aufgebaut wurde.</returns>
        private bool TryDirectConnect( TypedComIdentity<IBaseFilter> decoder, OutputPin source, MediaType mediaType )
        {
            // In normal cases we should directly connect to the filter so try
            var connected = false;

            // Try manual connect
            decoder.InspectAllPins( p => p.QueryDirection() == PinDirection.Input,
                pin =>
                {
                    // Skip on error
                    try
                    {
                        // Get the raw interface for the media type
                        var type = mediaType.GetReference();

                        // Process
                        using (var iFace = ComIdentity.Create<IPin>( pin ))
                            source.Connect( iFace.Interface, type );

                        // Did it
                        connected = true;
                    }
                    catch (Exception)
                    {
                    }

                    // First pin only - even if it can not be used!
                    return false;
                } );

            // Failed
            if (!connected)
                return false;

            // Find the output of the decoder and render it
            decoder.InspectAllPins( p => p.QueryDirection() == PinDirection.Output,
                pin =>
                {
                    // Create helper
                    using (var pinWrapper = ComIdentity.Create<IPin>( pin ))
                        DirectShowObject.Render( pinWrapper.Interface );

                    // Did it
                    return false;
                } );

            // Report
            return connected;
        }
Example #29
0
        public static NodeGraphManager BuildGraph(GraphEditorViewModel graph)
        {
            List <VisualNodeViewModel> visualExecutionNodes = new List <VisualNodeViewModel>();

            foreach (var graphComponent in graph.VisualNodes)
            {
                VisualNodeViewModel visualNode = graphComponent as VisualNodeViewModel;
                if (visualNode != null && visualNode.ExecutionInputs.Count > 0)
                {
                    visualExecutionNodes.Add(visualNode);
                }
            }

            // Begin to build our graph
            NodeGraphManager graphManager = new NodeGraphManager();

            Dictionary <VisualNodeViewModel, GraphNode> functionNodes = new Dictionary <VisualNodeViewModel, GraphNode>();
            List <VisualConstantNodeViewModel>          constantNodes = new List <VisualConstantNodeViewModel>();

            foreach (dynamic visualNode in graph.VisualNodes)
            {
                if (visualNode is VisualNodeViewModel)
                {
                    functionNodes.Add(visualNode, new GraphNode(visualNode.NodeType, graphManager));
                }
                else if (visualNode is VisualConstantNodeViewModel)
                {
                    constantNodes.Add(visualNode as VisualConstantNodeViewModel);
                }
            }

            // Wire up constant nodes
            foreach (var constantNode in constantNodes)
            {
                List <ConnectionViewModel> connections = GetPinConnections(constantNode.OutputPin, graph);

                // Lookup each input pin that the constant node is connecting to and add it in our graph manager
                foreach (var connection in connections)
                {
                    foreach (var functionNode in functionNodes)
                    {
                        if (functionNode.Key.Inputs.Contains(connection.InputPin))
                        {
                            // Get pin index
                            int pindex = ((NodePinViewModel)connection.InputPin).Index;

                            IDataTypeContainer valueToSet;

                            // Get value to set
                            if (constantNode.OutputPin.DataType == typeof(DataTypes.Numeric))
                            {
                                valueToSet = new DataTypes.Numeric(Double.Parse(constantNode.Value));
                            }
                            else if (constantNode.OutputPin.DataType == typeof(DataTypes.Boolean))
                            {
                                valueToSet = new DataTypes.Boolean(Boolean.Parse(constantNode.Value));
                            }
                            else if (constantNode.OutputPin.DataType == typeof(DataTypes.String))
                            {
                                valueToSet = new DataTypes.String(constantNode.Value);
                            }
                            else
                            {
                                throw new Exception("Data type could not be determined.");
                            }

                            OutputPin pinConnection = new OutputPin(
                                ((NodePinViewModel)connection.InputPin).DataType, null)
                            {
                                OutputValue = valueToSet, OutputRealised = true
                            };


                            graphManager.AddConnection(pinConnection, functionNode.Value.NodeInputs[pindex]);
                        }
                    }
                }
            }

            // Wire up functional nodes
            foreach (var functionNode in functionNodes)
            {
                int outputPindex = 0;

                // Check each output pin on the node
                foreach (var output in functionNode.Key.Outputs)
                {
                    List <ConnectionViewModel> connections = GetPinConnections(output, graph);

                    foreach (var connection in connections)
                    {
                        // Wire up non-execution pins
                        foreach (var targetFunctionNode in functionNodes)
                        {
                            if (targetFunctionNode.Key.Inputs.Contains(connection.InputPin))
                            {
                                int pindex = ((NodePinViewModel)connection.InputPin).Index;

                                graphManager.AddConnection(
                                    functionNodes[functionNode.Key].NodeOutputs[outputPindex],
                                    targetFunctionNode.Value.NodeInputs[pindex]);
                            }
                        }
                    }
                }

                // Wire up execution pins
                foreach (var executionOutput in functionNode.Key.ExecutionOutputs)
                {
                    List <ConnectionViewModel> connections = GetPinConnections(executionOutput, graph);

                    if (connections.Count == 0)
                    {
                        graphManager.AddNode(functionNode.Value);
                    }

                    foreach (var connection in connections)
                    {
                        foreach (var targetFunctionNode in functionNodes)
                        {
                            if (targetFunctionNode.Key.ExecutionInputs.Contains(connection.InputPin))
                            {
                                int pindex = ((NodePinViewModel)connection.OutputPin).Index;
                                graphManager.AddConnection(functionNode.Value, pindex, targetFunctionNode.Value);
                            }
                        }
                    }
                }
            }

            graphManager.RealiseNodeOutputs();

            return(graphManager);
        }
Example #30
0
        /// <summary>
        /// Sets input and output PinTarget for this connection</summary>
        public void SetPinTarget()
        {
            if (InputPin != null)
            {
                bool isInputElementRef = InputElement.DomNode.Is <IReference <DomNode> >();

                if (InputPin.Is <GroupPin>())
                {
                    if (isInputElementRef)
                    {
                        var pinTarget = InputPin.Cast <GroupPin>().PinTarget;
                        InputPinTarget = new PinTarget(pinTarget.LeafDomNode, pinTarget.LeafPinIndex,
                                                       InputElement.DomNode);
                    }
                    else
                    {
                        InputPinTarget = InputPin.Cast <GroupPin>().PinTarget;
                    }
                }
                else
                {
                    if (isInputElementRef)
                    {
                        var reference = InputElement.As <IReference <DomNode> >();
                        InputPinTarget = new PinTarget(reference.Target, InputPin.Index, InputElement.DomNode);
                    }
                    else
                    {
                        InputPinTarget = new PinTarget(InputElement.DomNode, InputPin.Index, null);
                    }
                }
                Debug.Assert(InputPinTarget != null, "sanity check");
            }

            if (OutputPin != null)
            {
                bool isOutputElementRef = OutputElement.DomNode.Is <IReference <DomNode> >();
                if (OutputPin.Is <GroupPin>())
                {
                    if (isOutputElementRef)
                    {
                        var pinTarget = OutputPin.Cast <GroupPin>().PinTarget;
                        OutputPinTarget = new PinTarget(pinTarget.LeafDomNode, pinTarget.LeafPinIndex,
                                                        OutputElement.DomNode);
                    }
                    else
                    {
                        OutputPinTarget = OutputPin.Cast <GroupPin>().PinTarget;
                    }
                }
                else
                {
                    if (isOutputElementRef)
                    {
                        var reference = OutputElement.Cast <IReference <DomNode> >();
                        OutputPinTarget = new PinTarget(reference.Target, OutputPin.Index, OutputElement.DomNode);
                    }
                    else
                    {
                        OutputPinTarget = new PinTarget(OutputElement.DomNode, OutputPin.Index, null);
                    }
                }
                Debug.Assert(OutputPinTarget != null, "sanity check");
            }
        }
Example #31
0
        public void addPins(ActionNode an, XElement node)
        {
            foreach (XElement pins in node.Elements())
            {
                if (pins.Name.LocalName == "argument")
                {
                    MascaretApplication.Instance.VRComponentFactory.Log("ARGUMENT PIN ################################");

                    XAttribute att = pins.Attribute("{http://www.omg.org/spec/XMI/20131001}type");
                    if (att == null)
                        att = pins.Attribute("{http://schema.omg.org/spec/XMI/2.1}type");

                    if (att != null)
                        MascaretApplication.Instance.VRComponentFactory.Log(att.Value);
                    if (att != null && att.Value == "uml:ValuePin")
                    {
                        ValuePin valuePin = new ValuePin();
                        XAttribute attID = pins.Attribute("{http://schema.omg.org/spec/XMI/2.1}id");
                        if (attID == null)
                            attID = pins.Attribute("{http://www.omg.org/spec/XMI/20131001}id");

                        string id = attID.Value;
                        string name = pins.Attribute("name").Value;
                        MascaretApplication.Instance.VRComponentFactory.Log("Pin Name : " + name);
                        valuePin.Id = id;
                        valuePin.name = name;

                        string strType = "";
                        XElement typeNode = pins.Element("type");
                        if (typeNode == null)
                        {
                            // Check if it's an attribute
                            string typeId = pins.Attribute("type").Value;
                            if (_primitiveTypes.ContainsKey(typeId))
                                strType = _primitiveTypes[typeId];
                        }
                        else
                        {
                            XAttribute attr = (XAttribute)typeNode.Attribute("href");
                            if (attr != null)
                                strType = attr.Value.Substring(attr.Value.IndexOf("#") + 1);
                        }
                        MascaretPrimitiveType attributeType = model.getBasicType(strType.ToLower());

                        valuePin.ResourceType = attributeType;

                        string strValue = "";
                        XElement valueNode = pins.Element("value");
                        XAttribute attrV = (XAttribute)valueNode.Attribute("value");
                        if (attrV != null) strValue = attrV.Value;

                        MascaretApplication.Instance.VRComponentFactory.Log("Valeur : " + strValue);
                        valuePin.ValueSpec = attributeType.createValueFromString(strValue);

                        /*Classifier ressourceType = getObjectNodeType(pins);
                        if(ressourceType != null)
                            valuePin.ResourceType = ressourceType;*/

                        an.Action.ValuePins.Add(valuePin);
                        _objectNodes.Add(valuePin.Id, valuePin);
                    }
                    else
                    {
                        InputPin inputPin = new InputPin();
                        inputPin.Id = pins.Attribute("{http://schema.omg.org/spec/XMI/2.1}id").Value;
                        if (inputPin.Id == null) inputPin.Id = pins.Attribute("{http://www.omg.org/spec/XMI/20131001}id").Value;

                        inputPin.name = pins.Attribute("name").Value;
                        Classifier ressourceType = getObjectNodeType(pins);
                        if (ressourceType != null)
                            inputPin.ResourceType = ressourceType;

                        //Debug.Log(" AN : " + an);

                        an.Action.InputPins.Add(inputPin);
                        _objectNodes.Add(inputPin.Id, inputPin);
                    }
                }
                else if (pins.Name.LocalName == "result")
                {
                    OutputPin outputPin = new OutputPin();
                    outputPin.Id = pins.Attribute("id").Value;
                    outputPin.name = pins.Attribute("name").Value;
                    Classifier ressourceType = getObjectNodeType(pins);
                    if (ressourceType != null)
                        outputPin.ResourceType = ressourceType;
                    an.Action.OutputPins.Add(outputPin);
                    _objectNodes.Add(outputPin.Id, outputPin);
                }
            }
        }
Example #32
0
 public Gate(string name = null)
 {
     Name   = name;
     Output = new OutputPin(this, Operation);
 }