protected void InitActivations()
        {
            if (this.mode == ControlMode.Random || this.mode == ControlMode.Manual)
            {
                if (this.useJellyFish)
                {
                    this.activationData = new FishActivationDataJellyfish(this.timeInterval, this.sampleNum, true);
                }
                else
                {
                    this.activationData = new FishActivationDataSwimming(this.timeInterval, this.sampleNum, true);
                }
                this.activationData.RandomActivation();
            }
            else
            if (this.mode == ControlMode.Activations)
            {
                this.activationData = FishActivationData.Load(this.activationFileName);
            }
            else
            if (this.mode == ControlMode.CosSwim)
            {
                this.activationData = new FishActivationDataSwimming(this.timeInterval, this.sampleNum, true);
                var ml = this.activationData[Spring.Type.MuscleMiddle, Spring.Side.Left];
                var bl = this.activationData[Spring.Type.MuscleBack, Spring.Side.Left];
                for (var i = 0; i < this.sampleNum; ++i)
                {
                    var x = i * 1f / (this.sampleNum - 1) * 2 * math.PI;
                    ml.DiscreteFunction[i] = math.sin(x);
                    bl.DiscreteFunction[i] = math.sin(x + math.PI);
                }
                ml.FFT.GenerateFFTData();
                bl.FFT.GenerateFFTData();
            }
            else
            if (this.mode == ControlMode.CosTrun)
            {
                var ar = FishActivationData.Load("TurnRight");

                this.activationData = new FishActivationDataTurnLeft(this.timeInterval, this.sampleNum, true);
                var fl  = this.activationData[Spring.Type.MuscleFront, Spring.Side.Left];
                var ml  = this.activationData[Spring.Type.MuscleMiddle, Spring.Side.Left];
                var afl = ar[Spring.Type.MuscleFront, Spring.Side.Left];
                var aml = ar[Spring.Type.MuscleMiddle, Spring.Side.Left];
                for (var i = 1; i < this.sampleNum; ++i)
                {
                    var x = i * 1f / (this.sampleNum - 1) * 2 * math.PI;
                    if (i < this.sampleNum / 3)
                    {
                        // ml.DiscreteFunction[i] = -math.sin(x*3);
                        // fl.DiscreteFunction[i] = -math.sin(x*3);
                    }
                    fl.DiscreteFunction[i] = -afl.DiscreteFunction[i];
                    ml.DiscreteFunction[i] = -aml.DiscreteFunction[i];
                }
                ml.FFT.GenerateFFTData();
                fl.FFT.GenerateFFTData();
            }
        }
Beispiel #2
0
        protected void Start()
        {
            var sampleNum = 15;
            var inteval   = new float2(0, 30);

            var sa = this.LoadData();

            this.activationData = (sa.Current as SAProblem.ActivationState.Data).ActivationData;

            this.activationData = FishActivationData.Load();

            // var act = this.activationData.ToDiscreteFunctions()[0];

            /*for(var i = 0; i < act.SampleNum; ++i)
             * {
             *  //act[i] = math.sin(2 * math.PI * i / (act.SampleNum-1) * 4);
             *  act[i] = 0;
             * }
             *
             * act[3] = act[4] = 1;
             * act[9] = act[10] = 1;
             *
             * this.curve = act.ToAnimationCurve();
             *
             * var vector = act.ToYVector();
             *
             * var array = vector.Select(s=>(double)s).ToArray();
             * var dft = new DFT();
             *
             * dft.Initialize((uint)array.Length);
             *
             * // Call the DFT and get the scaled spectrum back
             * Complex[] cSpectrum = dft.Execute(array);
             *
             * An = DSP.ConvertComplex.ToMagnitude(cSpectrum);
             * Pn = DSP.ConvertComplex.ToPhaseRadians(cSpectrum);
             *
             * var maxAn = An.Max();
             * var maxIndex = An.ToList().IndexOf(maxAn);
             * var maxPn = Pn[maxIndex];
             *
             * var start = new Tuple<float, float>(inteval.x, 0);
             * var end = new Tuple<float, float>(inteval.y, 0);
             * var function = new X2FDiscreteFunction<float>(start, end, sampleNum);
             *
             * for (var i = 0; i < function.SampleNum; ++i)
             * {
             *  var x = 2 * math.PI * i / (act.SampleNum - 1);
             *  //function[i] = (float)(An[0] / 2 + maxAn * math.cos(maxIndex * x + maxPn));
             *  //function[i] = FishActivationData.GetFx(An, Pn, x, 1);
             * }
             *
             * this.curve2 = function.ToAnimationCurve();
             */
        }
        public MuscleMC()
        {
            this.muscleControlParamters = new Dictionary <Spring.Type, Parameter>();
            var types = this.GetSpringTypes();

            foreach (var t in types)
            {
                this.muscleControlParamters.Add(t, new Parameter());
            }

            this.activationData = FishActivationData.Load(this.FileName);

            this.parameters = this.muscleControlParamters.Values.ToList();
        }
        protected void Start()
        {
            this.body = this.GetComponent <FishBody>();
            this.body.Init();

            // this.activationData = new FishActivationDataSwimming(this.interval, this.sampleNum);
            //this.activationData.RandomActivation();
            this.activationData = FishActivationData.Load();
            this.interval       = this.activationData.Interval;
            this.sampleNum      = this.activationData.SampleNum;

            this.curves      = this.activationData.ToAnimationCurves();
            this.activations = this.activationData.ToActivationList();

            var problem = new FishSimulatorOffline.Problem(this.body.modelData, this.activationData);
            var dt      = new IterationDelta();
            var sim     = new FishSimulatorOffline(problem, dt);

            sim.TryToRun();
        }