QLineF Util::rectSlice(QPointF p1, QPointF p2, QRectF r)
{
// https://gist.github.com/ChickenProp/3194723
qreal minX = r.x();
qreal minY = r.y();
qreal maxX = minX + r.width();
qreal maxY = minY + r.height();
qreal dx = p2.x() - p1.x();
qreal dy = p2.y() - p1.y();
qreal v[4] = { -dx, dx, -dy, dy };
qreal u[4] = { p1.x() - minX, maxX - p1.x(), p1.y() - minY, maxY - p1.y() };
qreal t[4];
qreal tMax = Inf, tMin = -Inf;
for (int i=0; i<4; ++i) {
if (v[i] != 0) {
t[i] = u[i]/v[i];
if (v[i] < 0 && tMin < t[i])
tMin = t[i];
if (v[i] > 0 && tMax > t[i])
tMax = t[i];
} else if (u[i] >= 0) {
return QLineF(p1, p2); // Inside rect
} else {
return QLineF(); // Outside rect
}
}
if (tMin >= tMax)
return QLineF();
if (tMax > 1) tMax = 1;
if (tMax < 0) tMax = 0;
if (tMin > 1) tMin = 1;
if (tMin < 0) tMin = 0;
QPointF q1(p1.x() + tMin*dx, p1.y() + tMin*dy);
QPointF q2(p1.x() + tMax*dx, p1.y() + tMax*dy);
return QLineF(q1, q2);
}
void dSceneRender::DrawCylinder(int segments, dFloat radius, dFloat heigh)
{
dVector q0 ( heigh / 2.0f, radius, 0.0f, 0.0f);
dVector q1 (-heigh / 2.0f, radius, 0.0f, 0.0f);
dMatrix rotation (dPitchMatrix(2.0f * 3.1614f/segments));
dVector cap0[1024];
dVector cap1[1024];
dAssert (segments < sizeof (cap0)/sizeof (cap0[0]));
cap0[segments] = q0;
cap1[segments] = q1;
for (int i = 0; i < segments; i ++) {
cap0[i] = q0;
cap1[i] = q1;
q0 = rotation.RotateVector(q0);
q1 = rotation.RotateVector(q1);
}
dVector normal0 ( 1.0f, 0.0f, 0.0f, 0.0f);
dVector normal1 (-1.0f, 0.0f, 0.0f, 0.0f);
BeginTriangle();
for (int i = 2; i < segments; i ++) {
SubmitNormal(normal0);
DrawTriangle(cap0[0], cap0[i-1], cap0[i]);
SubmitNormal(normal1);
DrawTriangle(cap1[0], cap1[i], cap1[i - 1]);
}
for (int i = 0; i < segments; i ++) {
dVector p0 (cap0[i]);
dVector p1 (cap0[i + 1]);
dVector p2 (cap1[i + 1]);
dVector p3 (cap1[i]);
dVector normal ((p1 - p0) * (p2 - p0));
normal = normal.Scale (1.0f / dSqrt(normal % normal));
SubmitNormal(normal);
DrawTriangle(p0, p2, p1);
SubmitNormal(normal);
DrawTriangle(p0, p3, p2);
}
End();
}
void
TestJoinNode() {
tbb::flow::graph g;
TestSimpleSuccessorArc<tbb::flow::queueing>("queueing");
TestSimpleSuccessorArc<tbb::flow::reserving>("reserving");
TestSimpleSuccessorArc<tbb::flow::tag_matching>("tag_matching");
// queueing and tagging join nodes have input queues, so the input ports do not reverse.
REMARK(" reserving preds");
{
tbb::flow::join_node<tbb::flow::tuple<int,int>, tbb::flow::reserving> rj(g);
tbb::flow::queue_node<int> q0(g);
tbb::flow::queue_node<int> q1(g);
tbb::flow::make_edge(q0,tbb::flow::input_port<0>(rj));
tbb::flow::make_edge(q1,tbb::flow::input_port<1>(rj));
q0.try_put(1);
g.wait_for_all(); // quiesce
ASSERT(!(tbb::flow::input_port<0>(rj).my_predecessors.empty()),"reversed port missing predecessor");
ASSERT((tbb::flow::input_port<1>(rj).my_predecessors.empty()),"non-reversed port has pred");
g.reset();
ASSERT((tbb::flow::input_port<0>(rj).my_predecessors.empty()),"reversed port has pred after reset()");
ASSERT((tbb::flow::input_port<1>(rj).my_predecessors.empty()),"non-reversed port has pred after reset()");
q1.try_put(2);
g.wait_for_all(); // quiesce
ASSERT(!(tbb::flow::input_port<1>(rj).my_predecessors.empty()),"reversed port missing predecessor");
ASSERT((tbb::flow::input_port<0>(rj).my_predecessors.empty()),"non-reversed port has pred");
g.reset();
ASSERT((tbb::flow::input_port<1>(rj).my_predecessors.empty()),"reversed port has pred after reset()");
ASSERT((tbb::flow::input_port<0>(rj).my_predecessors.empty()),"non-reversed port has pred after reset()");
#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
// should reset predecessors just as regular reset.
q1.try_put(3);
g.wait_for_all(); // quiesce
ASSERT(!(tbb::flow::input_port<1>(rj).my_predecessors.empty()),"reversed port missing predecessor");
ASSERT((tbb::flow::input_port<0>(rj).my_predecessors.empty()),"non-reversed port has pred");
g.reset(tbb::flow::rf_extract);
ASSERT((tbb::flow::input_port<1>(rj).my_predecessors.empty()),"reversed port has pred after reset()");
ASSERT((tbb::flow::input_port<0>(rj).my_predecessors.empty()),"non-reversed port has pred after reset()");
ASSERT(q0.my_successors.empty(), "edge not removed by reset(rf_extract)");
ASSERT(q1.my_successors.empty(), "edge not removed by reset(rf_extract)");
#endif
}
REMARK(" done\n");
}
cv::Mat sg::padKernelFFT( cv::Mat const & input, cv::Size const & paddedSize )
{
cv::Mat result = cv::Mat::zeros( paddedSize, input.type() );
// Get the 4 quadrants of the input kernel
int hwx = input.cols / 2;
int hwy = input.rows / 2;
int px = hwx;
int py = hwy;
int fftW = paddedSize.width;
int fftH = paddedSize.height;
if( input.cols %2 != 0 )
++px;
if( input.rows % 2 != 0 )
++py;
cv::Mat q0( input, cv::Rect( 0, 0, px, py ) );
cv::Mat q02( result, cv::Rect( fftW - px, fftH - py, px, py ) );
cv::Mat q1( input, cv::Rect( px, 0, hwx, py ) );
cv::Mat q12( result, cv::Rect( 0, fftH - py, hwx, py ) );
cv::Mat q2( input, cv::Rect( 0, py, px, hwy ) );
cv::Mat q22( result, cv::Rect( fftW - px, 0, px, hwy ) );
cv::Mat q3( input, cv::Rect( px, py, hwx, hwy ) );
cv::Mat q32( result, cv::Rect( 0, 0, hwx, hwy ) );
q0.copyTo( q02 );
q1.copyTo( q12 );
q2.copyTo( q22 );
q3.copyTo( q32 );
// if our filter doesn't have real and complex components, make the complex part zeros
if( result.channels() < 2 )
{
cv::Mat planes[] = { result, cv::Mat::zeros( result.size(), CV_32F ) };
cv::merge( planes, 2, result );
}
return result;
}
Mat THDUtil::computeOrientation(Mat frame)
{
Mat padded; //expanding input image to optimal size by making boarder
int m = getOptimalDFTSize(frame.rows);
int n = getOptimalDFTSize(frame.cols);
copyMakeBorder(frame, padded, m - frame.rows, 0, n - frame.cols, BORDER_CONSTANT, 0);
Mat planes[] = { Mat_<float>(padded), Mat::zeros(padded.size(), CV_32F) };
Mat complexI;
merge(planes, 2, complexI);
dft(complexI, complexI);
split(complexI, planes); // planes[0] = Re(DFT(I), planes[1] = Im(DFT(I))
magnitude(planes[0], planes[1], planes[0]);// planes[0] = magnitude
Mat magI = planes[0];
magI += Scalar::all(1); // switch to logarithmic scale
log(magI, magI);
// crop the spectrum, if it has an odd number of rows or columns
magI = magI(Rect(0, 0, magI.cols & -2, magI.rows & -2));
// rearrange the quadrants of Fourier image so that the origin is at the image center
int cx = magI.cols / 2;
int cy = magI.rows / 2;
Mat q0(magI, Rect(0, 0, cx, cy)); // Top-Left - Create a ROI per quadrant
Mat q1(magI, Rect(cx, 0, cx, cy)); // Top-Right
Mat q2(magI, Rect(0, cy, cx, cy)); // Bottom-Left
Mat q3(magI, Rect(cx, cy, cx, cy)); // Bottom-Right
Mat tmp; // swap quadrants (Top-Left with Bottom-Right)
q0.copyTo(tmp);
q3.copyTo(q0);
tmp.copyTo(q3);
q1.copyTo(tmp); // swap quadrant (Top-Right with Bottom-Left)
q2.copyTo(q1);
tmp.copyTo(q2);
normalize(magI, magI, 0, 1, CV_MINMAX); // Transform the matrix with float values into a
// viewable image form (float between values 0 and 1).
return magI;
}
void Database::_RemoveAlbum(QString album, int artist)
{
if(!artist)
RemoveAttribute(nAlbum, album);
else {
if(!open) return;
int id = _AddAlbum(album, artist);
if(id > 0) {
QSqlQuery q("", db);
q.prepare("select File from Song where Album = "+QString::number(id));
q.exec();
while(q.next()) {
_RemoveFile(q.value(0).toString());
}
QSqlQuery q1("delete from Album where ID = "+QString::number(id), db);
}
}
}
static dFloat PlaneMeshCollisionRayHitCallback (NewtonUserMeshCollisionRayHitDesc* const rayDesc)
{
dVector q0 (rayDesc->m_p0[0], rayDesc->m_p0[1], rayDesc->m_p0[2]);
dVector q1 (rayDesc->m_p1[0], rayDesc->m_p1[1], rayDesc->m_p1[2]);
dVector dq (q1 - q0);
// calculate intersection between point lien a plane and return intersection parameter
dInfinitePlane* const me = (dInfinitePlane*) rayDesc->m_userData;
dFloat t = -(me->m_plane.DotProduct3(q0) + me->m_plane.m_w) / (me->m_plane.DotProduct3(dq));
if ((t > 0.0f) && (t < 1.0f)) {
rayDesc->m_normalOut[0] = me->m_plane[0];
rayDesc->m_normalOut[1] = me->m_plane[1];
rayDesc->m_normalOut[2] = me->m_plane[2];
} else {
t = 1.2f;
}
return t;
}
void tst_QQuaternion::dotProduct()
{
QFETCH(float, x1);
QFETCH(float, y1);
QFETCH(float, z1);
QFETCH(float, scalar1);
QFETCH(float, x2);
QFETCH(float, y2);
QFETCH(float, z2);
QFETCH(float, scalar2);
QFETCH(float, dot);
QQuaternion q1(scalar1, x1, y1, z1);
QQuaternion q2(scalar2, x2, y2, z2);
QCOMPARE(QQuaternion::dotProduct(q1, q2), dot);
QCOMPARE(QQuaternion::dotProduct(q2, q1), dot);
}
void rotate_FromCenter(Mat &magI) {
int cx = magI.cols/2;
int cy = magI.rows/2;
Mat q0(magI, Rect(0, 0, cx, cy)); // Top-Left - Create a ROI per quadrant
Mat q1(magI, Rect(cx, 0, cx, cy)); // Top-Right
Mat q2(magI, Rect(0, cy, cx, cy)); // Bottom-Left
Mat q3(magI, Rect(cx, cy, cx, cy)); // Bottom-Right
Mat tmp; // swap quadrants (Top-Left with Bottom-Right)
q0.copyTo(tmp);
q3.copyTo(q0);
tmp.copyTo(q3);
q1.copyTo(tmp); // swap quadrant (Top-Right with Bottom-Left)
q2.copyTo(q1);
tmp.copyTo(q2);
}
void tst_QQuaternion::multiply()
{
QFETCH(qreal, x1);
QFETCH(qreal, y1);
QFETCH(qreal, z1);
QFETCH(qreal, w1);
QFETCH(qreal, x2);
QFETCH(qreal, y2);
QFETCH(qreal, z2);
QFETCH(qreal, w2);
QQuaternion q1(w1, x1, y1, z1);
QQuaternion q2(w2, x2, y2, z2);
QBENCHMARK {
QQuaternion q3 = q1 * q2;
}
}
int CreateCylinder (dVector* const points, dVector* const normals, int segments, dFloat radius, dFloat height, int maxPoints)
{
dMatrix rotation (dPitchMatrix((-360.0f / segments) * 3.141592f/180.0f));
dVector p0 (0.0, 0.0f, 0.0f, 0.0f);
dVector p1 (0.0, radius, 0.0f, 0.0f);
dVector q0 (height, 0.0f, 0.0f, 0.0f);
dVector q1 (height, radius, 0.0f, 0.0f);
dVector n (0, 1.0f, 0.0f, 0.0f);
int count = 0;
for (int i = 0; (i < segments) && (count < maxPoints); i ++) {
dVector p2 (rotation.RotateVector(p1));
normals[count] = dVector (-1.0f, 0.0f, 0.0f, 0.0f);
points[count * 3 + 0] = p0;
points[count * 3 + 1] = p1;
points[count * 3 + 2] = p2;
count ++;
dVector q2 (rotation.RotateVector(q1));
normals[count] = dVector (1.0f, 0.0f, 0.0f, 0.0f);
points[count * 3 + 0] = q0;
points[count * 3 + 1] = q2;
points[count * 3 + 2] = q1;
count ++;
normals[count] = n;
points[count * 3 + 0] = p1;
points[count * 3 + 1] = q1;
points[count * 3 + 2] = p2;
count ++;
normals[count] = n;
points[count * 3 + 0] = p2;
points[count * 3 + 1] = q1;
points[count * 3 + 2] = q2;
count ++;
n = rotation.RotateVector(n);
p1 = p2;
q1 = q2;
}
return count;
}
void sg::fftshift( cv::Mat & src )
{
// If even we can just pivot around the center pixel
// if odd, we pivot around center + (1,1)
// quadrants arranged q0 q1
// q2 q3
// q0 is located at (0, 0) with width px, height py
// q1 is located at (px, 0) with width hw, height py
// q2 is located at (0, py) with width px, height hw
// q3 is located at (px, py) with width hw, height hw
int hwx = src.cols / 2;
int hwy = src.rows / 2;
int px = hwx;
int py = hwy;
if( src.cols %2 != 0 )
++px;
if( src.rows % 2 != 0 )
++py;
cv::Mat q0( src, cv::Rect( 0, 0, px, py ) );
cv::Mat q02( src, cv::Rect( hwx, hwy, px, py ) );
cv::Mat q1( src, cv::Rect( px, 0, hwx, py ) );
cv::Mat q12( src, cv::Rect( 0, hwy, hwx, py ) );
cv::Mat q2( src, cv::Rect( 0, py, px, hwy ) );
cv::Mat q22( src, cv::Rect( hwx, 0, px, hwy ) );
cv::Mat q3( src, cv::Rect( px, py, hwx, hwy ) );
cv::Mat q32( src, cv::Rect( 0, 0, hwx, hwy ) );
// q0 is the biggest segment and might overlap with
// everything else so it gets done last, we hold it in tmp
cv::Mat tmpq0, tmpq2;
q0.copyTo( tmpq0 );
q2.copyTo( tmpq2 );
q3.copyTo( q32 );
q1.copyTo( q12 );
tmpq2.copyTo( q22 );
tmpq0.copyTo( q02 );
}
/*四角校正，opencv的fft输出的结果在四个角上，应当稍加处理。（swap）*/
void reswap4p(Mat &src)
{
int cx = src.cols / 2;
int cy = src.rows / 2;
Mat q0(src, Rect(0, 0, cx, cy)); // Top-Left - Create a ROI per quadrant
Mat q1(src, Rect(cx, 0, cx, cy)); // Top-Right
Mat q2(src, Rect(0, cy, cx, cy)); // Bottom-Left
Mat q3(src, Rect(cx, cy, cx, cy)); // Bottom-Right
Mat tmp; // swap quadrants (Top-Left with Bottom-Right)
q0.copyTo(tmp);
q3.copyTo(q0);
tmp.copyTo(q3);
q1.copyTo(tmp); // swap quadrant (Top-Right with Bottom-Left)
q2.copyTo(q1);
tmp.copyTo(q2);
}
void q1(char palavra[], int cont)
{
if(palavra[cont] == '\0')
{
qf(palavra, cont);
}
else if(palavra[cont] == '1')
{
q1(palavra, cont+1);
}
else if(palavra[cont] == '2')
{
qf(palavra, cont+1);
}
else
{
erro();
}
}
void rearrange(cv::Mat &img)
{
// img = img(cv::Rect(0, 0, img.cols & -2, img.rows & -2));
int cx = img.cols / 2;
int cy = img.rows / 2;
cv::Mat q0(img, cv::Rect(0, 0, cx, cy)); // Top-Left - Create a ROI per quadrant
cv::Mat q1(img, cv::Rect(cx, 0, cx, cy)); // Top-Right
cv::Mat q2(img, cv::Rect(0, cy, cx, cy)); // Bottom-Left
cv::Mat q3(img, cv::Rect(cx, cy, cx, cy)); // Bottom-Right
cv::Mat tmp; // swap quadrants (Top-Left with Bottom-Right)
q0.copyTo(tmp);
q3.copyTo(q0);
tmp.copyTo(q3);
q1.copyTo(tmp); // swap quadrant (Top-Right with Bottom-Left)
q2.copyTo(q1);
tmp.copyTo(q2);
}
void CustomHinge::SubmitConstrainst ()
{
dFloat angle;
dFloat sinAngle;
dFloat cosAngle;
dMatrix matrix0;
dMatrix matrix1;
// calculate the position of the pivot point and the jacobian direction vectors, in global space.
CalculateGlobalMatrix (m_localMatrix0, m_localMatrix1, matrix0, matrix1);
// Restrict the movemenet on the pivot point along all tree orthonormal direction
NewtonUserJointAddLinearRow (m_joint, &matrix0.m_posit[0], &matrix1.m_posit[0], &matrix0.m_front[0]);
NewtonUserJointAddLinearRow (m_joint, &matrix0.m_posit[0], &matrix1.m_posit[0], &matrix0.m_up[0]);
NewtonUserJointAddLinearRow (m_joint, &matrix0.m_posit[0], &matrix1.m_posit[0], &matrix0.m_right[0]);
// get a point along the pin axis at some resonable large distance from the pivot
dVector q0 (matrix0.m_posit + matrix0.m_front.Scale(MIN_JOINT_PIN_LENGTH));
dVector q1 (matrix1.m_posit + matrix1.m_front.Scale(MIN_JOINT_PIN_LENGTH));
// two contraints row perpendicular to the pin vector
NewtonUserJointAddLinearRow (m_joint, &q0[0], &q1[0], &matrix0.m_up[0]);
NewtonUserJointAddLinearRow (m_joint, &q0[0], &q1[0], &matrix0.m_right[0]);
// if limit are enable ...
if (m_limitsOn) {
// the joint angle can be determine by getting the angle between any two non parallel vectors
sinAngle = (matrix0.m_up * matrix1.m_up) % matrix0.m_front;
cosAngle = matrix0.m_up % matrix1.m_up;
angle = atan2f (sinAngle, cosAngle);
if (angle < m_minAngle) {
// get a point along the up vector and set a constraint
NewtonUserJointAddAngularRow (m_joint, 0.0f, &matrix0.m_front[0]);
NewtonUserJointSetRowMaximunFriction (m_joint, 0.0f);
} else if (angle > m_maxAngle) {
NewtonUserJointAddAngularRow (m_joint, 0.0f, &matrix0.m_front[0]);
NewtonUserJointSetRowMinimunFriction (m_joint, 0.0f);
}
}
}
rsa_priv::rsa_priv (const bigint &n1, const bigint &n2)
: rsa_pub (n1 * n2), p (n1), q (n2)
{
bigint p1 (n1-1);
bigint q1 (n2-1);
phin = p1 * q1;
d = mod (invert (e, phin), phin);
/* Precompute for CRT */
dp = mod (d, p1);
dq = mod (d, q1);
pinvq = mod (invert (p, q), q);
// warn << "p " << p.getstr () << "\n";
// warn << "q " << q.getstr () << "\n";
// warn << "e " << e.getstr << "\n";
// warn << "d " << d.getstr << "\n";
init ();
}
cv::Mat DftShift(const cv::Mat spectrum) {
cv::Mat shifted_spectrum = spectrum.clone();
int cr = shifted_spectrum.rows / 2;
int cc = shifted_spectrum.cols / 2;
cv::Mat q0(shifted_spectrum, cv::Rect(0, 0, cc, cr));
cv::Mat q1(shifted_spectrum, cv::Rect(cc, 0, cc, cr));
cv::Mat q2(shifted_spectrum, cv::Rect(0, cr, cc, cr));
cv::Mat q3(shifted_spectrum, cv::Rect(cc, cr, cc, cr));
cv::Mat tmp;
q0.copyTo(tmp);
q3.copyTo(q0);
tmp.copyTo(q3);
q1.copyTo(tmp);
q2.copyTo(q1);
tmp.copyTo(q2);
return shifted_spectrum;
}
void rearrangeQuadrants(cv::Mat& image) {
// rearrange the quadrants of Fourier image so that the origin is at the image center
int cx = image.cols / 2;
int cy = image.rows / 2;
cv::Mat q0(image, cv::Rect(0, 0, cx, cy)); // Top-Left - Create a ROI per quadrant
cv::Mat q1(image, cv::Rect(cx, 0, cx, cy)); // Top-Right
cv::Mat q2(image, cv::Rect(0, cy, cx, cy)); // Bottom-Left
cv::Mat q3(image, cv::Rect(cx, cy, cx, cy)); // Bottom-Right
cv::Mat tmp;
q0.copyTo(tmp);
q3.copyTo(q0);
tmp.copyTo(q3);
q1.copyTo(tmp); // swap quadrant (Top-Right with Bottom-Left)
q2.copyTo(q1);
tmp.copyTo(q2);
}
int main ()
{
printf ("Results of quat03_test:\n");
quatf q1 (1.0f, 2.0f, 3.0f, 4.0f), q2 (5.0f, 6.0f, 7.0f, 8.0f);
dump ("q1+q2", q1+q2);
dump ("q1-q2", q1-q2);
dump ("q1*q2", q1*q2);
dump ("q1*2", q1*2.0f);
dump ("q1/2", q1/2.0f);
dump ("2*q1", 2.0f*q1);
dump ("q1+=q2", quatf (q1)+=q2);
dump ("q1-=q2", quatf (q1)-=q2);
dump ("q1*=q2", quatf (q1)*=q2);
dump ("q1*=2", quatf (q1)*=2.0f);
dump ("q1/=2", quatf (q1)/=2.0f);
return 0;
}
void q2(const char *cad, int *p, int *c)
{
if(cad[*p] == '\0')
return;
if(cad[*p] == '0')
{
(*p)++;
q1(cad, p, c);
}
else if(cad[*p] == '1')
{
(*p)++;
q3(cad, p, c);
}
else
{
fprintf(stderr, "Cadena no reconocida\n");
exit(-2);
}
}
TEST(QuaternionTest, Extraction)
{
Vec4f p(0,5,5,1);
Quaternion q1(0, 45, 0);
Quaternion q2(0, 0, 45);
Vec4f p1 = p.Rotate(q1);
p1 = p1.Rotate(q2);
Quaternion q = q2*q1;
float angle;
Vec4f axis;
q.ExtractRotationAxisAndAngle(&angle, &axis);
Quaternion net(angle, axis);
Vec4f p2 = p.Rotate(net);
EXPECT_EQ(p1, p2);
}
void q1(const char *cad, int *p, int *c)
{
if(cad[*p] == '\0')
return;
if(cad[*p] == 'n' || cad[*p] == 'N')
{
(*p)++;
q2(cad, p, c);
}
else if(cad[*p] == 'i' || cad[*p] == 'I')
{
(*p)++;
q1(cad, p, c);
}
else
{
(*p)++;
q0(cad, p, c);
}
}
vector<double> CIEColor::SinglehueSequential(vector<vector<double> > MSCs, double t, double s, double b, double c, double h)
{
int N=10;
vector<double> Pseg;
vector<double> p0(3,0),p1(3,0), p2(3,0), q0(3,0), q1(3,0), q2(3,0);
p2[0]=100, p2[1]=0, p2[2]=h;
//p1=dividingLCHuvforMSC_H(0,100,h);
int mid1, mid2;
mid1 = int(h * 100);
float ML, MC, dl;
dl = h*100 - mid1;
mid1 = mid1%3600;
mid2 = (mid1+1)%3600;;
ML = MSCs[mid1][0]*(1-dl) + MSCs[mid2][0]*dl;
MC = MSCs[mid1][1]*(1-dl) + MSCs[mid2][1]*dl;
p1[0]= ML, p1[1]= MC, p1[2]= h;
p0[0]=0, p0[1]=0, p0[2]=h;
q0[0] = (1-s) * p0[0] + s *p1[0];
q0[1] = (1-s) * p0[1] + s *p1[1];
q0[2] = (1-s) * p0[2] + s *p1[2];
q2[0] = (1-s) * p2[0] + s *p1[0];
q2[1] = (1-s) * p2[1] + s *p1[1];
q2[2] = (1-s) * p2[2] + s *p1[2];
q1[0] = (q0[0] + q2[0])/2;
q1[1] = (q0[1] + q2[1])/2;
q1[2] = (q0[2] + q2[2])/2;
vector<double> T = getT(p0, p1, p2, q0, q1, q2, 125-125*pow(0.2,(1-c)*b+t*c));
Pseg = getCseg(p0, p1, p2, q0, q1, q2, T[0]);
Pseg[2]=h;
double r, g, k;
//LCHuvtoRGB(Pseg[0], Pseg[1], Pseg[2], r, g, k);
closestLCHuvtoRGB(Pseg[0], Pseg[1], Pseg[2], r, g, k);
Pseg[0]= r, Pseg[1]=g, Pseg[2]=k;
return Pseg;
}
void
QuaternionTest::testAssign()
{
xpcc::Quaternion<float> q1(1,2,3,4);
xpcc::Quaternion<float> q5;
q5 = q1;
TEST_ASSERT_EQUALS(q5.w, 1);
TEST_ASSERT_EQUALS(q5.x, 2);
TEST_ASSERT_EQUALS(q5.y, 3);
TEST_ASSERT_EQUALS(q5.z, 4);
float mData[] = {1,2,3,4};
xpcc::Matrix<float, 4, 1> m(mData);
xpcc::Quaternion<float> q6;
q6 = m;
TEST_ASSERT_EQUALS(q6.w, 1);
TEST_ASSERT_EQUALS(q6.x, 2);
TEST_ASSERT_EQUALS(q6.y, 3);
TEST_ASSERT_EQUALS(q6.z, 4);
}
int main()
{
Quaternion<> q0(1, 2, 3, 4);
Quaternion<> q1(2, 3, 4, 5);
Quaternion<> q2(3, 4, 5, 6);
double r = 7;
cout << "q0: " << q0 << endl;
cout << "q1: " << q1 << endl;
cout << "q2: " << q2 << endl;
cout << "r: " << r << endl;
cout << endl;
cout << "-q0: " << -q0 << endl;
cout << "~q0: " << ~q0 << endl;
cout << endl;
cout << "r * q0: " << r*q0 << endl;
cout << "r + q0: " << r+q0 << endl;
cout << "q0 / r: " << q0/r << endl;
cout << "q0 - r: " << q0-r << endl;
cout << endl;
cout << "q0 + q1: " << q0+q1 << endl;
cout << "q0 - q1: " << q0-q1 << endl;
cout << "q0 * q1: " << q0*q1 << endl;
cout << "q0 / q1: " << q0/q1 << endl;
cout << endl;
cout << "q0 * ~q0: " << q0*~q0 << endl;
cout << "q0 + q1*q2: " << q0+q1*q2 << endl;
cout << "(q0 + q1)*q2: " << (q0+q1)*q2 << endl;
cout << "q0*q1*q2: " << q0*q1*q2 << endl;
cout << "(q0*q1)*q2: " << (q0*q1)*q2 << endl;
cout << "q0*(q1*q2): " << q0*(q1*q2) << endl;
cout << endl;
cout << "||q0||: " << sqrt(q0.normSquared()) << endl;
cout << endl;
cout << "q0*q1 - q1*q0: " << (q0*q1 - q1*q0) << endl;
// Other base types
Quaternion<int> q5(2), q6(3);
cout << endl << q5*q6 << endl;
}
Database::Database() :QObject(0), subset(false), ssAlbum(0), fillingProgress(0), filling(false)
{
QMutexLocker locker(&lock);
db = QSqlDatabase::addDatabase("QSQLITE", "CollectionDB");
db.setDatabaseName(QDir::homePath()+"/.cuberok/collection.db");
// db.setConnectOptions("QSQLITE_ENABLE_SHARED_CACHE=1");
if(QFile::exists(db.databaseName())) {
if(!db.open()) {
qDebug("Can not open database");
proxy->error("Can not open database");
open = false;
} else {
open = true;
QSqlQuery q1("select value from Version", db);
int ver = -1;
if(q1.next()) ver = q1.value(0).toString().toInt();
if(ver == -1) {
open = createDatabase();
} else if(ver < DB_VERSION) {
open = updateDatabase(ver);
if(!open) db.close();
} else if(ver > DB_VERSION) {
open = false;
db.close();
qDebug("Wrong database version (%d)", ver);
proxy->error("Wrong database version -" + QString::number(ver));
}
}
} else {
if(!QDir().mkpath(QDir::homePath()+"/.cuberok") || !db.open()) {
qDebug("Can not create database");
proxy->error("Can not create database");
open = false;
} else {
open = createDatabase();
}
}
if(open) proxy->message("Database ready");
}
Num solve_Sss(Num X, Num T, Num r, Num b, Num v)
{
Num N = 2 * b / (v * v);
Num M = 2 * r / (v * v);
Num Sj = seed_Sss(N, M, X, T, b, v);
Num K = 1 - exp(-r * T);
Num d1 = bsm_general::d1(Sj, X, T, b, v);
Num q1_ = q1(N, M, K);
Num VS = X - Sj;
Num HS = hs(d1, Sj, X, T, r, b, v, q1_);
Num bj_ = bj(d1, T, r, b, v, q1_);
Num eps = 1e-6;
while (std::abs(VS - HS) / X > eps) {
Sj = (X - HS + bj_ * Sj) / (1 + bj_);
d1 = bsm_general::d1(Sj, X, T, b, v);
VS = X - Sj;
HS = hs(d1, Sj, X, T, r, b, v, q1_);
bj_ = bj(d1, T, r, b, v, q1_);
}
return Sj;
}
void SetKinematicPose(NewtonBody* const body, const dMatrix& matrix1, dFloat timestep)
{
dMatrix matrix0;
const dFloat OneOverDt = 1.0f / timestep;
NewtonBodyGetMatrix(body, &matrix0[0][0]);
dQuaternion q0(matrix0);
dQuaternion q1(matrix1);
dVector omega(q0.CalcAverageOmega(q1, OneOverDt));
// const dFloat maxOmega = 10.0f;
// dFloat mag2 = omega.DotProduct3(omega);
// if (mag2 > maxOmega) {
// omega = omega.Normalize().Scale(maxOmega);
// }
dVector veloc ((matrix1.m_posit - matrix0.m_posit).Scale (OneOverDt));
NewtonBodySetVelocity(body, &veloc[0]);
NewtonBodySetOmega(body, &omega[0]);
NewtonBodyIntegrateVelocity(body, timestep);
}
void rearrangeQuadrants(cv::Mat* magnitude) {
// rearrange the image so that the bright stuff is in the middle
int center_x = magnitude->cols/2, center_y = magnitude->rows/2;
//get a ROI for each quadrant
cv::Mat q0(*magnitude, cv::Rect(0, 0, center_x, center_y)); // Top-Left
cv::Mat q1(*magnitude, cv::Rect(center_x, 0, center_x, center_y)); // Top-Right
cv::Mat q2(*magnitude, cv::Rect(0, center_y, center_x, center_y)); // Bottom-Left
cv::Mat q3(*magnitude, cv::Rect(center_x, center_y, center_x, center_y)); // Bottom-Right
//by rearragning these ROIs it modifies the original image
// swap top left and bottom right
cv::Mat temp;
q0.copyTo(temp);
q3.copyTo(q0);
temp.copyTo(q3);
//swap top right and bottom left
q1.copyTo(temp);
q2.copyTo(q1);
temp.copyTo(q2);
}
