Vector
using Autodesk.DesignScript.Interfaces;
using Autodesk.DesignScript.Runtime;
using ProtoGeometryGenerator;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Autodesk.DesignScript.Geometry
{
[GenerateFromInterface(typeof(IVectorEntity), typeof(IGeometryFactory), new Type[] {
})]
public class Vector : DesignScriptEntity
{
internal IVectorEntity VectorEntity => HostImpl as IVectorEntity;
[Scaling()]
public double X {
get {
return VectorEntity.get_X() * DesignScriptEntity.scaleFactor;
}
}
[Scaling()]
public double Y {
get {
return VectorEntity.get_Y() * DesignScriptEntity.scaleFactor;
}
}
[Scaling()]
public double Z {
get {
return VectorEntity.get_Z() * DesignScriptEntity.scaleFactor;
}
}
[Scaling()]
public double Length {
get {
return VectorEntity.get_Length() * DesignScriptEntity.scaleFactor;
}
}
internal static IVectorEntity Unwrap(Vector o)
{
return o?.VectorEntity;
}
[SupressImportIntoVM]
[GenerateShadowing("FromJson", new Type[] {
typeof(string),
typeof(double)
})]
public static Vector FromJson(string json)
{
return Wrap(HostFactory.Factory.VectorFromJson(json, DesignScriptEntity.scaleFactor));
}
[SupressImportIntoVM]
public string ToJson()
{
return HostImpl.ToJson(DesignScriptEntity.scaleFactor);
}
internal Vector(IVectorEntity host)
: base(host)
{
}
public Point AsPoint()
{
return Point.Wrap(VectorEntity.AsPoint());
}
public Vector Reverse()
{
return Wrap(VectorEntity.Reverse());
}
public Vector Add(Vector vectorToAdd)
{
return Wrap(VectorEntity.Add(Unwrap(vectorToAdd)));
}
public Vector Subtract(Vector vectorToSubtract)
{
return Wrap(VectorEntity.Subtract(Unwrap(vectorToSubtract)));
}
[Scaling()]
public Vector Cross(Vector cross)
{
return Wrap(VectorEntity.Cross(Unwrap(cross))).Scale(DesignScriptEntity.scaleFactor);
}
[Scaling()]
public double Dot(Vector vec)
{
return VectorEntity.Dot(Unwrap(vec)) * Math.Pow(DesignScriptEntity.scaleFactor, 2);
}
[Scaling()]
public Vector Normalized()
{
return Wrap(VectorEntity.Normalized()).Scale(1 / DesignScriptEntity.scaleFactor);
}
public bool IsParallel(Vector otherVector)
{
return VectorEntity.IsParallel(Unwrap(otherVector));
}
public bool IsAlmostEqualTo(Vector otherVector)
{
return VectorEntity.IsAlmostEqualTo(Unwrap(otherVector));
}
public Vector Transform(CoordinateSystem coordinateSystem)
{
return Wrap(VectorEntity.Transform(CoordinateSystem.Unwrap(coordinateSystem)));
}
public Vector Rotate(Vector axis, double degrees = 0)
{
return Wrap(VectorEntity.Rotate(Unwrap(axis), degrees));
}
public Vector Rotate(Plane plane, double degrees = 0)
{
return Wrap(VectorEntity.Rotate(Plane.Unwrap(plane), degrees));
}
public Vector Scale(double scale_factor = 1)
{
return Wrap(VectorEntity.Scale(scale_factor));
}
public Vector Scale(double xScaleFactor = 1, double yScaleFactor = 1, double zScaleFactor = 1)
{
return Wrap(VectorEntity.Scale(xScaleFactor, yScaleFactor, zScaleFactor));
}
public double AngleWithVector(Vector otherVector)
{
return VectorEntity.AngleWithVector(Unwrap(otherVector));
}
public double AngleAboutAxis(Vector otherVector, Vector rotationAxis)
{
return VectorEntity.AngleAboutAxis(Unwrap(otherVector), Unwrap(rotationAxis));
}
public static Vector ByCoordinates([Scaling()] double x = 0, [Scaling()] double y = 0, [Scaling()] double z = 0)
{
DesignScriptEntity.CheckArgsForAsmExtents(x, y, z);
return Wrap(HostFactory.Factory.VectorByCoordinates(x / DesignScriptEntity.scaleFactor, y / DesignScriptEntity.scaleFactor, z / DesignScriptEntity.scaleFactor));
}
public static Vector ByCoordinates([Scaling()] double x = 0, [Scaling()] double y = 0, [Scaling()] double z = 0, bool normalized = false)
{
DesignScriptEntity.CheckArgsForAsmExtents(x, y, z);
return Wrap(HostFactory.Factory.VectorByCoordinates(x / DesignScriptEntity.scaleFactor, y / DesignScriptEntity.scaleFactor, z / DesignScriptEntity.scaleFactor, normalized));
}
public static Vector ByTwoPoints(Point start, Point end)
{
return Wrap(HostFactory.Factory.VectorByTwoPoints(Point.Unwrap(start), Point.Unwrap(end)));
}
[Scaling()]
public static Vector XAxis()
{
return Wrap(HostFactory.Factory.VectorXAxis()).Scale(1 / DesignScriptEntity.scaleFactor);
}
[Scaling()]
public static Vector YAxis()
{
return Wrap(HostFactory.Factory.VectorYAxis()).Scale(1 / DesignScriptEntity.scaleFactor);
}
[Scaling()]
public static Vector ZAxis()
{
return Wrap(HostFactory.Factory.VectorZAxis()).Scale(1 / DesignScriptEntity.scaleFactor);
}
internal static Vector Wrap(IVectorEntity host)
{
if (host != null)
return new Vector(host);
return null;
}
internal static Vector[] Wrap(IVectorEntity[] hosts)
{
return hosts.Select(Wrap).ToArray();
}
internal static Vector[][] Wrap(IVectorEntity[][] hosts)
{
return hosts.Select(Wrap).ToArray();
}
internal static IVectorEntity[] Unwrap(IEnumerable<Vector> o)
{
return o.Select(Unwrap).ToArray();
}
internal static IVectorEntity[] Unwrap(Vector[] o)
{
return o.Select(Unwrap).ToArray();
}
internal static IVectorEntity[][] Unwrap(Vector[][] o)
{
return o.Select(Unwrap).ToArray();
}
protected override bool Equals(DesignScriptEntity other)
{
if (base.Equals(other))
return true;
Vector vector = other as Vector;
if (vector != null) {
double num = X;
if (num.Equals(vector.X)) {
num = Y;
if (num.Equals(vector.Y)) {
num = Z;
return num.Equals(vector.Z);
}
}
}
return false;
}
protected override int ComputeHashCode()
{
return HashCode.Combine(X, Y, Z);
}
public override string ToString()
{
StringBuilder builder = DesignScriptEntity.GetBuilder();
AppendTo(builder);
return builder.ToString();
}
internal override void AppendTo(StringBuilder builder)
{
builder.Add("Vector(X = ", X).Add(", Y = ", Y).Add(", Z = ", Z)
.Add(", Length = ", Length)
.Append(")");
}
}
}