bool ZernikeMom::CalculateOneFrame(int frame){
const double PI = 3.141592654;
// cout << "ZernikeMom::CalculateOneFrame("<<frame<<")"<<endl;
EnsureImage();
SegmentData()->setCurrentFrame(frame);
TabulateFactorials(param.maxorder);
FindSegmentNormalisations();
int nc=NumberOfCoefficients(param.maxorder);
vector<double> zerovec(nc,0.0);
vector<vector<double> > A_real(DataCount(),zerovec);
vector<vector<double> > A_imag(DataCount(),zerovec);
int width = Width(true), height = Height(true);
int resind=0;
for(int n=0;n<=param.maxorder;n++)
for(int m=n&1;m<=n;m+=2){
for (int y=0; y<height; y++)
for (int x=0; x<width; x++){
vector<int> svec = SegmentVector(frame, x, y);
for (size_t j=0; j<svec.size(); j++) {
int dataind = DataIndex(svec[j], true);
if(dataind != -1){
int label=svec[j];
double xtilde=(x-XAvg(label))*Scaling(label);
double ytilde=(y-YAvg(label))*Scaling(label);
double roo=sqrt(xtilde*xtilde+ytilde*ytilde);
double theta;
if(ytilde || xtilde)
theta=atan2(ytilde,xtilde);
else
theta=0;
double r=R(n,m,roo);
r *= Scaling(label)*Scaling(label)*(n+1)/PI;
A_real[dataind][resind] += r*cos(m*theta);
A_imag[dataind][resind] -= r*sin(m*theta);
}
}
}
resind++;
}
for(size_t i=0;i<A_real.size();i++){
((ZernikeMomData*)GetData(i))->SetData(A_real[i],A_imag[i],param);
}
calculated = true;
return true;
}
bool ZernikeMom::CalculateOneLabel(int frame, int label)
{
const double PI = 3.141592654;
EnsureImage();
SegmentData()->setCurrentFrame(frame);
TabulateFactorials(param.maxorder);
FindSegmentNormalisations(label);
int nc=NumberOfCoefficients(param.maxorder);
vector<double> A_real(nc,0.0);
vector<double> A_imag(nc,0.0);
int width = Width(true), height = Height(true);
int resind=0;
for(int n=0;n<=param.maxorder;n++)
for(int m=n&1;m<=n;m+=2){
for (int y=0; y<height; y++)
for (int x=0; x<width; x++){
vector<int> svec = SegmentVector(frame, x, y);
for (size_t j=0; j<svec.size(); j++) {
if(svec[j]==label){
double xtilde=(x-XAvg(label))*Scaling(label);
double ytilde=(y-YAvg(label))*Scaling(label);
double roo=sqrt(xtilde*xtilde+ytilde*ytilde);
double theta;
if(ytilde || xtilde)
theta=atan2(ytilde,xtilde);
else
theta=0;
double r=R(n,m,roo);
r *= Scaling(label)*Scaling(label)*(n+1)/PI;
A_real[resind] += r*cos(m*theta);
A_imag[resind] -= r*sin(m*theta);
}
}
}
resind++;
}
int ind = DataIndex(label, true);
if(ind==-1) return false;
((ZernikeMomData*)GetData(ind))->SetData(A_real,A_imag,param);
calculated = true;
return true;
}
ITG cgsolver (double *A, double *x, double *b, ITG neq, ITG len,
ITG *ia, ITG *iz,
double *eps, ITG *niter, ITG precFlg)
{
ITG i=0;
double *Factor=NULL,*r=NULL,*p=NULL,*z=NULL,*C=NULL,*g=NULL,*rho=NULL;
/* reduce row and column indices by 1 (FORTRAN->C) */
for (i=0; i<neq; i++) --iz[i];
for (i=0; i<len; i++) --ia[i];
/* Scaling the equation system A x + b = 0 */
Factor=NNEW(double,neq);
Scaling(A,b,neq,ia,iz,Factor);
/* SOLVER/PRECONDITIONING TYPE */
/* Conjugate gradient solver without preconditioning */
if (!precFlg)
{
r=NNEW(double,neq);
p=NNEW(double,neq);
z=NNEW(double,neq);
CG(A,x,b,neq,len,ia,iz,eps,niter,r,p,z);
free(r);free(p);free(z);
}
void applyVerticalHintingTransform (float fontSize, Path& path)
{
if (cachedSize != fontSize)
{
cachedSize = fontSize;
cachedScale = Scaling (top, middle, bottom, fontSize);
}
if (bottom < top + 3.0f / fontSize)
return;
Path result;
for (Path::Iterator i (path); i.next();)
{
switch (i.elementType)
{
case Path::Iterator::startNewSubPath: result.startNewSubPath (i.x1, cachedScale.apply (i.y1)); break;
case Path::Iterator::lineTo: result.lineTo (i.x1, cachedScale.apply (i.y1)); break;
case Path::Iterator::quadraticTo: result.quadraticTo (i.x1, cachedScale.apply (i.y1),
i.x2, cachedScale.apply (i.y2)); break;
case Path::Iterator::cubicTo: result.cubicTo (i.x1, cachedScale.apply (i.y1),
i.x2, cachedScale.apply (i.y2),
i.x3, cachedScale.apply (i.y3)); break;
case Path::Iterator::closePath: result.closeSubPath(); break;
default: jassertfalse; break;
}
}
result.swapWithPath (path);
}
// Run a single benchmark for multiplying m x k x n with num_steps of recursion.
// To just call GEMM, set num_steps to zero.
// The median of five trials is printed to std::cout.
// If run_check is true, then it also
void SingleBenchmark(int m, int k, int n, int alg) {
// Run a set number of trials and pick the median time.
int num_trials = 5;
std::vector<double> times(num_trials);
for (int trial = 0; trial < kNumTrials; ++trial) {
Matrix<double> A = RandomMatrix<double>(m, k);
Matrix<double> B = RandomMatrix<double>(k, n);
Matrix<double> C(m, n);
if (alg == CLASSICAL) {
times[trial] = Time([&] { MatMul(A, B, C); });
} else if (alg == STRASSEN) {
times[trial] = Time([&] { strassen::FastMatmul(A, B, C, 1); });
} else if (alg == STRASSEN_SCALED) {
times[trial] = Time([&] {
Matrix<double> A_roi = A;
Matrix<double> B_roi = B;
std::vector<double> r_roi, s_roi;
Scaling(A_roi, B_roi, kNumScalingSteps, r_roi, s_roi, OUTSIDE_INSIDE);
strassen::FastMatmul(A, B, C, 1);
PostProcessScaling(C, r_roi, s_roi);
});
}
}
// Spit out the median time
std::sort(times.begin(), times.end());
size_t ind = num_trials / 2;
std::cout << " " << m << " " << k << " " << n << " "
<< " " << times[ind] << "; ";
}
Matrix4x4 Matrix4x4::TRS(const Vector3 &t, const Quaternion &r, const Vector3 &s)
{
Matrix4x4 mt = Translation(t);
Matrix4x4 mr = Rotation(r);
Matrix4x4 ms = Scaling(s);
return mt * mr * ms;
}
void animateScene(int value) {
glutTimerFunc(REFRESH_MILISECS, animateScene, 0);
static float scale = 1.0f;
VECTOR4D Speed = { 0.02f, 0.02f, 0.02f, 0.0f };
//MATRIX4D P = PerspectiveWidthHeightRH(0.5f, 0.5f, 1.0f, 10.0f);
MATRIX4D InvV = FastInverse(Vi);
VECTOR4D XDir = { InvV.m00, InvV.m10, InvV.m20, 0.0f };
VECTOR4D YDir = { InvV.m01, InvV.m11, InvV.m21, 0.0f };
VECTOR4D ZDir = { InvV.m02, InvV.m12, InvV.m22, 0.0f };
VECTOR4D EyePos = { InvV.m03, InvV.m13, InvV.m23, 1.0f };
P = PerspectiveWidthHeightRH(0.5f, 0.5f, 1.0f, 10.0f);
if (bLeft)
EyePos = EyePos + XDir * Speed;
if (bRight)
EyePos = EyePos - XDir * Speed;
if (bDown)
EyePos = EyePos + YDir * Speed;
if (bUp)
EyePos = EyePos - YDir * Speed;
if (bBackward)
EyePos = EyePos + ZDir * Speed;
if (bForward)
EyePos = EyePos - ZDir * Speed;
InvV.m03 = EyePos.x;
InvV.m13 = EyePos.y;
InvV.m23 = EyePos.z;
Vi = FastInverse(InvV);
if (bRotateX) {
//R = R * RotationX(INCREMENT);
VECTOR4D Axis = {1, 0, 0, 0};
R = R * RotationAxis(INCREMENT, Axis);
}
if (bRotateY) {
//R = R * RotationY(INCREMENT);
VECTOR4D Axis = { 0, 1, 0, 0 };
R = R * RotationAxis(INCREMENT, Axis);
}
if (bRotateZ) {
//R = R * RotationZ(INCREMENT);
VECTOR4D Axis = { 0, 0, 1, 0 };
R = R * RotationAxis(INCREMENT, Axis);
}
if (bScaleUp)
scale += INCREMENT;
if (bScaleDown)
scale -= INCREMENT;
T = (P * Vi) * R * Scaling(scale, scale, scale);
glutPostRedisplay();
}
namespace CGAL {
const Translation TRANSLATION = Translation();
const Rotation ROTATION = Rotation();
const Scaling SCALING = Scaling();
const Reflection REFLECTION = Reflection();
const Identity_transformation IDENTITY = Identity_transformation();
const Origin ORIGIN = Origin();
const Null_vector NULL_VECTOR = Null_vector();
} //namespace CGAL
//===============================================
//処理
//===============================================
//[input]
// なし
//[return]
// なし
//===============================================
void CField::Exec()
{
//::D3DXVec3TransformCoord(&vAxisX, &vAxisX, &m_matRotate);
//::D3DXVec3TransformCoord(&vAxisZ, &vAxisZ, &m_matRotate);
//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_DIR_LEFT) )
//{
// m_vPos -= vAxisX*0.1f;
// //m_Anim += 1.0f;
//}
//
//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_DIR_RIGHT) )
//{
// m_vPos += vAxisX*0.1f;
// //m_Anim += 1.0f;
//}
//
//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_DIR_UP) )
//{
// m_vPos -= vAxisZ * 0.1f;
// //m_vPos.z -= 0.1f;
// //m_Anim += 1.0f;
//}
//
//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_DIR_DOWN) )
//{
// m_vPos += vAxisZ * 0.1f;
// //m_vPos.z += 0.1f;
// //m_Anim += 1.0f;
//}
//if(CJoyPad::GetState(0, PAD_STATE_HOLD, PAD_BUTTON_02) )
//{
// m_vRot.x += 0.1f;
//}
// Update(0.000f);
Translation(m_vPos.x, m_vPos.y, m_vPos.z);
Scaling(m_vScale.x, m_vScale.y, m_vScale.z);
Heading(m_vRot.x);
Pitching(m_vRot.x);
Rolling(m_vRot.x);
Render(Joker::GetDevice());
SetWorldMatrix();
}
static void
Prologue()
{
if (eflag) {
floatish epsfscale = epsfwidth / (floatish) borderwidth;
EPSFSpecialComments(epsfscale);
Scaling(epsfscale);
} else {
StandardSpecialComments();
if (gflag) Portrait(); else Landscape();
}
}
int main(){
Macro();
int n;for (scanf("%d", &n); n; n--) {
char c; Point_3 p;
scanf("\n%c%lf%lf%lf", &c, &p.x, &p.y, &p.z);
if (c == 'T') Translation(p); if (c == 'S') Scaling(p);
if (c == 'R') { double r;scanf("%lf\n", &r);
Rotate(p, r); //===========绕OP逆时针旋转r角度
}}
for (scanf("%d", &n); n; n--) {
Point_3 p, p2; scanf("%lf%lf%lf", &p.x, &p.y, &p.z);
p2 = opt(p); printf(“%f %f %f\n”,p2.x,p2.y,p2.z);
}
}
void ros_kinfu_publisher::publishTSDFCloud(PointCloudTSDF::Ptr cloud_ptr){
sensor_msgs::PointCloud2 msg;
PointCloudTSDF::Ptr tsdf_output_ptr(new PointCloudTSDF);
Affine3f scale;
scale = Scaling(1/1000.f);
pcl::transformPointCloud(*cloud_ptr,*tsdf_output_ptr,scale);
pcl::toROSMsg(*tsdf_output_ptr,msg);
msg.header.frame_id = kf_world_frame;
msg.header.stamp = ros::Time::now();
tsdfPublisher.publish(msg);
}
bool cTexture::draw
(
long p_destX, long p_destY,
long p_srcX /*= 0*/, long p_srcY /*= 0*/,
long p_width /*= 0*/, long p_height /*= 0*/,
D3DCOLOR p_color /*= 0xffffffff*/,
D3DXVECTOR2 *p_pRotationCenter /*= NULL*/,
float p_angle /*= 0.0f*/,
float p_XScale /*= 1.0f*/, float p_YScale /*= 1.0f*/
)
{
RECT rect;
ID3DXSprite *pSprite;
if(m_pTexture == NULL)
return FALSE;
if(m_pGraphics == NULL)
return FALSE;
if((pSprite = m_pGraphics->getSprite()) == NULL)
return FALSE;
if(!p_width)
p_width = m_width;
if(!p_height)
p_height = m_height;
rect.left = p_srcX;
rect.top = p_srcY;
rect.right = rect.left + p_width;
rect.bottom = rect.top + p_height;
//D3DXVECTOR3 Center = D3DXVECTOR3(10, 10, 1); // 材质的矩形区域的中心点
D3DXVECTOR3 Position = D3DXVECTOR3((float)p_destX, (float)p_destY, 0); // 画的位置
pSprite->Begin(D3DXSPRITE_ALPHABLEND);
D3DXVECTOR2 Scaling(p_XScale, p_YScale); // 縮放比例
/*D3DXVECTOR2 RotationCenter( p_destX + p_width / 2,
p_destY + p_height / 2 );*/
D3DXMATRIX Matrix; // 坐标转换矩阵
D3DXVECTOR2 d3dx_vector2((float)p_destX, (float)p_destY);
D3DXMatrixTransformation2D(&Matrix, &d3dx_vector2,
0.0, &Scaling, p_pRotationCenter, p_angle, 0 );
pSprite->SetTransform(&Matrix);
pSprite->Draw( m_pTexture, &rect, NULL, &Position, p_color);
pSprite->End();
return true;
}
void renderScene(void) {
int sx = glutGet(GLUT_WINDOW_WIDTH);
int sy = glutGet(GLUT_WINDOW_HEIGHT);
//SAspect = Scaling(1, (float)sx / sy, 1);
VECTOR4D worldRayOrigin, worldRayDir;
VECTOR4D modelRayOrigin, modelRayDir;
MATRIX4D InvW;
multimap<float, CMesh::INTERSECTIONINFO> faces;
bool fill = false;
SAspect = Scaling((float)sy / sx, 1, 1);
W = Identity();
P = PerspectiveWidthHeightRH(0.5f, 0.5f, 1.0f, 10.0f);
EC = SAspect * T * Translation(0.0f, 0.0f, -1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
BuildRayFromPerspective(EC, mx, my, worldRayOrigin, worldRayDir);
Inverse(W, InvW);
modelRayOrigin = InvW * worldRayOrigin;
modelRayDir = InvW * worldRayDir;
fill = g_EggCarton.RayCast(modelRayOrigin, modelRayDir, faces);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glBegin(GL_TRIANGLES);
g_EggCarton.Draw(EC);
glEnd();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glBegin(GL_TRIANGLES);
if (fill)
g_EggCarton.Draw(EC, faces.begin()->second.Face, 1);
glEnd();
if (bWireframe)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
else
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glBegin(GL_TRIANGLES);
g_Plate.Draw(SAspect * T * Translation(0.0f, 0.0f, -0.1f));
g_Sphere.Draw(SAspect * T * Translation(0.4f, 0.4f, 0.32f));
g_Bananas.Draw(SAspect * T * Translation(0.45f, 0.45f, 0.48f));
g_Flower.Draw(SAspect * T * Translation(-0.5f, 0.5f, 0.8f));
glEnd();
glutSwapBuffers();
}
Matrix4f Model::getModelMatrix() const {
Matrix4f M;
Matrix3f R = rotation.toRotationMatrix();
M.setIdentity();
// then rotate
M.block<3,3>(0,0) = R;
// then scale
M = M * Scaling(Vector4f(scale, scale, scale, 1));
// translate to center first
Affine3f a(Translation3f(-center));
M = M * a.matrix();
// finally set position
M.block<3,1>(0,3) += position;
return M;
}
void on_draw_frame() {
//glClearColor(0.30f, 0.74f, 0.20f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Set the blending function (normal w/ premultiplied alpha)
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
update_life_cycle();
// Create Projection Matrix
float aspectRatio = 768.0f / 1022;
Affine3f m;
m = Scaling(1.0f, aspectRatio, 1.0f);
Matrix4f projectionMatrix = Matrix4f::Identity();
projectionMatrix = m.matrix();
// Render Emitter
if (s_emitters.size() > 0) {
std::vector<EmitterObject*>::iterator it = s_emitters.begin();
for (; it != s_emitters.end(); ++it) {
(*it)->RenderWithProjection(projectionMatrix);
}
}
/*
glUseProgram(program);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
glUniform1i(u_texture_unit_location, 0);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glVertexAttribPointer(a_position_location, 2, GL_FLOAT, GL_FALSE,
4 * sizeof(GL_FLOAT), BUFFER_OFFSET(0));
glVertexAttribPointer(a_texture_coordinates_location, 2, GL_FLOAT, GL_FALSE,
4 * sizeof(GL_FLOAT), BUFFER_OFFSET(2 * sizeof(GL_FLOAT)));
glEnableVertexAttribArray(a_position_location);
glEnableVertexAttribArray(a_texture_coordinates_location);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindBuffer(GL_ARRAY_BUFFER, 0);
*/
}
void renderScene(void) {
int sx = glutGet(GLUT_WINDOW_WIDTH);
int sy = glutGet(GLUT_WINDOW_HEIGHT);
MATRIX4D SAspect = Scaling((float)sy / sx, 1, 1);
//MATRIX4D SAspect = Scaling(1, (float)sx / sy, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(bWireframe)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
else
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glBegin(GL_TRIANGLES);
g_EggCarton.Draw(SAspect * T * Translation(0.0f, 0.0f, -1.0f));
g_Plate.Draw(SAspect * T * Translation(0.0f, 0.0f, -0.1f));
g_Sphere.Draw(SAspect * T * Translation(0.4f, 0.4f, 0.32f));
g_Bananas.Draw(SAspect * T * Translation(0.45f, 0.45f, 0.48f));
g_Flower.Draw(SAspect * T * Translation(-0.5f, 0.5f, 0.8f));
glEnd();
glutSwapBuffers();
}
//===============================================
//処理
//===============================================
void CEffect::Exec()
{
//SetPosition(
if(m_IsVariable)
{
Translation(m_vPos.x, m_vPos.y, m_vPos.z);
Scaling(m_vScale.x, m_vScale.y, m_vScale.z);
//Heading(m_vRot.x);
//
Pitching(m_vRot.x);
//
//Rolling(m_vRot.x);
Render(Joker::GetDevice());
m_pAnimController->AdvanceTime(m_AnimSpeed, NULL);
SetWorldMatrix();
}
}
int main(void)
{
//assign X component
vec1[0] = 2.0;
//assign Y component
vec1[1] = 2.0;
//assign Z component
vec1[2] = 2.0;
vec2[0] = 5.0;
vec2[1] = 5.0;
vec2[2] = 5.0;
VectorAdd(vec1,vec2,vec3);
printf("Vector addition: ");
int i;
for(i = 0; i < 3; i++)
{
printf("%g ", vec3[i]);
}
VectorSubtract(vec1,vec2,vec3);
printf("\nVector subtraction: ");
for(i = 0; i < sizeof(vec3)/sizeof(int); i++)
{
printf("%g ", vec3[i]);
}
DotProduct(vec1,vec2,cheez);
printf("\nDot product: %g", cheez);
Scaling(vec1, 2);
printf("\nScaling by 2: ");
for(i = 0; i < sizeof(vec1)/sizeof(int); i++)
{
printf("%g ", vec1[i]);
}
VCopy(vec1, vec3);
printf("\nCopying vec1 to vec3: ");
for(i = 0; i < sizeof(vec3)/sizeof(int); i++)
{
printf("%g ", vec3[i]);
}
VClear(vec3);
printf("\nClearing vec3: ");
for(i = 0; i < sizeof(vec3)/sizeof(int); i++)
{
printf("%g ", vec3[i]);
}
Inverse(vec2);
printf("\nInverse of vec2: ");
for(i = 0; i < sizeof(vec3)/sizeof(int); i++)
{
printf("%g ", vec2[i]);
}
Cross(vec1, vec2, vec3);
printf("\nCross of vec1 and vec2: ");
for(i = 0; i < sizeof(vec3)/sizeof(int); i++)
{
printf("%g ", vec3[i]);
}
Magnitude(vec2);
printf("\nMagnitude of vec2: ");
printf("%g ", Magnitude(vec2));
Normalize(vec2);
printf("\nNormalize of vec2: ");
for(i = 0; i < sizeof(vec3)/sizeof(int); i++)
{
printf("%g ", vec2[i]);
}
}
Matrix Matrix::TRS(Vector3& translation, Quaternion& rotation, Vector3& scaling)
{
return Scaling(scaling) * Rotation(rotation) * Translation(translation);
}
Matrix Transformation::Scaling ( Vector _ScalingFactors )
{
//Calls the function above
return Scaling ( _ScalingFactors.x, _ScalingFactors.y, _ScalingFactors.z );
}
ContourAttributes::Scaling
ContourAttributes::GetScaling() const
{
return Scaling(scaling);
}
void
ContourAttributes::SetFromNode(DataNode *parentNode)
{
if(parentNode == 0)
return;
DataNode *searchNode = parentNode->GetNode("ContourAttributes");
if(searchNode == 0)
return;
DataNode *node;
// Set the default palette from the values in the DataNode.
if((node = searchNode->GetNode("defaultPalette")) != 0)
defaultPalette.SetFromNode(node);
if((node = searchNode->GetNode("colorType")) != 0)
{
// Allow enums to be int or string in the config file
if(node->GetNodeType() == INT_NODE)
{
int ival = node->AsInt();
if(ival >= 0 && ival < 3)
SetColorType(ColoringMethod(ival));
}
else if(node->GetNodeType() == STRING_NODE)
{
ColoringMethod value;
if(ColoringMethod_FromString(node->AsString(), value))
SetColorType(value);
}
}
if((node = searchNode->GetNode("colorTableName")) != 0)
SetColorTableName(node->AsString());
if((node = searchNode->GetNode("legendFlag")) != 0)
SetLegendFlag(node->AsBool());
if((node = searchNode->GetNode("invertColorTable")) != 0)
SetInvertColorTable(node->AsBool());
if((node = searchNode->GetNode("lineStyle")) != 0)
SetLineStyle(node->AsInt());
if((node = searchNode->GetNode("lineWidth")) != 0)
SetLineWidth(node->AsInt());
if((node = searchNode->GetNode("singleColor")) != 0)
singleColor.SetFromNode(node);
if((node = searchNode->GetNode("contourNLevels")) != 0)
SetContourNLevels(node->AsInt());
if((node = searchNode->GetNode("contourValue")) != 0)
SetContourValue(node->AsDoubleVector());
if((node = searchNode->GetNode("contourPercent")) != 0)
SetContourPercent(node->AsDoubleVector());
if((node = searchNode->GetNode("contourMethod")) != 0)
{
// Allow enums to be int or string in the config file
if(node->GetNodeType() == INT_NODE)
{
int ival = node->AsInt();
if(ival >= 0 && ival < 3)
SetContourMethod(Select_by(ival));
}
else if(node->GetNodeType() == STRING_NODE)
{
Select_by value;
if(Select_by_FromString(node->AsString(), value))
SetContourMethod(value);
}
}
if((node = searchNode->GetNode("minFlag")) != 0)
SetMinFlag(node->AsBool());
if((node = searchNode->GetNode("maxFlag")) != 0)
SetMaxFlag(node->AsBool());
if((node = searchNode->GetNode("min")) != 0)
SetMin(node->AsDouble());
if((node = searchNode->GetNode("max")) != 0)
SetMax(node->AsDouble());
if((node = searchNode->GetNode("scaling")) != 0)
{
// Allow enums to be int or string in the config file
if(node->GetNodeType() == INT_NODE)
{
int ival = node->AsInt();
if(ival >= 0 && ival < 2)
SetScaling(Scaling(ival));
}
else if(node->GetNodeType() == STRING_NODE)
{
Scaling value;
if(Scaling_FromString(node->AsString(), value))
SetScaling(value);
}
}
if((node = searchNode->GetNode("wireframe")) != 0)
SetWireframe(node->AsBool());
}
void
SurfaceAttributes::SetFromNode(DataNode *parentNode)
{
if(parentNode == 0)
return;
DataNode *searchNode = parentNode->GetNode("SurfaceAttributes");
if(searchNode == 0)
return;
DataNode *node;
if((node = searchNode->GetNode("legendFlag")) != 0)
SetLegendFlag(node->AsBool());
if((node = searchNode->GetNode("lightingFlag")) != 0)
SetLightingFlag(node->AsBool());
if((node = searchNode->GetNode("surfaceFlag")) != 0)
SetSurfaceFlag(node->AsBool());
if((node = searchNode->GetNode("wireframeFlag")) != 0)
SetWireframeFlag(node->AsBool());
if((node = searchNode->GetNode("limitsMode")) != 0)
{
// Allow enums to be int or string in the config file
if(node->GetNodeType() == INT_NODE)
{
int ival = node->AsInt();
if(ival >= 0 && ival < 2)
SetLimitsMode(LimitsMode(ival));
}
else if(node->GetNodeType() == STRING_NODE)
{
LimitsMode value;
if(LimitsMode_FromString(node->AsString(), value))
SetLimitsMode(value);
}
}
if((node = searchNode->GetNode("minFlag")) != 0)
SetMinFlag(node->AsBool());
if((node = searchNode->GetNode("maxFlag")) != 0)
SetMaxFlag(node->AsBool());
if((node = searchNode->GetNode("colorByZFlag")) != 0)
SetColorByZFlag(node->AsBool());
if((node = searchNode->GetNode("scaling")) != 0)
{
// Allow enums to be int or string in the config file
if(node->GetNodeType() == INT_NODE)
{
int ival = node->AsInt();
if(ival >= 0 && ival < 3)
SetScaling(Scaling(ival));
}
else if(node->GetNodeType() == STRING_NODE)
{
Scaling value;
if(Scaling_FromString(node->AsString(), value))
SetScaling(value);
}
}
if((node = searchNode->GetNode("lineStyle")) != 0)
SetLineStyle(node->AsInt());
if((node = searchNode->GetNode("lineWidth")) != 0)
SetLineWidth(node->AsInt());
if((node = searchNode->GetNode("surfaceColor")) != 0)
surfaceColor.SetFromNode(node);
if((node = searchNode->GetNode("wireframeColor")) != 0)
wireframeColor.SetFromNode(node);
if((node = searchNode->GetNode("skewFactor")) != 0)
SetSkewFactor(node->AsDouble());
if((node = searchNode->GetNode("min")) != 0)
SetMin(node->AsDouble());
if((node = searchNode->GetNode("max")) != 0)
SetMax(node->AsDouble());
if((node = searchNode->GetNode("colorTableName")) != 0)
SetColorTableName(node->AsString());
if((node = searchNode->GetNode("invertColorTable")) != 0)
SetInvertColorTable(node->AsBool());
}
void
SurfaceFilterAttributes::SetFromNode(DataNode *parentNode)
{
if(parentNode == 0)
return;
DataNode *searchNode = parentNode->GetNode("SurfaceFilterAttributes");
if(searchNode == 0)
return;
DataNode *node;
if((node = searchNode->GetNode("limitsMode")) != 0)
{
// Allow enums to be int or string in the config file
if(node->GetNodeType() == INT_NODE)
{
int ival = node->AsInt();
if(ival >= 0 && ival < 2)
SetLimitsMode(LimitsMode(ival));
}
else if(node->GetNodeType() == STRING_NODE)
{
LimitsMode value;
if(LimitsMode_FromString(node->AsString(), value))
SetLimitsMode(value);
}
}
if((node = searchNode->GetNode("minFlag")) != 0)
SetMinFlag(node->AsBool());
if((node = searchNode->GetNode("maxFlag")) != 0)
SetMaxFlag(node->AsBool());
if((node = searchNode->GetNode("scaling")) != 0)
{
// Allow enums to be int or string in the config file
if(node->GetNodeType() == INT_NODE)
{
int ival = node->AsInt();
if(ival >= 0 && ival < 3)
SetScaling(Scaling(ival));
}
else if(node->GetNodeType() == STRING_NODE)
{
Scaling value;
if(Scaling_FromString(node->AsString(), value))
SetScaling(value);
}
}
if((node = searchNode->GetNode("skewFactor")) != 0)
SetSkewFactor(node->AsDouble());
if((node = searchNode->GetNode("min")) != 0)
SetMin(node->AsDouble());
if((node = searchNode->GetNode("max")) != 0)
SetMax(node->AsDouble());
if((node = searchNode->GetNode("zeroFlag")) != 0)
SetZeroFlag(node->AsBool());
if((node = searchNode->GetNode("variable")) != 0)
SetVariable(node->AsString());
if((node = searchNode->GetNode("useXYLimits")) != 0)
SetUseXYLimits(node->AsBool());
if((node = searchNode->GetNode("generateNodalOutput")) != 0)
SetGenerateNodalOutput(node->AsBool());
}
dhVector dhVector::operator*(REAL r) // cross operator
{
dhVector temp;
temp = Scaling(r);
return temp;
}
dhVector dhVector::Scaling( dhVector s)
{
return Scaling( s.x,s.y,s.z );
}
SurfaceFilterAttributes::Scaling
SurfaceFilterAttributes::GetScaling() const
{
return Scaling(scaling);
}
template<typename Scalar, int Mode, int Options> void transformations()
{
/* this test covers the following files:
Cross.h Quaternion.h, Transform.cpp
*/
typedef Matrix<Scalar,2,2> Matrix2;
typedef Matrix<Scalar,3,3> Matrix3;
typedef Matrix<Scalar,4,4> Matrix4;
typedef Matrix<Scalar,2,1> Vector2;
typedef Matrix<Scalar,3,1> Vector3;
typedef Matrix<Scalar,4,1> Vector4;
typedef Quaternion<Scalar> Quaternionx;
typedef AngleAxis<Scalar> AngleAxisx;
typedef Transform<Scalar,2,Mode,Options> Transform2;
typedef Transform<Scalar,3,Mode,Options> Transform3;
typedef Transform<Scalar,2,Isometry,Options> Isometry2;
typedef Transform<Scalar,3,Isometry,Options> Isometry3;
typedef typename Transform3::MatrixType MatrixType;
typedef DiagonalMatrix<Scalar,2> AlignedScaling2;
typedef DiagonalMatrix<Scalar,3> AlignedScaling3;
typedef Translation<Scalar,2> Translation2;
typedef Translation<Scalar,3> Translation3;
Vector3 v0 = Vector3::Random(),
v1 = Vector3::Random();
Matrix3 matrot1, m;
Scalar a = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
Scalar s0 = internal::random<Scalar>();
VERIFY_IS_APPROX(v0, AngleAxisx(a, v0.normalized()) * v0);
VERIFY_IS_APPROX(-v0, AngleAxisx(Scalar(M_PI), v0.unitOrthogonal()) * v0);
VERIFY_IS_APPROX(internal::cos(a)*v0.squaredNorm(), v0.dot(AngleAxisx(a, v0.unitOrthogonal()) * v0));
m = AngleAxisx(a, v0.normalized()).toRotationMatrix().adjoint();
VERIFY_IS_APPROX(Matrix3::Identity(), m * AngleAxisx(a, v0.normalized()));
VERIFY_IS_APPROX(Matrix3::Identity(), AngleAxisx(a, v0.normalized()) * m);
Quaternionx q1, q2;
q1 = AngleAxisx(a, v0.normalized());
q2 = AngleAxisx(a, v1.normalized());
// rotation matrix conversion
matrot1 = AngleAxisx(Scalar(0.1), Vector3::UnitX())
* AngleAxisx(Scalar(0.2), Vector3::UnitY())
* AngleAxisx(Scalar(0.3), Vector3::UnitZ());
VERIFY_IS_APPROX(matrot1 * v1,
AngleAxisx(Scalar(0.1), Vector3(1,0,0)).toRotationMatrix()
* (AngleAxisx(Scalar(0.2), Vector3(0,1,0)).toRotationMatrix()
* (AngleAxisx(Scalar(0.3), Vector3(0,0,1)).toRotationMatrix() * v1)));
// angle-axis conversion
AngleAxisx aa = AngleAxisx(q1);
VERIFY_IS_APPROX(q1 * v1, Quaternionx(aa) * v1);
VERIFY_IS_NOT_APPROX(q1 * v1, Quaternionx(AngleAxisx(aa.angle()*2,aa.axis())) * v1);
aa.fromRotationMatrix(aa.toRotationMatrix());
VERIFY_IS_APPROX(q1 * v1, Quaternionx(aa) * v1);
VERIFY_IS_NOT_APPROX(q1 * v1, Quaternionx(AngleAxisx(aa.angle()*2,aa.axis())) * v1);
// AngleAxis
VERIFY_IS_APPROX(AngleAxisx(a,v1.normalized()).toRotationMatrix(),
Quaternionx(AngleAxisx(a,v1.normalized())).toRotationMatrix());
AngleAxisx aa1;
m = q1.toRotationMatrix();
aa1 = m;
VERIFY_IS_APPROX(AngleAxisx(m).toRotationMatrix(),
Quaternionx(m).toRotationMatrix());
// Transform
// TODO complete the tests !
a = 0;
while (internal::abs(a)<Scalar(0.1))
a = internal::random<Scalar>(-Scalar(0.4)*Scalar(M_PI), Scalar(0.4)*Scalar(M_PI));
q1 = AngleAxisx(a, v0.normalized());
Transform3 t0, t1, t2;
// first test setIdentity() and Identity()
t0.setIdentity();
VERIFY_IS_APPROX(t0.matrix(), Transform3::MatrixType::Identity());
t0.matrix().setZero();
t0 = Transform3::Identity();
VERIFY_IS_APPROX(t0.matrix(), Transform3::MatrixType::Identity());
t0.setIdentity();
t1.setIdentity();
v1 << 1, 2, 3;
t0.linear() = q1.toRotationMatrix();
t0.pretranslate(v0);
t0.scale(v1);
t1.linear() = q1.conjugate().toRotationMatrix();
t1.prescale(v1.cwiseInverse());
t1.translate(-v0);
VERIFY((t0 * t1).matrix().isIdentity(test_precision<Scalar>()));
t1.fromPositionOrientationScale(v0, q1, v1);
VERIFY_IS_APPROX(t1.matrix(), t0.matrix());
t0.setIdentity(); t0.scale(v0).rotate(q1.toRotationMatrix());
t1.setIdentity(); t1.scale(v0).rotate(q1);
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
t0.setIdentity(); t0.scale(v0).rotate(AngleAxisx(q1));
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
VERIFY_IS_APPROX(t0.scale(a).matrix(), t1.scale(Vector3::Constant(a)).matrix());
VERIFY_IS_APPROX(t0.prescale(a).matrix(), t1.prescale(Vector3::Constant(a)).matrix());
// More transform constructors, operator=, operator*=
Matrix3 mat3 = Matrix3::Random();
Matrix4 mat4;
mat4 << mat3 , Vector3::Zero() , Vector4::Zero().transpose();
Transform3 tmat3(mat3), tmat4(mat4);
if(Mode!=int(AffineCompact))
tmat4.matrix()(3,3) = Scalar(1);
VERIFY_IS_APPROX(tmat3.matrix(), tmat4.matrix());
Scalar a3 = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
Vector3 v3 = Vector3::Random().normalized();
AngleAxisx aa3(a3, v3);
Transform3 t3(aa3);
Transform3 t4;
t4 = aa3;
VERIFY_IS_APPROX(t3.matrix(), t4.matrix());
t4.rotate(AngleAxisx(-a3,v3));
VERIFY_IS_APPROX(t4.matrix(), MatrixType::Identity());
t4 *= aa3;
VERIFY_IS_APPROX(t3.matrix(), t4.matrix());
v3 = Vector3::Random();
Translation3 tv3(v3);
Transform3 t5(tv3);
t4 = tv3;
VERIFY_IS_APPROX(t5.matrix(), t4.matrix());
t4.translate(-v3);
VERIFY_IS_APPROX(t4.matrix(), MatrixType::Identity());
t4 *= tv3;
VERIFY_IS_APPROX(t5.matrix(), t4.matrix());
AlignedScaling3 sv3(v3);
Transform3 t6(sv3);
t4 = sv3;
VERIFY_IS_APPROX(t6.matrix(), t4.matrix());
t4.scale(v3.cwiseInverse());
VERIFY_IS_APPROX(t4.matrix(), MatrixType::Identity());
t4 *= sv3;
VERIFY_IS_APPROX(t6.matrix(), t4.matrix());
// matrix * transform
VERIFY_IS_APPROX((t3.matrix()*t4).matrix(), (t3*t4).matrix());
// chained Transform product
VERIFY_IS_APPROX(((t3*t4)*t5).matrix(), (t3*(t4*t5)).matrix());
// check that Transform product doesn't have aliasing problems
t5 = t4;
t5 = t5*t5;
VERIFY_IS_APPROX(t5, t4*t4);
// 2D transformation
Transform2 t20, t21;
Vector2 v20 = Vector2::Random();
Vector2 v21 = Vector2::Random();
for (int k=0; k<2; ++k)
if (internal::abs(v21[k])<Scalar(1e-3)) v21[k] = Scalar(1e-3);
t21.setIdentity();
t21.linear() = Rotation2D<Scalar>(a).toRotationMatrix();
VERIFY_IS_APPROX(t20.fromPositionOrientationScale(v20,a,v21).matrix(),
t21.pretranslate(v20).scale(v21).matrix());
t21.setIdentity();
t21.linear() = Rotation2D<Scalar>(-a).toRotationMatrix();
VERIFY( (t20.fromPositionOrientationScale(v20,a,v21)
* (t21.prescale(v21.cwiseInverse()).translate(-v20))).matrix().isIdentity(test_precision<Scalar>()) );
// Transform - new API
// 3D
t0.setIdentity();
t0.rotate(q1).scale(v0).translate(v0);
// mat * aligned scaling and mat * translation
t1 = (Matrix3(q1) * AlignedScaling3(v0)) * Translation3(v0);
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
t1 = (Matrix3(q1) * Eigen::Scaling(v0)) * Translation3(v0);
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
t1 = (q1 * Eigen::Scaling(v0)) * Translation3(v0);
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
// mat * transformation and aligned scaling * translation
t1 = Matrix3(q1) * (AlignedScaling3(v0) * Translation3(v0));
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
t0.setIdentity();
t0.scale(s0).translate(v0);
t1 = Eigen::Scaling(s0) * Translation3(v0);
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
t0.prescale(s0);
t1 = Eigen::Scaling(s0) * t1;
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
t0 = t3;
t0.scale(s0);
t1 = t3 * Eigen::Scaling(s0,s0,s0);
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
t0.prescale(s0);
t1 = Eigen::Scaling(s0,s0,s0) * t1;
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
t0.setIdentity();
t0.prerotate(q1).prescale(v0).pretranslate(v0);
// translation * aligned scaling and transformation * mat
t1 = (Translation3(v0) * AlignedScaling3(v0)) * Transform3(q1);
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
// scaling * mat and translation * mat
t1 = Translation3(v0) * (AlignedScaling3(v0) * Transform3(q1));
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
t0.setIdentity();
t0.scale(v0).translate(v0).rotate(q1);
// translation * mat and aligned scaling * transformation
t1 = AlignedScaling3(v0) * (Translation3(v0) * Transform3(q1));
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
// transformation * aligned scaling
t0.scale(v0);
t1 *= AlignedScaling3(v0);
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
// transformation * translation
t0.translate(v0);
t1 = t1 * Translation3(v0);
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
// translation * transformation
t0.pretranslate(v0);
t1 = Translation3(v0) * t1;
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
// transform * quaternion
t0.rotate(q1);
t1 = t1 * q1;
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
// translation * quaternion
t0.translate(v1).rotate(q1);
t1 = t1 * (Translation3(v1) * q1);
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
// aligned scaling * quaternion
t0.scale(v1).rotate(q1);
t1 = t1 * (AlignedScaling3(v1) * q1);
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
// quaternion * transform
t0.prerotate(q1);
t1 = q1 * t1;
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
// quaternion * translation
t0.rotate(q1).translate(v1);
t1 = t1 * (q1 * Translation3(v1));
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
// quaternion * aligned scaling
t0.rotate(q1).scale(v1);
t1 = t1 * (q1 * AlignedScaling3(v1));
VERIFY_IS_APPROX(t0.matrix(), t1.matrix());
// test transform inversion
t0.setIdentity();
t0.translate(v0);
t0.linear().setRandom();
Matrix4 t044 = Matrix4::Zero();
t044(3,3) = 1;
t044.block(0,0,t0.matrix().rows(),4) = t0.matrix();
VERIFY_IS_APPROX(t0.inverse(Affine).matrix(), t044.inverse().block(0,0,t0.matrix().rows(),4));
t0.setIdentity();
t0.translate(v0).rotate(q1);
t044 = Matrix4::Zero();
t044(3,3) = 1;
t044.block(0,0,t0.matrix().rows(),4) = t0.matrix();
VERIFY_IS_APPROX(t0.inverse(Isometry).matrix(), t044.inverse().block(0,0,t0.matrix().rows(),4));
Matrix3 mat_rotation, mat_scaling;
t0.setIdentity();
t0.translate(v0).rotate(q1).scale(v1);
t0.computeRotationScaling(&mat_rotation, &mat_scaling);
VERIFY_IS_APPROX(t0.linear(), mat_rotation * mat_scaling);
VERIFY_IS_APPROX(mat_rotation*mat_rotation.adjoint(), Matrix3::Identity());
VERIFY_IS_APPROX(mat_rotation.determinant(), Scalar(1));
t0.computeScalingRotation(&mat_scaling, &mat_rotation);
VERIFY_IS_APPROX(t0.linear(), mat_scaling * mat_rotation);
VERIFY_IS_APPROX(mat_rotation*mat_rotation.adjoint(), Matrix3::Identity());
VERIFY_IS_APPROX(mat_rotation.determinant(), Scalar(1));
// test casting
Transform<float,3,Mode> t1f = t1.template cast<float>();
VERIFY_IS_APPROX(t1f.template cast<Scalar>(),t1);
Transform<double,3,Mode> t1d = t1.template cast<double>();
VERIFY_IS_APPROX(t1d.template cast<Scalar>(),t1);
Translation3 tr1(v0);
Translation<float,3> tr1f = tr1.template cast<float>();
VERIFY_IS_APPROX(tr1f.template cast<Scalar>(),tr1);
Translation<double,3> tr1d = tr1.template cast<double>();
VERIFY_IS_APPROX(tr1d.template cast<Scalar>(),tr1);
AngleAxis<float> aa1f = aa1.template cast<float>();
VERIFY_IS_APPROX(aa1f.template cast<Scalar>(),aa1);
AngleAxis<double> aa1d = aa1.template cast<double>();
VERIFY_IS_APPROX(aa1d.template cast<Scalar>(),aa1);
Rotation2D<Scalar> r2d1(internal::random<Scalar>());
Rotation2D<float> r2d1f = r2d1.template cast<float>();
VERIFY_IS_APPROX(r2d1f.template cast<Scalar>(),r2d1);
Rotation2D<double> r2d1d = r2d1.template cast<double>();
VERIFY_IS_APPROX(r2d1d.template cast<Scalar>(),r2d1);
t20 = Translation2(v20) * (Rotation2D<Scalar>(s0) * Scaling(s0));
t21 = Translation2(v20) * Rotation2D<Scalar>(s0) * Scaling(s0);
VERIFY_IS_APPROX(t20,t21);
}
