void Thread::setConstraints(Vector3d* positions, Vector3d* tangents)
{
for (int i = 0; i < 2; i++)
{
_positions[i] = positions[i];
_tangents[i] = tangents[i];
_tangents[i].normalize();
}
Vector3d axis = Vector3d::UnitX().cross(_tangents[0]);
if (axis.norm() != 0.0)
axis.normalize();
Matrix3d rot_to_start(Eigen::AngleAxisd(acos(Vector3d::UnitX().dot(_tangents[0])),axis));
_transform_to_start = Matrix4d::Zero();
_transform_to_start.corner(Eigen::TopLeft,3,3) = rot_to_start;
//_transform_to_start.corner(Eigen::TopRight,3,1) = _positions[0];
_transform_to_start(3,3) = 1.0;
_translate_to_start = Matrix4d::Identity();
_translate_to_start.corner(Eigen::TopRight,3,1) = _positions[0];
inverseTransform(_transform_to_start, _transform_to_unit);
//add scaling factors to make it so we can solve in canonical form, with thread length 1
/* _transform_to_start.corner(Eigen::TopLeft,3,3) = _length*_transform_to_start.corner(Eigen::TopLeft,3,3);
_transform_to_unit.corner(Eigen::TopLeft,3,3) = (1.0/_length)*_transform_to_unit.corner(Eigen::TopLeft,3,3);
_transform_to_unit.corner(Eigen::TopRight,3,1) = (1.0/_length)*_transform_to_unit.corner(Eigen::TopRight,3,1);
*/
// std::cout << "transform to unit vector: " << _transform_to_unit << std::endl;
// std::cout << "transform to start vector: " << _transform_to_start << std::endl;
}
void ImageViewer::on_actionDFT_triggered()
{
cv::Mat cvMat = ASM::QPixmapToCvMat(QPixmap::fromImage(*image));
cv::Mat grayscaleMat (cvMat.size(), CV_8U);
cv::cvtColor( cvMat, grayscaleMat, CV_BGR2GRAY );
int width = grayscaleMat.cols;
int height = grayscaleMat.rows;
cv::Mat cvMat_dft = computeDFT(grayscaleMat);
cv::Mat magI;
updateMag(cvMat_dft,magI);
//Mat mask = createBoxMask(cvMat_dft.size(), cvMat_dft.cols/2, cvMat_dft.rows/2,cvMat_dft.cols/8,cvMat_dft.rows/8, true);
Mat mask = createGausFilterMask(cvMat_dft.size(), cvMat_dft.cols/2, cvMat_dft.rows/2,cvMat_dft.cols/2,cvMat_dft.rows/2, true, true);
std::cout << "before mul spect " << grayscaleMat.size() << " " << cvMat_dft.size() << " " << " " << mask.size() << std::endl;
shift(mask);
Mat planes[] = {Mat::zeros(cvMat_dft.size(), CV_32F), Mat::zeros(cvMat_dft.size(), CV_32F)};
Mat kernel_spec;
planes[0] = mask; // real
planes[1] = mask; // imaginar
merge(planes, 2, kernel_spec);
mulSpectrums(cvMat_dft, kernel_spec, cvMat_dft , DFT_ROWS); // only DFT_ROWS accepted
cv::Mat magI2;
updateMag(cvMat_dft,magI2); // show spectrum
cv::Mat inverseTransform;
cv::dft(cvMat_dft,inverseTransform,cv::DFT_INVERSE|cv::DFT_REAL_OUTPUT);
normalize(inverseTransform, inverseTransform, 0, 255, CV_MINMAX);
cv::Mat finalImage = inverseTransform;
if(width <inverseTransform.cols || height<inverseTransform.rows) {
finalImage = inverseTransform(Rect(0,0,width,height));
}
// Back to 8-bits
cv::Mat finalImage2;
finalImage.convertTo(finalImage2, CV_8U);
if(!scene) scene = new QGraphicsScene;
if(!view) view = new QGraphicsView(scene);
if(item) {
scene->clear();
//delete item; item=0;
}
item = new QGraphicsPixmapItem(ASM::cvMatToQPixmap(finalImage2).copy());
scene->addItem(item);
view->adjustSize();
view->show();
}
void QFourierTransformer::transform(float input[], float output[], Direction direction)
{
if(direction == QFourierTransformer::Forward)
{
forwardTransform(input, output);
}
else
{
inverseTransform(input, output);
}
}
void KisBrush::generateBoundary() const
{
KisFixedPaintDeviceSP dev;
KisDabShape inverseTransform(1.0 / scale(), 1.0, -angle());
if (brushType() == IMAGE || brushType() == PIPE_IMAGE) {
dev = paintDevice(KoColorSpaceRegistry::instance()->rgb8(),
inverseTransform, KisPaintInformation());
}
else {
const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
dev = new KisFixedPaintDevice(cs);
mask(dev, KoColor(Qt::black, cs), inverseTransform, KisPaintInformation());
}
d->boundary = new KisBoundary(dev);
d->boundary->generateBoundary();
}
void Foam::scaleSearchableSurface::getNormal
(
const List<pointIndexHit>& info,
vectorField& normal
) const
{
vectorField iNormal;
transformationSearchableSurface::getNormal
(
info,
iNormal
);
normal.setSize(iNormal.size());
forAll(normal,i) {
normal[i]=inverseTransform(iNormal[i]);
normal[i]/=mag(normal[i]);
}
void Thread::optimizeManyPoints(MatrixXd& constraints, int num_pts_between, vector<double>&curvatures_resampled, vector<double>& torsions_resampled, Matrix4d& start_transform)
{
int num_constraints = constraints.rows()-1;
int num_pieces_reopt = num_pts_between*num_constraints;
double length_per_piece = 1.0/( num_pieces_reopt);
//opt_params_many_points.transform_back = _transform_to_start;
opt_params_many_points.num_segments = num_pieces_reopt;
opt_params_many_points.length_per_segment = length_per_piece;
opt_params_many_points.points.resize(num_constraints);
opt_params_many_points.orig_params_each_piece = new NEWMAT::ColumnVector(2*num_pieces_reopt+3);
opt_params_many_points.num_pts_between = num_pts_between;
opt_params_many_points.gravity_multipler = (GRAVITY_CONSTANT)*_length;
opt_params_many_points.total_length = _length;
for (int i=0; i < num_constraints; i++)
{
for (int j=0; j < num_pts_between; j++)
{
int piece_num = i*num_pts_between+j;
opt_params_many_points.orig_params_each_piece->element(2*piece_num) = curvatures_resampled[i];
opt_params_many_points.orig_params_each_piece->element(2*piece_num+1) = torsions_resampled[i];
}
}
double eulerZ, eulerY, eulerX;
eulerAnglesFramTransform(start_transform.corner(Eigen::TopLeft,3,3), eulerZ, eulerY, eulerX);
opt_params_many_points.orig_params_each_piece->element(2*num_pieces_reopt) = eulerZ;
opt_params_many_points.orig_params_each_piece->element(2*num_pieces_reopt+1) = eulerY;
opt_params_many_points.orig_params_each_piece->element(2*num_pieces_reopt+2) = eulerX;
for (int i=0; i < num_constraints; i++)
{
opt_params_many_points.points[i] = ((constraints.block((i+1),0,1,3) - constraints.block(0,0,1,3))/_length).transpose();
}
NEWMAT::ColumnVector x_sol;
optimize_FDNLF(2*opt_params_many_points.num_segments+3, energyEvalFunctionManyPoints, energyEvalFunctionManyPoints_init, x_sol);
std::cout << "done re-optimizing" << std::endl;
delete opt_params_many_points.orig_params_each_piece;
//set thread params
_positions[0] = constraints.block(0,0,1,3).transpose();
transformFromEulerAngles(_transform_to_start, x_sol(2*num_pieces_reopt+1), x_sol(2*num_pieces_reopt+2));
_translate_to_start = Matrix4d::Identity();
_translate_to_start.corner(Eigen::TopRight,3,1) = _positions[0];
_tangents[0] = _transform_to_start.corner(Eigen::TopLeft,3,1);
//_tangents[0] = orig_thread->_tangents[0];
_angle_first_rot = x_sol(2*num_pieces_reopt+3);
inverseTransform(_transform_to_start, _transform_to_unit);
Matrix4d transform_back;
getStartTransform(transform_back);
transform_back.corner(Eigen::TopLeft,3,3) *= _length;
threadList = new ThreadPiece(x_sol(1), x_sol(2), length_per_piece);
ThreadPiece* currPiece = threadList;
for (int i=1; i < num_pieces_reopt; i++)
{
currPiece->addSegmentAfter(new ThreadPiece(x_sol(2*i+1), x_sol(2*i+2), length_per_piece));
transform_back *= currPiece->_transform;
currPiece = currPiece->_next_segment;
}
//_positions[1] = transform_back.corner(Eigen::TopRight,3,1);
// _positions[1] = orig_thread->_positions[1];
// _tangents[1] = orig_thread->_tangents[1];
// _tangents[1].normalize();
// _tangents[0].normalize();
_positions[1] = transform_back.corner(Eigen::TopRight,3,1);
_tangents[1] = transform_back.corner(Eigen::TopLeft,3,1);
_tangents[1].normalize();
//printThreadInfo();
}
void VrmlNodePlaneSensor::activate( double timeStamp,
bool isActive,
double *p )
{
// Become active
if ( isActive && ! d_isActive.get() )
{
d_isActive.set(isActive);
float V[3] = { (float)p[0], (float)p[1], (float)p[2] };
double M[4][4];
inverseTransform( M );
VM( V, M, V );
d_activationPoint.set( V[0], V[1], V[2] );
#if 0
theSystem->warn(" planesensor: activate at (%g %g %g)\n",
p[0],p[1],p[2]);
theSystem->warn(" planesensor: local coord (%g %g %g)\n",
V[0],V[1],V[2]);
#endif
eventOut( timeStamp, "isActive", d_isActive );
}
// Become inactive
else if ( ! isActive && d_isActive.get() )
{
#if 0
theSystem->warn(" planesensor: deactivate\n");
#endif
d_isActive.set(isActive);
eventOut( timeStamp, "isActive", d_isActive );
// auto offset
if ( d_autoOffset.get() )
{
d_offset = d_translation;
eventOut( timeStamp, "offset_changed", d_offset );
}
}
// Tracking
else if ( isActive )
{
float V[3] = { (float)p[0], (float)p[1], (float)p[2] };
double M[4][4];
inverseTransform( M );
VM( V, M, V );
#if 0
theSystem->warn(" planesensor: track at (%g %g %g)\n",
p[0],p[1],p[2]);
theSystem->warn(" planesensor: local cd (%g %g %g)\n",
V[0],V[1],V[2]);
#endif
d_trackPoint.set( V[0], V[1], V[2] );
eventOut( timeStamp, "trackPoint_changed", d_trackPoint );
float t[3];
t[0] = V[0] - d_activationPoint.x() + d_offset.x();
t[1] = V[1] - d_activationPoint.y() + d_offset.y();
t[2] = 0.0;
if ( d_minPosition.x() == d_maxPosition.x() )
t[0] = d_minPosition.x();
else if ( d_minPosition.x() < d_maxPosition.x() )
{
if (t[0] < d_minPosition.x())
t[0] = d_minPosition.x();
else if (t[0] > d_maxPosition.x())
t[0] = d_maxPosition.x();
}
if ( d_minPosition.y() == d_maxPosition.y() )
t[1] = d_minPosition.y();
else if ( d_minPosition.y() < d_maxPosition.y() )
{
if (t[1] < d_minPosition.y())
t[1] = d_minPosition.y();
else if (t[1] > d_maxPosition.y())
t[1] = d_maxPosition.y();
}
d_translation.set( t[0], t[1], t[2] );
eventOut( timeStamp, "translation_changed", d_translation );
}
}
