public static OSCValue CreateOSCValue(OSCValueType valueType)
        {
            switch (valueType)
            {
            case OSCValueType.Unknown:
                return(null);

            case OSCValueType.Int:
                return(OSCValue.Int(0));

            case OSCValueType.Long:
                return(OSCValue.Long(0));

            case OSCValueType.True:
                return(OSCValue.Bool(true));

            case OSCValueType.False:
                return(OSCValue.Bool(false));

            case OSCValueType.Float:
                return(OSCValue.Float(0));

            case OSCValueType.Double:
                return(OSCValue.Double(0));

            case OSCValueType.String:
                return(OSCValue.String(""));

            case OSCValueType.Null:
                return(OSCValue.Null());

            case OSCValueType.Impulse:
                return(OSCValue.Impulse());

            case OSCValueType.Blob:
                return(OSCValue.Blob(new byte[0]));

            case OSCValueType.Char:
                return(OSCValue.Char(' '));

            case OSCValueType.Color:
                return(OSCValue.Color(Color.white));

            case OSCValueType.TimeTag:
                return(OSCValue.TimeTag(DateTime.Now));

            case OSCValueType.Midi:
                return(OSCValue.Midi(new OSCMidi(0, 0, 0, 0)));

            case OSCValueType.Array:
                return(OSCValue.Array());

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Exemplo n.º 2
0
        public override OSCValue GetValue()
        {
            double value;

            if (double.TryParse(Input.text, out value))
            {
                return(OSCValue.Double(value));
            }

            return(OSCValue.Double(0));
        }
        public void SendDouble(float value)
        {
            var doubleValue = (double)value;

            if (doubleValue > double.Epsilon)
            {
                doubleValue = Math.Min(doubleValue + double.Epsilon, 1);
            }

            Send(_doubleAddress, OSCValue.Double(doubleValue));

            TransmitterTextDouble.text = doubleValue.ToString();
        }
 protected override void FillMessage(OSCMessage message, double value)
 {
     message.AddValue(OSCValue.Double(value));
 }
 protected override void ValueToOSCValues(List <OSCValue> values, double value)
 {
     values.Add(OSCValue.Double(value));
 }
Exemplo n.º 6
0
        protected void MuseTracker(double[] v)
        {
            Debug.Log("IN MUSETRACKER");
            //            double avg = 0;

            // skip if any sensor is over 1
            // for (int i = 0; i < 4; i++) { if (v[i] > 1 || v[i] < 0) { return; } }

            if (numSamps <= history_size)
            {
                if (numSamps < history_size)
                {
                    for (int i = 0; i < 4; i++)
                    {
                        history[numSamps][i] = v[i];
                        means[i]            += v[i];
                        numSamps++;
                    }
                }
                else if (numSamps == history_size)
                {
                    for (int i = 0; i < history_size; i++)
                    {
                        for (int j = 0; j < 4; j++)
                        {
                            means[j] += history[i][j];
                        }
                    }
                    for (int i = 0; i < 4; i++)
                    {
                        means[i] /= history_size;
                    }
                    for (int i = 0; i < history_size; i++)
                    {
                        for (int j = 0; j < 4; j++)
                        {
                            std_devs[j] += Math.Pow(history[i][j] - means[j], 2);
                        }
                    }
                    for (int i = 0; i < 4; i++)
                    {
                        std_devs[i] /= numSamps;
                        std_devs[i]  = Math.Sqrt(std_devs[i]);
                    }
                    numSamps++;
                }
            }
            else
            {
                Debug.Log("v = " + v[0].ToString() + " " + v[1].ToString() + " " + v[2].ToString() + " " + v[3].ToString());

                //shift each entry in memory to the left by one.
                for (int i = 0; i < memory - 1; i++)
                {
                    for (int j = 0; j < 2; j++)
                    {
                        AFvals[i][j] = AFvals[i + 1][j];
                        Tvals[i][j]  = Tvals[i + 1][j];
                    }
                }

                //then normalize by mean and std deviation and put the newest value in the last position
                AFvals[memory - 1][0] = (v[1] - means[1]) / std_devs[1];
                AFvals[memory - 1][1] = (v[2] - means[2]) / std_devs[2];
                Tvals[memory - 1][0]  = (v[0] - means[0]) / std_devs[0];
                Tvals[memory - 1][1]  = (v[3] - means[3]) / std_devs[3];
                Debug.LogFormat("std_dev 1 at line 246 is {}", std_devs[1]);
                if (AFvals[0][0] != -1)
                {
                    double[] AFweighted = smoothprocess(AFvals);
                    double[] Tweighted  = smoothprocess(Tvals);

                    var message = new OSCMessage(_transmitAddress);
                    message.AddValue(OSCValue.Double(Tweighted[0]));
                    message.AddValue(OSCValue.Double(AFweighted[0]));
                    message.AddValue(OSCValue.Double(AFweighted[1]));
                    message.AddValue(OSCValue.Double(Tweighted[1]));
                    _transmitter.Send(message);

                    /* var message2 = new OSCMessage(_transmitAddressErf);
                     *
                     * double left = (v[1] - means[1]) / std_devs[1];
                     * double right = (v[2] - means[2]) / std_devs[2];
                     * message2.AddValue(OSCValue.Double(Erf((left+right)/2)));
                     * _transmitter.Send(message2);*/


                    Debug.Log("avg:" + AFweighted[0].ToString() + " " + AFweighted[1].ToString());
                    double merge = (AFweighted[0] + AFweighted[1]) / 2;

                    present++;
                }
            }
        }