// copied from sheet -- not correct public override void calcAxis() { if (axisA != null) return ; axisA = new Point3f(); if (lowerNeighborIsHelixOrSheet()) apolymer.getLeadMidPoint(monomerIndex, axisA); else apolymer.getLeadMidPoint(monomerIndex + 1, axisA); axisB = new Point3f(); if (upperNeighborIsHelixOrSheet()) apolymer.getLeadMidPoint(monomerIndex + monomerCount, axisB); else apolymer.getLeadMidPoint(monomerIndex + monomerCount - 1, axisB); axisUnitVector = new Vector3f(); axisUnitVector.sub(axisB, axisA); axisUnitVector.normalize(); Point3f tempA = new Point3f(); apolymer.getLeadMidPoint(monomerIndex, tempA); projectOntoAxis(tempA); Point3f tempB = new Point3f(); apolymer.getLeadMidPoint(monomerIndex + monomerCount, tempB); projectOntoAxis(tempB); axisA = tempA; axisB = tempB; }
public virtual void calc1Screen(Point3f center, Vector3f vector, short mad, float offsetFraction, Point3i screen) { pointT.set_Renamed(vector); float scale = mad * offsetFraction; pointT.scaleAdd(scale, center); //viewer.transformPoint(pointT, screen); }
public virtual Point3i[] calcScreens(Point3f[] centers, Vector3f[] vectors, short[] mads, float offsetFraction) { // this basically does object->screen transformation?? Point3i[] screens = new Point3i[centers.Length];// viewer.allocTempScreens(centers.Length); if (offsetFraction == 0) { for (int i = centers.Length; --i >= 0; ) screens[i] = new Point3i((int)centers[i].x, (int)centers[i].y, (int)centers[i].z); //viewer.transformPoint(centers[i], screens[i]); } else { offsetFraction /= 1000; for (int i = centers.Length; --i >= 0; ) { pointT.set_Renamed(vectors[i]); float scale = mads[i] * offsetFraction; pointT.scaleAdd(scale, centers[i]); //if (float.IsNaN(pointT.x)) //{ // System.Console.Out.WriteLine(" vectors[" + i + "]=" + vectors[i] + " centers[" + i + "]=" + centers[i] + " mads[" + i + "]=" + mads[i] + " scale=" + scale + " --> " + pointT); //} //viewer.transformPoint(pointT, screens[i]); screens[i] = new Point3i((int)pointT.x, (int)pointT.y, (int)pointT.z); } } return screens; }
public override void calcAxis() { if (axisA != null) return ; if (monomerCount == 2) { axisA = aminoPolymer.getLeadPoint(monomerIndex); axisB = aminoPolymer.getLeadPoint(monomerIndex + 1); } else { axisA = new Point3f(); aminoPolymer.getLeadMidPoint(monomerIndex + 1, axisA); axisB = new Point3f(); aminoPolymer.getLeadMidPoint(monomerIndex + monomerCount - 1, axisB); } axisUnitVector = new Vector3f(); axisUnitVector.sub(axisB, axisA); axisUnitVector.normalize(); Point3f tempA = new Point3f(); aminoPolymer.getLeadMidPoint(monomerIndex, tempA); if (!lowerNeighborIsHelixOrSheet()) projectOntoAxis(tempA); Point3f tempB = new Point3f(); aminoPolymer.getLeadMidPoint(monomerIndex + monomerCount, tempB); if (!upperNeighborIsHelixOrSheet()) projectOntoAxis(tempB); axisA = tempA; axisB = tempB; }
public virtual void render1Chain(int monomerCount, Monomer[] monomers, Point3f[] centers, Vector3f[] vectors, short[] mads, short[] colixes) { Point3i[] ribbonTopScreens; Point3i[] ribbonBottomScreens; ribbonTopScreens = calcScreens(centers, vectors, mads, isNucleic?1f:0.5f); ribbonBottomScreens = calcScreens(centers, vectors, mads, isNucleic?0f:- 0.5f); render2Strand(monomerCount, monomers, mads, colixes, ribbonTopScreens, ribbonBottomScreens); //viewer.freeTempScreens(ribbonTopScreens); //viewer.freeTempScreens(ribbonBottomScreens); }
public virtual Point3i[] calcScreens(Point3f[] centers, Vector3f[] vectors, short[] mads, float offsetFraction) { int count = centers.Length; Point3i[] screens = new Point3i[count];// null;// viewer.allocTempScreens(count); if (offsetFraction == 0) { for (int i = count; --i >= 0; ) screens[i] = new Point3i((int)centers[i].x, (int)centers[i].y, (int)centers[i].z); // viewer.transformPoint(centers[i], screens[i]); } else { for (int i = count; --i >= 0; ) { pointT.set_Renamed(vectors[i]); //boolean isSpecial = isSpecials[i]; short mad = mads[i]; /* if (isSpecial && !lastWasSpecial) mad *= 2; */ /* short mad = isSpecial || i == 0 ? mads[i] : mads[i - 1]; if (i + 1 < count && isSpecial) { if (isSpecial && ! isSpecials[i + 1]) mad = mads[i]; } */ float scale = mad * offsetFraction; pointT.scaleAdd(scale, centers[i]); screens[i] = new Point3i((int)pointT.x, (int)pointT.y, (int)pointT.z); //viewer.transformPoint(pointT, screens[i]); } } return screens; }
public float getAngle(int atomIndexA, int atomIndexB, int atomIndexC) { if (vectorBA == null) { vectorBA = new Vector3f(); vectorBC = new Vector3f(); } Point3f pointA = atoms[atomIndexA].point3f; Point3f pointB = atoms[atomIndexB].point3f; Point3f pointC = atoms[atomIndexC].point3f; vectorBA.sub(pointA, pointB); vectorBC.sub(pointC, pointB); float angle = vectorBA.angle(vectorBC); float degrees = toDegrees(angle); return degrees; }
/// <summary> Constructs and initializes an AxisAngle4f from the specified /// axis and angle. /// </summary> /// <param name="axis">the axis /// </param> /// <param name="angle">the angle of rotation in radians /// /// </param> /// <since> Java 3D 1.2 /// </since> public AxisAngle4f(Vector3f axis, float angle) { this.x = axis.x; this.y = axis.y; this.z = axis.z; this.angle = angle; }
/// <summary> Sets the value of this AxisAngle4f to the specified /// axis and angle. /// </summary> /// <param name="axis">the axis /// </param> /// <param name="angle">the angle of rotation in radians /// /// </param> /// <since> Java 3D 1.2 /// </since> public void set_Renamed(Vector3f axis, float angle) { this.x = axis.x; this.y = axis.y; this.z = axis.z; this.angle = angle; }
/// <summary> Returns the angle in radians between this vector and /// the vector parameter; the return value is constrained to the /// range [0,PI]. /// </summary> /// <param name="v1"> the other vector /// </param> /// <returns> the angle in radians in the range [0,PI] /// </returns> public float angle(Vector3f v1) { // return (double)Math.acos(dot(v1)/v1.length()/v.length()); // Numerically, near 0 and PI are very bad condition for acos. // In 3-space, |atan2(sin,cos)| is much stable. double xx = y * v1.z - z * v1.y; double yy = z * v1.x - x * v1.z; double zz = x * v1.y - y * v1.x; double cross = System.Math.Sqrt(xx * xx + yy * yy + zz * zz); //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" return (float) System.Math.Abs(System.Math.Atan2(cross, dot(v1))); }
/// <summary> Constructs and initializes a Vector3f from the specified Vector3f.</summary> /// <param name="v1">the Vector3f containing the initialization x y z data /// </param> public Vector3f(Vector3f v1):base(v1) { }
public Point3i transformPoint(Point3f pointAngstroms, Vector3f vibrationVector) { return null;// transformManager.transformPoint(pointAngstroms, vibrationVector); }
/// <summary> Modifies the translational components of this matrix to the values of /// the Vector3f argument; the other values of this matrix are not modified. /// </summary> /// <param name="trans">the translational component /// </param> public virtual void setTranslation(Vector3f trans) { m03 = trans.x; m13 = trans.y; m23 = trans.z; }
/// <summary> Retrieves the translational components of this matrix.</summary> /// <param name="trans">the vector that will receive the translational component /// </param> public void get_Renamed(Vector3f trans) { trans.x = m03; trans.y = m13; trans.z = m23; }
public void transformVector(Vector3f vectorAngstroms, Vector3f vectorTransformed) { //transformManager.transformVector(vectorAngstroms, vectorTransformed); }
/// <summary> Constructs and initializes a Matrix4f from the rotation matrix, /// translation, and scale values; the scale is applied only to the /// rotational components of the matrix (upper 3x3) and not to the /// translational components. /// </summary> /// <param name="m1"> The rotation matrix representing the rotational components /// </param> /// <param name="t1"> The translational components of the matrix /// </param> /// <param name="s"> The scale value applied to the rotational components /// </param> public Matrix4f(Matrix3f m1, Vector3f t1, float s) { set_Renamed(m1); mulRotationScale(s); setTranslation(t1); m33 = 1.0f; }
/// <summary> Performs an SVD normalization of this matrix to calculate the rotation /// as a 3x3 matrix, the translation, and the scale. None of the matrix values are modified. /// </summary> /// <param name="m1">The normalized matrix representing the rotation /// </param> /// <param name="t1">The translation component /// </param> /// <returns> The scale component of this transform /// </returns> public float get_Renamed(Matrix3f m1, Vector3f t1) { get_Renamed(t1); return SVD(m1, null); }
/// <summary> Constructs and initializes a Matrix4f from the quaternion, /// translation, and scale values; the scale is applied only to the /// rotational components of the matrix (upper 3x3) and not to the /// translational components. /// </summary> /// <param name="q1"> The quaternion value representing the rotational component /// </param> /// <param name="t1"> The translational component of the matrix /// </param> /// <param name="s"> The scale value applied to the rotational components /// </param> public Matrix4f(Quat4f q1, Vector3f t1, float s) { set_Renamed(q1, t1, s); }
/// <summary> Transforms the normal parameter by this transform and places the value /// back into normal. The fourth element of the normal is assumed to be zero. /// </summary> /// <param name="normal">the input normal to be transformed. /// </param> public void transform(Vector3f normal) { transform(normal, normal); }
/// <summary> Transforms the normal parameter by this Matrix4f and places the value /// into normalOut. The fourth element of the normal is assumed to be zero. /// </summary> /// <param name="normal">the input normal to be transformed. /// </param> /// <param name="normalOut">the transformed normal /// </param> public void transform(Vector3f normal, Vector3f normalOut) { normalOut.set_Renamed(m00 * normal.x + m01 * normal.y + m02 * normal.z, m10 * normal.x + m11 * normal.y + m12 * normal.z, m20 * normal.x + m21 * normal.y + m22 * normal.z); }
/// <summary> Sets the value of this matrix to a scale and translation matrix; /// the translation is scaled by the scale factor and all of the /// matrix values are modified. /// </summary> /// <param name="v1">the translation amount /// </param> /// <param name="scale">the scale factor for the matrix /// </param> public void set_Renamed(Vector3f v1, float scale) { m00 = scale; m01 = 0.0f; m02 = 0.0f; m03 = scale * v1.x; m10 = 0.0f; m11 = scale; m12 = 0.0f; m13 = scale * v1.y; m20 = 0.0f; m21 = 0.0f; m22 = scale; m23 = scale * v1.z; m30 = 0.0f; m31 = 0.0f; m32 = 0.0f; m33 = 1.0f; }
/// <summary> Sets the value of this matrix to a translate matrix by the /// passed translation value. /// </summary> /// <param name="v1">the translation amount /// </param> public void set_Renamed(Vector3f v1) { setIdentity(); setTranslation(v1); }
/// <summary> Sets the value of this matrix to a scale and translation matrix; /// scale is not applied to the translation and all of the matrix /// values are modified. /// </summary> /// <param name="scale">the scale factor for the matrix /// </param> /// <param name="v1">the translation amount /// </param> public void set_Renamed(float scale, Vector3f v1) { set_Renamed(scale); setTranslation(v1); }
/// <summary> Sets the value of this vector to the normalization of vector v1.</summary> /// <param name="v1">the un-normalized vector /// </param> public void normalize(Vector3f v1) { set_Renamed(v1); normalize(); }
public void transformPoint(Point3f pointAngstroms, Vector3f vibrationVector, Point3i pointScreen) { //transformManager.transformPoint(pointAngstroms, vibrationVector, pointScreen); }
/// <summary> Sets the value of this matrix from the rotation expressed by the /// rotation matrix m1, the translation t1, and the scale s. The translation /// is not modified by the scale. /// </summary> /// <param name="m1">The rotation component /// </param> /// <param name="t1">The translation component /// </param> /// <param name="scale">The scale component /// </param> public void set_Renamed(Matrix3f m1, Vector3f t1, float scale) { setRotationScale(m1); mulRotationScale(scale); setTranslation(t1); m33 = 1.0f; }
/// <summary> Sets this vector to be the vector cross product of vectors v1 and v2.</summary> /// <param name="v1">the first vector /// </param> /// <param name="v2">the second vector /// </param> public void cross(Vector3f v1, Vector3f v2) { // store in tmp once for aliasing-safty // i.e. safe when a.cross(a, b) set_Renamed(v1.y * v2.z - v1.z * v2.y, v1.z * v2.x - v1.x * v2.z, v1.x * v2.y - v1.y * v2.x); }
/// <summary> Sets the value of this matrix from the rotation expressed by the /// quaternion q1, the translation t1, and the scale s. /// </summary> /// <param name="q1"> the rotation expressed as a quaternion /// </param> /// <param name="t1"> the translation /// </param> /// <param name="s"> the scale value /// </param> public void set_Renamed(Quat4f q1, Vector3f t1, float s) { set_Renamed(q1); mulRotationScale(s); m03 = t1.x; m13 = t1.y; m23 = t1.z; }
public virtual void calcSheetUnitVectors() { if (widthUnitVector == null) { Vector3f vectorCO = new Vector3f(); Vector3f vectorCOSum = new Vector3f(); AminoMonomer amino = (AminoMonomer) aminoPolymer.monomers[monomerIndex]; vectorCOSum.sub(amino.CarbonylOxygenAtomPoint, amino.CarbonylCarbonAtomPoint); for (int i = monomerCount; --i > 0; ) { amino = (AminoMonomer) aminoPolymer.monomers[i]; vectorCO.sub(amino.CarbonylOxygenAtomPoint, amino.CarbonylCarbonAtomPoint); //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" if (vectorCOSum.angle(vectorCO) < (float) System.Math.PI / 2) vectorCOSum.add(vectorCO); else vectorCOSum.sub(vectorCO); } heightUnitVector = vectorCO; // just reuse the same temp vector; heightUnitVector.cross(axisUnitVector, vectorCOSum); heightUnitVector.normalize(); widthUnitVector = vectorCOSum; widthUnitVector.cross(axisUnitVector, heightUnitVector); } }
/// <summary> Computes the dot product of the this vector and vector v1.</summary> /// <param name="v1">the other vector /// </param> public float dot(Vector3f v1) { return x * v1.x + y * v1.y + z * v1.z; }