Cómo crear valor a partir de 0..1..0..1..0 etc pulsante para una duración dada?

Question

Estoy trabajando en algo de código en el que tengo un objeto Time con un time miembro. Time.time da mí el tiempo desde mi aplicación comenzó en segundos (valor de coma flotante). Ahora quiero crear un valor pulsante entre 0 y 1 y luego de 1 a 0 de nuevo, que continúa haciendo adelgaza hasta las paradas de la aplicación.

Yo estaba pensando usar sin (), pero no sé lo que pase a ella como parametros para crear este valor pulsante.

¿Cómo puedo crear este valor pulsante?

Saludos cordiales, Pollux

Answer 1

Usted menciona el uso sin (), así que supongo que usted quiere que el pulso de forma continua entre 0 y 1.

Algo como esto va a hacer:

float pulse(float time) {
    const float pi = 3.14;
    const float frequency = 10; // Frequency in Hz
    return 0.5*(1+sin(2 * pi * frequency * time));
}

1/frequency = 0.1 second es el período, que es el tiempo entre 1'S.

Answer 2

¿Qué hay de x = 1 - x? O si usted quiere que sea su uso basado en el tiempo del temporizador 2%

Oh, quería que los valores entre 0 y 1 también. cómo sobre Math.Abs ??(100 - (Timer% 200)) / 100 Cuando el temporizador es algo así como DateTime.Now.TimeOfDay.TotalMilliseconds

Editar Mis pruebas indican que esto es más del doble de rápido que el método de pecado. Para 1 millón de iteraciones, el método pecado toma .048 segundos mientras que el método Abs toma alrededor de .023 segundos. Además, se obtiene diferentes formas de onda fuera de los dos, por supuesto. Sin produce una onda sinusoidal, mientras que Abs produce una onda triangular.

static void Main(string[] args)
{
   System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
   sw.Start();
   const int count = 1000000;
   float[] results = new float[count];
   for (int i = 0; i < count; i++)
   {
      results[i] = AbsPulse(i/1000000F);
      //results[i] = SinPulse(i / 1000000F);
   }
   sw.Stop();
   Console.WriteLine("Time Elapsed: {0} seconds", sw.Elapsed.TotalSeconds);
   char[,] graph = new char[80, 20];
   for (int y = 0; y <= graph.GetUpperBound(1); y++)
      for (int x = 0; x <= graph.GetUpperBound(0); x++)
         graph[x, y] = ' ';
   for (int x = 0; x < count; x++)
   {
      int col = x * 80 / count;
      graph[col, (int)(results[x] * graph.GetUpperBound(1))] = 'o';
   }
   for (int y = 0; y <= graph.GetUpperBound(1); y++)
   {
      for (int x = 0; x < graph.GetUpperBound(0); x++)
         Console.Write(graph[x, y]);
      Console.WriteLine();
   }
}

static float AbsPulse(float time)
{
   const int frequency = 10; // Frequency in Hz
   const int resolution = 1000; // How many steps are there between 0 and 1
   return Math.Abs(resolution - ((int)(time * frequency * 2 * resolution) % (resolution * 2))) / (float)resolution;
}

static float SinPulse(float time)
{
   const float pi = 3.14F;
   const float frequency = 10; // Frequency in Hz
   return 0.5F * (1 + (float)Math.Sin(2 * pi * frequency * time));
}

Answer 3

Una función seno sería ideal que pienso, pero hay que ajustar el período y la escala.

La función seno produce resultados entre -1 y 1, pero desea ir entre 0 y 1. Para escalar correctamente desea (sin(x)+1)/2.

la función seno comienza en cero, va a 1 en pi / 2, el cero de nuevo en pi, -1 a 3 * pi / 2, y de nuevo a cero en 2 * pi. Escalado, el primer cero sucederá en 3 pi * / 2 y el primer máximo después de que estará en 5/2 * pi. Así x en la fórmula anterior es (2*time + 3) * pi/2.

Poniendo todo junto: (sin((2*time.time + 3) * pi/2) + 1) / 2

Answer 4

¿Con qué frecuencia desea que el pulso?

Vamos a decir que quiere ir de 0 a 1 más de 10 segundos.

float pulseValueForTime(int sec) {
    int pulsePoint = sec % 10;
    float pulsePercent = (float)pulsePoint / (float)10;
    float pulseInTermsOfPI = (pulsePercent * 2 * PI) - PI;
    float sinVal = MagicalSinFunction(pulseInTermsOfPI); // what framework you use to compute sin is up to you... I'm sure you can google that!
    return (sinVal + 1) / 2; // sin is between 1 and -1, translate to between 0 and 1
}

Answer 5

Mira en funciones facilidad. Que hacen este tipo de cosas en todo tipo de maneras -. Lineales, poli, exp, sin, etc.