NetFabric.Angle

NetFabric.Ángulo

Implementa una estructura que representa un ángulo.

El ángulo se almacena en la memoria en la unidad de medida del ángulo en la que se definió originalmente, con doble precisión, lo que permite un control preciso sobre las conversiones y reduce los errores de redondeo. Todas las operaciones están fuertemente tipadas.

Incluye operaciones de ángulos como lerp, reducción, ángulo de referencia, comparación, clasificación y trigonometría.

Uso:

Agregando a tu proyecto

NetFabric.Angle está disponible como paquete NuGet y como paquete Unity.

Creación del ángulo:

Utilice los métodos para las unidades de medida con las que está trabajando:

 var right0 = Angle . FromRadian ( Math . PI / 2.0 ) ;
var right1 = Angle . FromDegrees ( 90.0 ) ;
var right3 = Angle . FromGradian ( 100.0 ) ;

Cuando se utiliza el formato DMS, los minutos de arco y los segundos de arco deben ser valores en el intervalo [0,0, 60,0[

 var right3 = Angle . FromDegrees ( 90 , 59.9 ) ; // degrees and arcminutes
var right4 = Angle . FromDegrees ( - 90 , 59 , 59.9 ) ; // degrees, arcminutes and arcseconds

Puedes utilizar los ángulos predefinidos en cualquier unidad de medida:

 var zero = AngleDegrees . Zero ;          // 0 degrees
var right = AngleDegrees . Right ;        // 90 degrees
var straight = AngleDegrees . Straight ;  // 180 degrees
var full = AngleDegrees . Full ;          // 360 degrees 

 var zero = AngleRadians . Zero ;          // 0 radians
var right = AngleRadians . Right ;        // PI/2 radians
var straight = AngleRadians . Straight ;  // PI radians
var full = AngleRadians . Full ;          // 2 * PI radians

Convirtiendo el ángulo:

Utilice los métodos static para convertir cualquier ángulo:

 var radians = Angle . ToRadians ( angle ) ;

Los ángulos están fuertemente tipados para que sepa desde qué unidad de medida se está convirtiendo.

Nota: Si es necesario, los resultados deben reducirse explícitamente.

Leyendo el ángulo:

Utilice la propiedad que lleva el nombre de la unidad de medida (para ser explícito):

 var radians = angleRadians . Radians ;
var degrees = angleDegrees . Degrees ;
var gradians = angleGradians . Gradians ;

Un ángulo en grados se puede deconstruir en notación DMS. Esto se puede hacer usando cualquiera de los argumentos:

 int degrees0 ;
double minute0 ;
angleDegrees . Deconstruct ( out degrees0 , out minutes0 ) ;

int degrees1 ;
int minute1 ;
double seconds1 ;
angleDegrees . Deconstruct ( out degrees1 , out minutes1 , out seconds1 ) ;

sacar argumentos con sintaxis de C# 7:

 angleDegrees . Deconstruct ( out var degrees0 , out var minutes0 ) ;
angleDegrees . Deconstruct ( out var degrees1 , out var minutes1 , out var seconds1 ) ;

o usando deconstructores de C# 7:

 var ( degrees0 , minutes0 ) = angleDegrees ;
var ( degrees1 , minutes1 , seconds1 ) = angleDegrees ;

Reducción y referencia

El ángulo se puede reducir a un ángulo coterminal en el rango [0,0, 360,0[ grados: ​

 var angle = Angle . Reduce ( AngleDegrees . Right + AngleDegrees . Full ) ; // result is AngleDegrees.Right

Obteniendo el ángulo de referencia (el ángulo más pequeño con el eje x):

 var angle = Angle . GetReference ( AngleDegrees . Right + AngleDegrees . FromDegrees ( 45.0 ) ) ; // result is an angle with 45 degrees

Operaciones matemáticas

Se definen operadores matemáticos que permiten cálculos con ángulos. ​

 var angle0 = - AngleDegrees . Right ;
var angle1 = AngleDegrees . Straight + Angle . FromDegrees ( 45.0 ) ;
var angle2 = 2.0 * Angle . FromDegrees ( 30.0 ) ;
var angle3 = Angle . FromDegrees ( 30.0 ) / 2.0 ;

Nota: Si es necesario, los resultados deben reducirse explícitamente.

También se definen métodos equivalentes para que puedan usarse en idiomas que no admiten operadores.

 var angle0 = Angle . Negate ( AngleDegrees . Right ) ;
var angle1 = Angle . Add ( AngleDegrees . Straight , Angle . FromDegrees ( 45.0 ) ) ;
var angle2 = Angle . Multiply ( 2.0 , Angle . FromDegrees ( 30.0 ) ) ;
var angle3 = Angle . Divide ( Angle . FromDegrees ( 30.0 ) , 2.0 ) ;

Comparación

Los operadores de comparación se pueden utilizar para comparar dos ángulos:

 if ( angle0 > angle1 || angle0 == angle2 ) {
    .. .
}

Para idiomas que no admiten operadores, utilice el método estático Compare(): ​

 if ( Angle . Compare ( angle0 , angle1 ) <= 0 ) { // less or equal to
    .. .
}

Por motivos de rendimiento, los valores comparados no se reducen. Si es necesario, deberán reducirse explícitamente: ​

 if ( Angle . Reduce ( angle0 ) > Angle . Reduce ( angle1 ) ) {
    .. .
}

o utilice el método estático CompareReduced():

 if ( Angle . CompareReduced ( angle0 , angle1 ) > 0 ) {
    .. .
}

Trigonometría

Las operaciones trigonométricas habituales (sin, cos, tan, asin, acos, atan, sinh y cosh) están disponibles como métodos estáticos pero sólo para ángulos en radianes:

 double value0 = Angle . Sin ( angleRadians ) ;
AngleRadians angle0 = Angle . Asin ( value0 ) ;

Los ángulos que no están en radianes deben convertirse:

 double value1 = Angle . Sin ( Angle . ToRadians ( angleDegrees ) ) ;
AngleDegrees angle1 = Angle . ToDegrees ( Angle . Asin ( value1 ) ) ;

Clasificación

Puedes obtener el cuadrante del ángulo.

 var quad0 = Angle . GetQuadrant ( Angle . FromDegrees ( 45.0 ) ) ; // Angle.Quadrant.First
var quad1 = Angle . GetQuadrant ( Angle . FromDegrees ( 220.0 ) ) ; // Angle.Quadrant.Third
var quad2 = Angle . GetQuadrant ( Angle . FromDegrees ( - 45.0 ) ) ; // Angle.Quadrant.Fourth

y podemos comprobar si un ángulo es agudo, recto, obtuso, recto o reflejo:

 var isAcute = Angle . IsAcute ( AngleDegrees . Right ) ; // false
var isAcute = Angle . IsAcute ( Angle . FromDegrees ( 45.0 ) ) ; // true
var isRight = Angle . IsRight ( AngleDegrees . Right ) ; // true

La clasificación considera el equivalente positivo reducido del ángulo así:

 var isAcute = Angle . IsAcute ( Angle . FromDegrees ( 45.0 ) ) ; // true
var isAcute = Angle . IsAcute ( Angle . FromDegrees ( - 45.0 ) ) ; // true
var isAcute = Angle . IsAcute ( Angle . FromDegrees ( 315.0 ) ) ; // false