void GpxBlock::setDirection(Graphic::Direction dir)
{
qreal angle;
if(_myDirection != dir && checkDirection(_myDirection))
angle=rotationAngle(_myDirection, dir);
else
angle = rotationAngle(Graphic::RIGHT,dir);
_myDirection = dir;
QGraphicsItem::rotate(angle);
foreach(GpxConnectionInport* port, _inPorts) {
port->setDirection(direction());
port->updatePosition();
}
FT_Face
ServerFont::GetTransformedFace(bool rotate, bool shear) const
{
fStyle->Lock();
FT_Face face = fStyle->FreeTypeFace();
if (!face) {
fStyle->Unlock();
return NULL;
}
FT_Set_Char_Size(face, 0, int32(fSize * 64), 72, 72);
if ((rotate && fRotation != 0) || (shear && fShear != 90)) {
FT_Matrix rmatrix, smatrix;
Angle rotationAngle(fRotation);
rmatrix.xx = (FT_Fixed)( rotationAngle.Cosine() * 0x10000);
rmatrix.xy = (FT_Fixed)(-rotationAngle.Sine() * 0x10000);
rmatrix.yx = (FT_Fixed)( rotationAngle.Sine() * 0x10000);
rmatrix.yy = (FT_Fixed)( rotationAngle.Cosine() * 0x10000);
Angle shearAngle(fShear);
smatrix.xx = (FT_Fixed)(0x10000);
smatrix.xy = (FT_Fixed)(-shearAngle.Cosine() * 0x10000);
smatrix.yx = (FT_Fixed)(0);
smatrix.yy = (FT_Fixed)(0x10000);
// Multiply togheter and apply transform
FT_Matrix_Multiply(&rmatrix, &smatrix);
FT_Set_Transform(face, &smatrix, NULL);
}
// fStyle will be unlocked in PutTransformedFace()
return face;
}
const Matrix2x2 slerp(const Matrix2x2& a, const Matrix2x2& b, const float t)
{
const Matrix2x2 c = timesTranspose(a, b);
const float angle = rotationAngle(c);
return a * Matrix2x2::rotation(t * angle);
}
void LineItem::updateChildGeometry(const QRectF &oldParentRect, const QRectF &newParentRect) {
// parent has been resized: update the line's dimensions:
// we would like to have lines in terms of relative endpoint locations,
// but instead they are in terms of length (relative to parent width)
// and angle, relative to the parent.
qreal theta = rotationAngle()*M_PI/180.0;
qreal oldL = relativeWidth()*oldParentRect.width();
// we want to keep the endpoints fixed relative to the parent, so
// we need to calculate new lengths and angles.
qreal newDx = cos(theta)*oldL*newParentRect.width()/oldParentRect.width();
qreal newDy = sin(theta)*oldL*newParentRect.height()/oldParentRect.height();
qreal newWidth = sqrt(newDx*newDx + newDy*newDy);
QTransform transform;
transform.rotate(atan2(newDy, newDx)*180.0/M_PI);
// my brain hurts less for rotations when we center the object at 0,0
QRectF itemRect(-newWidth*0.5, -rect().height()*0.5,
newWidth, rect().height());
// we don't now what the parents's origin is, so, add .x() and .y()
setPos(relativeCenter().x() * newParentRect.width() + newParentRect.x(),
relativeCenter().y() * newParentRect.height()+ newParentRect.y());
setViewRect(itemRect, true);
setTransform(transform);
setRelativeWidth(newWidth / newParentRect.width());
}
int QPinchGesture::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QGesture::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<int*>(_v) = QFlag(totalChangeFlags()); break;
case 1: *reinterpret_cast<int*>(_v) = QFlag(changeFlags()); break;
case 2: *reinterpret_cast< qreal*>(_v) = totalScaleFactor(); break;
case 3: *reinterpret_cast< qreal*>(_v) = lastScaleFactor(); break;
case 4: *reinterpret_cast< qreal*>(_v) = scaleFactor(); break;
case 5: *reinterpret_cast< qreal*>(_v) = totalRotationAngle(); break;
case 6: *reinterpret_cast< qreal*>(_v) = lastRotationAngle(); break;
case 7: *reinterpret_cast< qreal*>(_v) = rotationAngle(); break;
case 8: *reinterpret_cast< QPointF*>(_v) = startCenterPoint(); break;
case 9: *reinterpret_cast< QPointF*>(_v) = lastCenterPoint(); break;
case 10: *reinterpret_cast< QPointF*>(_v) = centerPoint(); break;
}
_id -= 11;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setTotalChangeFlags(QFlag(*reinterpret_cast<int*>(_v))); break;
case 1: setChangeFlags(QFlag(*reinterpret_cast<int*>(_v))); break;
case 2: setTotalScaleFactor(*reinterpret_cast< qreal*>(_v)); break;
case 3: setLastScaleFactor(*reinterpret_cast< qreal*>(_v)); break;
case 4: setScaleFactor(*reinterpret_cast< qreal*>(_v)); break;
case 5: setTotalRotationAngle(*reinterpret_cast< qreal*>(_v)); break;
case 6: setLastRotationAngle(*reinterpret_cast< qreal*>(_v)); break;
case 7: setRotationAngle(*reinterpret_cast< qreal*>(_v)); break;
case 8: setStartCenterPoint(*reinterpret_cast< QPointF*>(_v)); break;
case 9: setLastCenterPoint(*reinterpret_cast< QPointF*>(_v)); break;
case 10: setCenterPoint(*reinterpret_cast< QPointF*>(_v)); break;
}
_id -= 11;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 11;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 11;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 11;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 11;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 11;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 11;
}
#endif // QT_NO_PROPERTIES
return _id;
}
void SprayBrush::paint(KisPaintDeviceSP dab, KisPaintDeviceSP source,
const KisPaintInformation& info, qreal rotation, qreal scale,
const KoColor &color, const KoColor &bgColor)
{
// initializing painter
if (!m_painter) {
m_painter = new KisPainter(dab);
m_painter->setFillStyle(KisPainter::FillStyleForegroundColor);
m_painter->setMaskImageSize(m_shapeProperties->width, m_shapeProperties->height);
m_dabPixelSize = dab->colorSpace()->pixelSize();
if (m_colorProperties->useRandomHSV) {
m_transfo = dab->colorSpace()->createColorTransformation("hsv_adjustment", QHash<QString, QVariant>());
}
m_brushQImage = m_shapeProperties->image;
if (!m_brushQImage.isNull()) {
m_brushQImage = m_brushQImage.scaled(m_shapeProperties->width, m_shapeProperties->height);
}
m_imageDevice = new KisPaintDevice(dab->colorSpace());
}
qreal x = info.pos().x();
qreal y = info.pos().y();
KisRandomAccessorSP accessor = dab->createRandomAccessorNG(qRound(x), qRound(y));
Q_ASSERT(color.colorSpace()->pixelSize() == dab->pixelSize());
m_inkColor = color;
KisCrossDeviceColorPicker colorPicker(source, m_inkColor);
// apply size sensor
m_radius = m_properties->radius * scale;
// jitter movement
if (m_properties->jitterMovement) {
x = x + ((2 * m_radius * drand48()) - m_radius) * m_properties->amount;
y = y + ((2 * m_radius * drand48()) - m_radius) * m_properties->amount;
}
// this is wrong for every shape except pixel and anti-aliased pixel
if (m_properties->useDensity) {
m_particlesCount = (m_properties->coverage * (M_PI * m_radius * m_radius));
}
else {
m_particlesCount = m_properties->particleCount;
}
QHash<QString, QVariant> params;
qreal nx, ny;
int ix, iy;
qreal angle;
qreal length;
qreal rotationZ = 0.0;
qreal particleScale = 1.0;
bool shouldColor = true;
if (m_colorProperties->fillBackground) {
m_painter->setPaintColor(bgColor);
paintCircle(m_painter, x, y, m_radius);
}
QTransform m;
m.reset();
m.rotateRadians(-rotation + deg2rad(m_properties->brushRotation));
m.scale(m_properties->scale, m_properties->scale);
for (quint32 i = 0; i < m_particlesCount; i++) {
// generate random angle
angle = drand48() * M_PI * 2;
// generate random length
if (m_properties->gaussian) {
length = qBound<qreal>(0.0, m_rand->nextGaussian(0.0, 0.50) , 1.0);
}
else {
length = drand48();
}
if (m_shapeDynamicsProperties->enabled) {
// rotation
rotationZ = rotationAngle();
if (m_shapeDynamicsProperties->followCursor) {
rotationZ = linearInterpolation(rotationZ, angle, m_shapeDynamicsProperties->followCursorWeigth);
}
if (m_shapeDynamicsProperties->followDrawingAngle) {
rotationZ = linearInterpolation(rotationZ, info.drawingAngle(), m_shapeDynamicsProperties->followDrawingAngleWeight);
}
// random size - scale
if (m_shapeDynamicsProperties->randomSize) {
particleScale = drand48();
}
}
// generate polar coordinate
nx = (m_radius * cos(angle) * length);
ny = (m_radius * sin(angle) * length);
// compute the height of the ellipse
ny *= m_properties->aspect;
// transform
m.map(nx, ny, &nx, &ny);
// color transformation
if (shouldColor) {
if (m_colorProperties->sampleInputColor) {
colorPicker.pickOldColor(nx + x, ny + y, m_inkColor.data());
}
// mix the color with background color
if (m_colorProperties->mixBgColor) {
KoMixColorsOp * mixOp = dab->colorSpace()->mixColorsOp();
const quint8 *colors[2];
colors[0] = m_inkColor.data();
colors[1] = bgColor.data();
qint16 colorWeights[2];
int MAX_16BIT = 255;
qreal blend = info.pressure();
colorWeights[0] = static_cast<quint16>(blend * MAX_16BIT);
colorWeights[1] = static_cast<quint16>((1.0 - blend) * MAX_16BIT);
mixOp->mixColors(colors, colorWeights, 2, m_inkColor.data());
}
if (m_colorProperties->useRandomHSV && m_transfo) {
params["h"] = (m_colorProperties->hue / 180.0) * drand48();
params["s"] = (m_colorProperties->saturation / 100.0) * drand48();
params["v"] = (m_colorProperties->value / 100.0) * drand48();
m_transfo->setParameters(params);
m_transfo->transform(m_inkColor.data(), m_inkColor.data() , 1);
}
if (m_colorProperties->useRandomOpacity) {
quint8 alpha = qRound(drand48() * OPACITY_OPAQUE_U8);
m_inkColor.setOpacity(alpha);
m_painter->setOpacity(alpha);
}
if (!m_colorProperties->colorPerParticle) {
shouldColor = false;
}
m_painter->setPaintColor(m_inkColor);
}
qreal jitteredWidth = qMax(qreal(1.0), m_shapeProperties->width * particleScale);
qreal jitteredHeight = qMax(qreal(1.0), m_shapeProperties->height * particleScale);
if (m_shapeProperties->enabled){
switch (m_shapeProperties->shape){
// ellipse
case 0:
{
if (m_shapeProperties->width == m_shapeProperties->height){
paintCircle(m_painter, nx + x, ny + y, qRound(jitteredWidth * 0.5));
}
else {
paintEllipse(m_painter, nx + x, ny + y, qRound(jitteredWidth * 0.5) , qRound(jitteredHeight * 0.5), rotationZ);
}
break;
}
// rectangle
case 1:
{
paintRectangle(m_painter, nx + x, ny + y, qRound(jitteredWidth) , qRound(jitteredHeight), rotationZ);
break;
}
// wu-particle
case 2: {
paintParticle(accessor, m_inkColor, nx + x, ny + y);
break;
}
// pixel
case 3: {
ix = qRound(nx + x);
iy = qRound(ny + y);
accessor->moveTo(ix, iy);
memcpy(accessor->rawData(), m_inkColor.data(), m_dabPixelSize);
break;
}
case 4: {
if (!m_brushQImage.isNull()) {
QTransform m;
m.rotate(rad2deg(rotationZ));
if (m_shapeDynamicsProperties->randomSize) {
m.scale(particleScale, particleScale);
}
m_transformed = m_brushQImage.transformed(m, Qt::SmoothTransformation);
m_imageDevice->convertFromQImage(m_transformed, 0);
KisRandomAccessorSP ac = m_imageDevice->createRandomAccessorNG(0, 0);
QRect rc = m_transformed.rect();
if (m_colorProperties->useRandomHSV && m_transfo) {
for (int y = rc.y(); y < rc.y() + rc.height(); y++) {
for (int x = rc.x(); x < rc.x() + rc.width(); x++) {
ac->moveTo(x, y);
m_transfo->transform(ac->rawData(), ac->rawData() , 1);
}
}
}
ix = qRound(nx + x - rc.width() * 0.5);
iy = qRound(ny + y - rc.height() * 0.5);
m_painter->bitBlt(QPoint(ix, iy), m_imageDevice, rc);
m_imageDevice->clear();
break;
}
}
}
// Auto-brush
}
else {
QPointF hotSpot = m_brush->hotSpot(particleScale, particleScale, -rotationZ, info);
QPointF pos(nx + x, ny + y);
QPointF pt = pos - hotSpot;
qint32 ix;
qreal xFraction;
qint32 iy;
qreal yFraction;
KisPaintOp::splitCoordinate(pt.x(), &ix, &xFraction);
KisPaintOp::splitCoordinate(pt.y(), &iy, &yFraction);
//KisFixedPaintDeviceSP dab;
if (m_brush->brushType() == IMAGE ||
m_brush->brushType() == PIPE_IMAGE) {
m_fixedDab = m_brush->paintDevice(m_fixedDab->colorSpace(), particleScale, -rotationZ, info, xFraction, yFraction);
if (m_colorProperties->useRandomHSV && m_transfo) {
quint8 * dabPointer = m_fixedDab->data();
int pixelCount = m_fixedDab->bounds().width() * m_fixedDab->bounds().height();
m_transfo->transform(dabPointer, dabPointer, pixelCount);
}
}
else {
m_brush->mask(m_fixedDab, m_inkColor, particleScale, particleScale, -rotationZ, info, xFraction, yFraction);
}
m_painter->bltFixed(QPoint(ix, iy), m_fixedDab, m_fixedDab->bounds());
}
}
// recover from jittering of color,
// m_inkColor.opacity is recovered with every paint
}
void SetRotateObjectAtZ(float aAngle)
{
CU::Vector3f rotationAngle(locDLLApplication->GetModel()->GetManualRotationAngle());
rotationAngle.z = aAngle;
locDLLApplication->GetModel()->SetManualRotationAngle(rotationAngle);
}
DrawingItemPoint* DrawingItemGroup::cornerPoint(Qt::Corner corner) const
{
DrawingItemPoint* itemPoint = nullptr;
bool lFlipped = isFlipped();
qreal lRotationAngle = rotationAngle();
switch (corner)
{
case Qt::TopRightCorner:
if (lFlipped)
{
if (lRotationAngle == 90.0) itemPoint = point(3);
else if (lRotationAngle == 180.0) itemPoint = point(1);
else if (lRotationAngle == 270.0) itemPoint = point(2);
else itemPoint = point(0);
}
else
{
if (lRotationAngle == 90.0) itemPoint = point(0);
else if (lRotationAngle == 180.0) itemPoint = point(3);
else if (lRotationAngle == 270.0) itemPoint = point(1);
else itemPoint = point(2);
}
break;
case Qt::BottomRightCorner:
if (lFlipped)
{
if (lRotationAngle == 90.0) itemPoint = point(1);
else if (lRotationAngle == 180.0) itemPoint = point(2);
else if (lRotationAngle == 270.0) itemPoint = point(0);
else itemPoint = point(3);
}
else
{
if (lRotationAngle == 90.0) itemPoint = point(2);
else if (lRotationAngle == 180.0) itemPoint = point(0);
else if (lRotationAngle == 270.0) itemPoint = point(3);
else itemPoint = point(1);
}
break;
case Qt::BottomLeftCorner:
if (lFlipped)
{
if (lRotationAngle == 90.0) itemPoint = point(2);
else if (lRotationAngle == 180.0) itemPoint = point(0);
else if (lRotationAngle == 270.0) itemPoint = point(3);
else itemPoint = point(1);
}
else
{
if (lRotationAngle == 90.0) itemPoint = point(1);
else if (lRotationAngle == 180.0) itemPoint = point(2);
else if (lRotationAngle == 270.0) itemPoint = point(0);
else itemPoint = point(3);
}
break;
default: // Qt::TopLeftCorner
if (lFlipped)
{
if (lRotationAngle == 90.0) itemPoint = point(0);
else if (lRotationAngle == 180.0) itemPoint = point(3);
else if (lRotationAngle == 270.0) itemPoint = point(1);
else itemPoint = point(2);
}
else
{
if (lRotationAngle == 90.0) itemPoint = point(3);
else if (lRotationAngle == 180.0) itemPoint = point(1);
else if (lRotationAngle == 270.0) itemPoint = point(2);
else itemPoint = point(0);
}
break;
}
return itemPoint;
}
void Foam::cyclicGgiPolyPatch::checkDefinition() const
{
// A little bit of sanity check The rotation angle/axis is
// specified in both the master and slave patch of the
// cyclicGgi. This is a pain, but the other alternatives
// would be:
//
// - Specify in only of the two patches boundary
// definition : - which one to chose? - which default
// value to chose for the non-initialized value - Use a
// specific dictionary for this... Nope, too cumbersome.
//
// So, we impose that the boundary definition of both
// patches must specify the same information If not, well,
// we stop the simulation and ask for a fix.
if (!active())
{
// No need to check anything, the shadow is not initialized properly.
// This will happen with blockMesh when defining cyclicGGI patches.
// Return quietly
return;
}
if
(
(mag(rotationAngle()) - mag(cyclicShadow().rotationAngle())) > SMALL
|| cmptSum(rotationAxis() - cyclicShadow().rotationAxis()) > SMALL
)
{
FatalErrorIn("void cyclicGgiPolyPatch::check() const")
<< " Rotation angle for patch name : "
<< name() << " is: " << rotationAngle()
<< " axis: " << rotationAxis() << nl
<< " Rotation angle for shadow patch name: "
<< shadowName() << " is: "
<< cyclicShadow().rotationAngle() << " axis: "
<< cyclicShadow().rotationAxis() << nl
<< " Both values need to be opposite in "
<< "the boundary file. "
<< abort(FatalError);
}
if
(
(mag(separationOffset() + cyclicShadow().separationOffset())) > SMALL
)
{
FatalErrorIn("void cyclicGgiPolyPatch::check() const")
<< "Separation offset for patch name : "
<< name() << " is: " << separationOffset()
<< " Separation offset for shadow patch name: "
<< shadowName() << " is: "
<< cyclicShadow().separationOffset() << " axis: "
<< " Both values need to be opposite in "
<< "the boundary file. "
<< abort(FatalError);
}
if (debug > 1 && master())
{
Info<< "Writing transformed slave patch as VTK." << nl
<< "Master: " << name()
<< " Slave: " << shadowName()
<< " Angle (master to slave): " << rotationAngle() << " deg"
<< " Axis: " << rotationAxis()
<< " Separation: " << separationOffset() << endl;
const polyMesh& mesh = boundaryMesh().mesh();
fileName fvPath(mesh.time().path()/"VTK");
mkDir(fvPath);
pointField transformedPoints = cyclicShadow().localPoints();
tensor rot = RodriguesRotation(rotationAxis_, -rotationAngle_);
transform(transformedPoints, rot, transformedPoints);
// Add separation offset to transformed points. HJ, 24/Nov/2009
transformedPoints += cyclicShadow().separationOffset();
standAlonePatch::writeVTK
(
fvPath/fileName("cyclicGgi" + name() + cyclicShadow().name()),
cyclicShadow().localFaces(),
transformedPoints
);
}
}