/// <summary>
/// Gets the control point at the given (u, v) index.
/// </summary>
/// <param name="u">Index of control-point along surface U direction.</param>
/// <param name="v">Index of control-point along surface V direction.</param>
/// <returns>The control point at the given (u, v) index.</returns>
public ControlPoint GetControlPoint(int u, int v)
{
if (u < 0)
{
throw new IndexOutOfRangeException("u must be larger than or equal to zero.");
}
if (v < 0)
{
throw new IndexOutOfRangeException("v must be larger than or equal to zero.");
}
if (u >= CountU)
{
throw new IndexOutOfRangeException("u must be less than CountU.");
}
if (v >= CountV)
{
throw new IndexOutOfRangeException("v must be less than CountV.");
}
Point4d pt = new Point4d();
IntPtr ptr = m_surface.ConstPointer();
if (UnsafeNativeMethods.ON_NurbsSurface_GetCV(ptr, u, v, ref pt))
{
return(new ControlPoint(pt));
}
return(ControlPoint.Unset);
}
public static Matrix4d buildReflection(Point4d point)
{
float xx = point.x * point.x;
float xy = point.x * point.y;
float xz = point.x * point.z;
float xw = point.x * point.w;
float yy = point.y * point.y;
float yz = point.y * point.z;
float yw = point.y * point.w;
float zz = point.z * point.z;
float zw = point.z * point.w;
float ww = point.w * point.w;
float pp_h = xx + yy + zz - ww;
float temp = -2.0f / pp_h;
Matrix4d ppTI31 = new Matrix4d();
ppTI31.SetRow(0, new Point4d(xx * temp + 1, xy * temp, xz * temp, -xw * temp));
ppTI31.SetRow(1, new Point4d(xy * temp, yy * temp + 1, yz * temp, -yw * temp));
ppTI31.SetRow(2, new Point4d(xz * temp, yz * temp, zz * temp + 1, -zw * temp));
ppTI31.SetRow(3, new Point4d(xw * temp, yw * temp, zw * temp, -ww * temp + 1));
return(ppTI31);
}
public static Point4d GetMidpoint(Point4d pointA, Point4d pointB)
{
float coefficientA = Mathf.Sqrt(MinkowskiInnerProduct(pointB, pointB) * MinkowskiInnerProduct(pointA, pointB));
float coefficientB = Mathf.Sqrt(MinkowskiInnerProduct(pointA, pointA) * MinkowskiInnerProduct(pointA, pointB));
return(new Point4d(pointA.x * coefficientA + pointB.x * coefficientB, pointA.y * coefficientA + pointB.y * coefficientB, pointA.z * coefficientA + pointB.z * coefficientB, pointA.w * coefficientA + pointB.w * coefficientB));
}
public void sub(Point4d t1)
{
this.x = this.x - (t1.x);
this.y = this.y - (t1.y);
this.z = this.z - (t1.z);
this.w = this.w - (t1.w);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
const int degree = 2;
const int cv_count = 7;
const int knot_count = cv_count + degree - 1;
const int order = degree + 1;
var points = new Point3d[cv_count];
points[0] = new Point3d(2.500, 0.000, 0.000);
points[1] = new Point3d(5.000, 0.000, 0.000);
points[2] = new Point3d(3.750, 2.165, 0.000);
points[3] = new Point3d(2.500, 4.330, 0.000);
points[4] = new Point3d(1.250, 2.165, 0.000);
points[5] = new Point3d(0.000, 0.000, 0.000);
points[6] = new Point3d(2.500, 0.000, 0.000);
var weights = new double[cv_count];
weights[0] = 1.0;
weights[1] = 0.5;
weights[2] = 1.0;
weights[3] = 0.5;
weights[4] = 1.0;
weights[5] = 0.5;
weights[6] = 1.0;
var knots = new double[knot_count];
knots[0] = 0.000;
knots[1] = 0.000;
knots[2] = 0.333;
knots[3] = 0.333;
knots[4] = 0.667;
knots[5] = 0.667;
knots[6] = 1.000;
knots[7] = 1.000;
var curve = new NurbsCurve(3, true, order, cv_count);
for (var ci = 0; ci < cv_count; ci++)
{
var cv = new Point4d(points[ci].X * weights[ci], points[ci].Y * weights[ci], points[ci].Z * weights[ci], weights[ci]);
curve.Points.SetPoint(ci, cv);
}
for (var ki = 0; ki < knot_count; ki++)
{
curve.Knots[ki] = knots[ki];
}
if (curve.IsValid)
{
doc.Objects.AddCurve(curve);
doc.Views.Redraw();
}
return(Result.Success);
}
public void CanBe_Created()
{
var pt3 = new Point3d(1, 0, 0);
var pt4 = new Point4d(1, 0, 0, 1);
var pt42 = new Point4d(pt3);
Assert.Equal(pt42, pt4);
}
public static float getThetaByPoint(Point4d p)
{
if (p.y == 0.0f)
{
return(0.0f);
}
return(Mathf.Atan(p.y / p.x));
}
public static float getPhiByPoint(Point4d p)
{
if (p.z == 0.0f)
{
return(0.0f);
}
return(Mathf.Atan(Mathf.Sqrt(p.x * p.x + p.y * p.y) / p.z));
}
public static Vector3 projectAndGetVect3(Point4d p)
{
float tx = p.x / (p.w);
float ty = p.y / (p.w);
float tz = p.z / (p.w);
return(new Vector3(tx, ty, tz));
}
// The usual vector dot product computed from x, y, and z only.
public float vectorDot3(Point4d v1)
{
float tx = this.x * (v1.x);
float ty = this.y * (v1.y);
float tz = this.z * (v1.z);
return(tx + (ty) + (tz));
}
public void CanToggle_IsUnset_OnWeightChange()
{
var pt = new Point4d();
Assert.True(pt.IsUnset);
pt.Weight += 1;
Assert.False(pt.IsUnset);
}
public static void makeUnitVector(Point4d p)
{
float s = p.w * vectorLength(p);
p.x /= s;
p.y /= s;
p.z /= s;
p.w = 1.0f;
}
public static Vector3 projectAndGetVect3FromHypToEuc(Point4d p)
{
Vector3 temp = projectAndGetVect3(p);
temp.x = HyperbolicMath.euclideanDistance(temp.x);
temp.y = HyperbolicMath.euclideanDistance(temp.y);
temp.z = HyperbolicMath.euclideanDistance(temp.z);
return(temp);
}
// Returns the Minkowski inner product of this with y.
public float minkowski(Point4d v)
{
float tx = this.x * (v.x);
float ty = this.y * (v.y);
float tz = this.z * (v.z);
float tw = this.w * (v.w);
return(tx + (ty) + (tz) - (tw));
}
// Euclidean norm of homogeneous coordinates [and equivalent to
// Point4d.distance(new Point4d(0, 0, 0, 0))].
public float vectorLength(Point4d p)
{
float x2 = this.x * this.x;
float y2 = this.y * this.y;
float z2 = this.z * this.z;
float w2 = this.w * this.w;
return(x2 + (y2) + (z2) / Mathf.Sqrt(w2));
}
// this = s*t1 + t2
public void scaleAdd(float s, Point4d t1, Point4d t2)
{
float tx = t1.x * s + (t2.x);
float ty = t1.y * s + (t2.y);
float tz = t1.z * s + (t2.z);
float tw = t1.w * s + (t2.w);
this.x = tx; this.y = ty; this.z = tz; this.w = tw;
}
public void transform(Point4d v)
{
float x = this.matrix4d.m00 * v.x + (this.matrix4d.m01 * v.y) + (this.matrix4d.m02 * v.z) + (this.matrix4d.m03 * v.w);
float y = this.matrix4d.m10 * v.x + (this.matrix4d.m11 * v.y) + (this.matrix4d.m12 * v.z) + (this.matrix4d.m13 * v.w);
float z = this.matrix4d.m20 * v.x + (this.matrix4d.m21 * v.y) + (this.matrix4d.m22 * v.z) + (this.matrix4d.m23 * v.w);
float w = this.matrix4d.m30 * v.x + (this.matrix4d.m31 * v.y) + (this.matrix4d.m32 * v.z) + (this.matrix4d.m33 * v.w);
v.x = x; v.y = y; v.z = z; v.w = w;
}
public void CanCreate_FromPointAndWeight()
{
var pt = new Point3d(1, 0, 1);
const int weight = 1;
var pt4 = new Point4d(pt, weight);
Assert.Equal(pt, pt4.Position);
Assert.Equal(weight, pt4.Weight);
}
public SliceBasedVoxelDataStructure() : base()
{
_positionCache = new Point4d(0, 0, 0, 1);
_indexCache = new Point4d(0, 0, 0, 1);
_slices = new List <DicomSlice>();
GlobalMax = new Voxel()
{
Value = float.MinValue
};
Voxels = new Voxels(this);
}
public void CanBe_Negated()
{
const double a = 3.3;
const double b = 2.2;
const double c = 4.11;
const double d = 1.344;
var ptA = new Point4d(a, b, c, d);
var ptResult = new Point4d(-a, -b, -c, d);
Assert.True(-ptA == ptResult);
}
public void CanBe_Divided()
{
const double a = 3.3;
const double b = 2.2;
const double c = 4.11;
const double d = 1.344;
const double m = 1.45;
var ptA = new Point4d(a, b, c, d);
var ptResult = new Point4d(a / m, b / m, c / m, d / m);
Assert.True(ptA / m == ptResult);
}
public void CanBe_Multiplied()
{
const double a = 3.3;
const double b = 2.2;
const double c = 4.11;
const double d = 1.344;
const double m = 1.45;
var ptA = new Point4d(a, b, c, d);
var ptResult = new Point4d(a * m, b * m, c * m, d * m);
Assert.True(ptA * m == ptResult);
Assert.True(m * ptA == ptResult);
}
public void CanBe_Created()
{
var pt2 = new Point2d(1, 0);
var pt3 = new Point3d(1, 0, 0);
var pt4 = new Point4d(1, 0, 0, 1);
var npt2 = new Point3d(pt2);
var npt4 = new Point3d(pt4);
var npt5 = ( Point3d )pt4;
Assert.True(pt3 == npt2);
Assert.True(pt3 == npt4);
Assert.True(pt3 == npt5);
}
public void CanBe_Added()
{
const double a = 3.3;
const double b = 2.2;
const double c = 4.11;
const double d = 1.344;
var ptA = new Point4d(a, b, c, d);
var ptB = new Point4d(b, c, a, d);
var ptResult = new Point4d(a + b, b + c, c + a, d + d);
Assert.True(ptA + ptB == ptResult);
}
public void CanBe_Added_WithVector()
{
const double a = 3.3;
const double b = 2.2;
const double c = 4.11;
const double d = 1.344;
var ptA = new Point4d(a, b, c, d);
var v = new Vector3d(b, c, a);
var ptResult = new Point4d(a + b, b + c, c + a, d);
Assert.True(ptA + v == ptResult);
}
public static float getRotAngleY(Point4d p)
{
float yAngRot;
if (p.z == 0.0f)
{
yAngRot = 0.0f;
}
else
{
yAngRot = Mathf.Atan(p.x / p.z);
}
return(yAngRot);
}
public void CanBe_Subtracted()
{
const double a = 3.3;
const double b = 2.2;
const double c = 4.11;
const double d = 1.344;
var ptA = new Point4d(a, b, c, d);
var ptB = new Point4d(b, c, a, d);
var expected = new Point4d(a - b, b - c, c - a, d - d);
var actual = ptA - ptB;
Assert.Equal(expected, actual);
}
public static float getRotAngleX(Point4d p)
{
float xAngRot;
if (p.z == 0.0f)
{
xAngRot = 0.0f;
}
else
{
xAngRot = Mathf.Atan(p.y / p.z);
}
return(xAngRot);
}
public static Matrix4d buildCanonicalOrientationEuclidean(Point4d a, Point4d b)
{
Point4d orientation = new Point4d(b.x - a.x, b.y - a.y, b.z - a.z);
//float r = Mathf.Sqrt(orientation.x * orientation.x + orientation.y * orientation.y + orientation.z * orientation.z);
float theta = Mathf.Atan(orientation.y / orientation.x);
float phi = Mathf.Atan(Mathf.Sqrt(orientation.x * orientation.x + orientation.y * orientation.y) / orientation.z);
Matrix4d rotationMat = new Matrix4d();
rotationMat.rotX(theta);
Matrix4d rotationMatResult = new Matrix4d();
rotationMatResult.rotZ(phi);
rotationMatResult *= rotationMat;
return(rotationMatResult); //TODO: implement
}
public Point4d GetControlVertex4d(int index)
{
if (index < 0 || index >= ControlVertexCount)
{
throw new ArgumentOutOfRangeException("index");
}
var rc = new Point4d();
IntPtr const_ptr_this = ConstPointer();
if (!UnsafeNativeMethods.ON_BezierCurve_GetCV4d(const_ptr_this, index, ref rc))
{
return(Point4d.Unset);
}
return(rc);
}
internal static extern bool ON_4dPoint_Normalize(ref Point4d a);
internal static extern bool ON_4dPoint_Equality(Point4d a, Point4d b);
internal static extern bool ON_NurbsSurface_SetCV(IntPtr pNurbsSurface, int u, int v, ref Point4d point);
internal static extern bool ON_NurbsCurve_GetCV2(IntPtr pCurve, int cvIndex, ref Point4d point);
internal static extern bool ON_BezierCurve_GetCV4d(IntPtr pConstBezierCurve, int index, ref Point4d point);
internal static extern IntPtr ON_BezierCurve_New4d(int count, Point4d[] points);
internal static extern void Rdk_ContentField_SetPoint4dValue(IntPtr pField, Point4d v, int iCC);
internal static extern void Rdk_ContentField_Point4dValue(IntPtr pField, ref Point4d p);
internal static extern int Rdk_Variant_Get4dPointValue(IntPtr pV, ref Point4d v);
internal static extern void Rdk_Variant_Set4dPointValue(IntPtr pV, Point4d v);
/// <summary>Get location of a control vertex.</summary>
/// <param name="index">
/// Control vertex index (0 <= index < ControlVertexCount)
/// </param>
/// <returns>
/// Homogenous value of control vertex. If the bezier is not
/// rational, the weight is 1.
/// </returns>
/// <exception cref="ArgumentOutOfRangeException">when index is out of range</exception>
public Point4d GetControlVertex4d(int index)
{
if( index<0 || index>=ControlVertexCount )
throw new ArgumentOutOfRangeException("index");
Point4d rc = new Point4d();
IntPtr pConstThis = ConstPointer();
if (!UnsafeNativeMethods.ON_BezierCurve_GetCV4d(pConstThis, index, ref rc))
return Point4d.Unset;
return rc;
}
