bool ccClipBox::move3D(const CCVector3d& uInput)
{
if (m_activeComponent == NONE || !m_box.isValid())
return false;
CCVector3d u = uInput;
//Arrows
if (m_activeComponent >= X_MINUS_ARROW && m_activeComponent <= CROSS)
{
if (m_glTransEnabled)
m_glTrans.inverse().applyRotation(u);
switch(m_activeComponent)
{
case X_MINUS_ARROW:
m_box.minCorner().x += static_cast<PointCoordinateType>(u.x);
if (m_box.minCorner().x > m_box.maxCorner().x)
m_box.minCorner().x = m_box.maxCorner().x;
break;
case X_PLUS_ARROW:
m_box.maxCorner().x += static_cast<PointCoordinateType>(u.x);
if (m_box.minCorner().x > m_box.maxCorner().x)
m_box.maxCorner().x = m_box.minCorner().x;
break;
case Y_MINUS_ARROW:
m_box.minCorner().y += static_cast<PointCoordinateType>(u.y);
if (m_box.minCorner().y > m_box.maxCorner().y)
m_box.minCorner().y = m_box.maxCorner().y;
break;
case Y_PLUS_ARROW:
m_box.maxCorner().y += static_cast<PointCoordinateType>(u.y);
if (m_box.minCorner().y > m_box.maxCorner().y)
m_box.maxCorner().y = m_box.minCorner().y;
break;
case Z_MINUS_ARROW:
m_box.minCorner().z += static_cast<PointCoordinateType>(u.z);
if (m_box.minCorner().z > m_box.maxCorner().z)
m_box.minCorner().z = m_box.maxCorner().z;
break;
case Z_PLUS_ARROW:
m_box.maxCorner().z += static_cast<PointCoordinateType>(u.z);
if (m_box.minCorner().z > m_box.maxCorner().z)
m_box.maxCorner().z = m_box.minCorner().z;
break;
case CROSS:
m_box += CCVector3::fromArray(u.u);
break;
default:
assert(false);
return false;
}
//send 'modified' signal
emit boxModified(&m_box);
}
else if (m_activeComponent == SPHERE)
{
//handled by move2D!
return false;
}
else if (m_activeComponent >= X_MINUS_TORUS && m_activeComponent <= Z_PLUS_TORUS)
{
//we guess the rotation order by comparing the current screen 'normal'
//and the vector prod of u and the current rotation axis
CCVector3d Rb(0,0,0);
switch(m_activeComponent)
{
case X_MINUS_TORUS:
Rb.x = -1;
break;
case X_PLUS_TORUS:
Rb.x = 1;
break;
case Y_MINUS_TORUS:
Rb.y = -1;
break;
case Y_PLUS_TORUS:
Rb.y = 1;
break;
case Z_MINUS_TORUS:
Rb.z = -1;
break;
case Z_PLUS_TORUS:
Rb.z = 1;
break;
default:
assert(false);
return false;
}
CCVector3d R = Rb;
if (m_glTransEnabled)
m_glTrans.applyRotation(R);
CCVector3d RxU = R.cross(u);
//look for the most parallel dimension
int minDim = 0;
double maxDot = m_viewMatrix.getColumnAsVec3D(0).dot(RxU);
for (int i=1; i<3; ++i)
{
double dot = m_viewMatrix.getColumnAsVec3D(i).dot(RxU);
if (fabs(dot) > fabs(maxDot))
{
maxDot = dot;
minDim = i;
}
}
//angle is proportional to absolute displacement
double angle_rad = u.norm()/m_box.getDiagNorm() * M_PI;
if (maxDot < 0.0)
angle_rad = -angle_rad;
ccGLMatrixd rotMat;
rotMat.initFromParameters(angle_rad,Rb,CCVector3d(0,0,0));
CCVector3 C = m_box.getCenter();
ccGLMatrixd transMat;
transMat.setTranslation(-C);
transMat = rotMat * transMat;
transMat.setTranslation(transMat.getTranslationAsVec3D() + CCVector3d::fromArray(C.u));
m_glTrans = m_glTrans * ccGLMatrix(transMat.inverse().data());
enableGLTransformation(true);
}
else
{
assert(false);
return false;
}
update();
return true;
}
vector<Point> Find_refer_point(vector<Point> contour_point)
{
int size = contour_point.size(); Point temp;
int i=0,j=0,k=0;
float x_sum=0,y_sum=0; float x_mean,y_mean;
float xx=0,xy=0,yx=0,yy=0; float xd,yd;
float A[2][2];
float maj1,maj2,min1,min2;
for(i=0;i<size;i++)
{
temp = contour_point[i];
x_sum = temp.x + x_sum;
y_sum = temp.y + x_sum;
}
x_mean = x_sum/(float)size; y_mean = y_sum/(float)size;
for(i=0;i<size;i++)
{
temp = contour_point[i];
xd = (float)temp.y - x_mean;
yd = (float)temp.x - y_mean;
xx = xx + (xd*xd)/(float)size;
xy = xy + (xd*yd)/(float)size;
yx = yx + (yd*xd)/(float)size;
yy = yy + (yd*yd)/(float)size;
}
A[0][0] = xx; A[0][1] = xy; A[1][0] = yx; A[1][1] = yy;
Mat CM(2,2,CV_32FC1,A);
Mat eival(2,1,CV_32FC1);
Mat eivec(2,2,CV_32FC1);
eigen(CM,eival,eivec);
maj1 = eivec.at<float>(0,0);
maj2 = eivec.at<float>(0,1);
min1 = eivec.at<float>(1,0);
min2 = eivec.at<float>(1,1);
float Head[2]={0,0}, Lfoot[2]={0,0}, Rfoot[2]={0,0};
float dummy_x, dummy_y;
float Rmin[2], Rmaj[2], Gmin[2], Gmaj[2];
Rmin[0] = (-1)*maj1; Rmin[1] = (-1)*maj2; Rmaj[0] = maj1; Rmaj[1] = maj2;
Gmin[0] = (-1)*min1; Gmin[1] = (-1)*min2; Gmaj[0] = min1; Gmaj[1] = min2;
Mat Ra(1,2,CV_32FC1,Rmin);
Mat Rb(1,2,CV_32FC1,Rmaj);
Mat Ga(1,2,CV_32FC1,Gmin);
Mat Gb(1,2,CV_32FC1,Gmaj);
Mat dumvec(1,2,CV_32FC1);
float Hmax=0,Lmax=0,Rmax=0,d_dum=0;
float dum1,dum2,dum3;
for (k = 0; k < size; k++)
{
temp = contour_point[k];
i = temp.y; j = temp.x;
dummy_x = (float)temp.y - x_mean; dummy_y = (float)temp.x - y_mean;
dumvec.at<float>(0, 0) = dummy_x;
dumvec.at<float>(0, 1) = dummy_y;
dum1 = Ra.dot(dumvec);
if (Hmax < dum1)
{
Hmax = dum1;
Head[0] = j; Head[1] = i;
}
dum2 = Ga.dot(dumvec);
if (dum2 > 0)
{
d_dum = Rb.dot(dumvec);
if (d_dum > 0)
{
if (Lmax < (d_dum + dum2))
{
Lmax = d_dum + dum2;
Lfoot[0] = j, Lfoot[1] = i;
}
}
}
dum3 = Gb.dot(dumvec);
if (dum3 > 0)
{
d_dum = Rb.dot(dumvec);
if (d_dum > 0)
{
if (Rmax < (d_dum + dum3))
{
Rmax = d_dum + dum3;
Rfoot[0] = j, Rfoot[1] = i;
}
}
}
}
vector<Point> Result(3);
Result[0].x = Head[0]; Result[0].y = Head[1];
Result[1].x = Lfoot[0]; Result[1].y = Lfoot[1];
Result[2].x = Rfoot[0]; Result[2].y = Rfoot[1];
return Result;
}
