Krita Source Code Documentation
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Private Member Functions | Friends | List of all members
KisBezierTransformMeshDetail::KisBezierTransformMesh Class Reference

#include <KisBezierTransformMesh.h>

+ Inheritance diagram for KisBezierTransformMeshDetail::KisBezierTransformMesh:

Public Member Functions

QRect approxChangeRect (const QRect &rc) const
 
QRect approxNeedRect (const QRect &rc) const
 
PatchIndex hitTestPatch (const QPointF &pt, QPointF *localPointResult=0) const
 
QRect hitTestPatchInSourceSpace (const QRectF &rect) const
 
 KisBezierTransformMesh ()
 
 KisBezierTransformMesh (const QRectF &srcRect, const QSize &size=QSize(2, 2))
 
void transformMesh (const QPoint &srcQImageOffset, const QImage &srcImage, const QPoint &dstQImageOffset, QImage *dstImage) const
 
void transformMesh (KisPaintDeviceSP srcDevice, KisPaintDeviceSP dstDevice) const
 
- Public Member Functions inherited from KisBezierMeshDetails::Mesh< NodeArg, PatchArg >
control_point_iterator beginControlPoints ()
 
control_point_const_iterator beginControlPoints () const
 
patch_iterator beginPatches ()
 
patch_const_iterator beginPatches () const
 
segment_iterator beginSegments ()
 
segment_const_iterator beginSegments () const
 
control_point_const_iterator constBeginControlPoints () const
 
patch_const_iterator constBeginPatches () const
 
segment_const_iterator constBeginSegments () const
 
control_point_const_iterator constEndControlPoints () const
 
patch_const_iterator constEndPatches () const
 
segment_const_iterator constEndSegments () const
 
control_point_const_iterator constFind (const ControlPointIndex &index) const
 
control_point_const_iterator constFind (const NodeIndex &index) const
 
patch_const_iterator constFind (const PatchIndex &index) const
 
segment_const_iterator constFind (const SegmentIndex &index) const
 
QRectF dstBoundingRect () const
 
control_point_iterator endControlPoints ()
 
control_point_const_iterator endControlPoints () const
 
patch_iterator endPatches ()
 
patch_const_iterator endPatches () const
 
segment_iterator endSegments ()
 
segment_const_iterator endSegments () const
 
control_point_iterator find (const ControlPointIndex &index)
 
control_point_const_iterator find (const ControlPointIndex &index) const
 
control_point_iterator find (const NodeIndex &index)
 
control_point_const_iterator find (const NodeIndex &index) const
 
patch_iterator find (const PatchIndex &index)
 
patch_const_iterator find (const PatchIndex &index) const
 
segment_iterator find (const SegmentIndex &index)
 
segment_const_iterator find (const SegmentIndex &index) const
 
ControlPointIndex hitTestControlPoint (const QPointF &pt, qreal distanceThreshold) const
 
ControlPointIndex hitTestNode (const QPointF &pt, qreal distanceThreshold) const
 
SegmentIndex hitTestSegment (const QPointF &pt, qreal distanceThreshold, qreal *t=0) const
 
bool isIdentity () const
 
template<typename T >
bool isIndexValid (const T &index) const
 
Patch makePatch (const PatchIndex &index) const
 
Patch makePatch (int col, int row) const
 
 Mesh ()
 
 Mesh (const QRectF &mapRect, const QSize &size=QSize(2, 2))
 
Node & node (const NodeIndex &index)
 
const Node & node (const NodeIndex &index) const
 
Node & node (int col, int row)
 
const Node & node (int col, int row) const
 
bool operator== (const Mesh &rhs) const
 
QRectF originalRect () const
 
void removeColumn (int column)
 
void removeColumnOrRow (NodeIndex index, bool row)
 
void removeRow (int row)
 
void reshapeMeshHorizontally (int numColumns)
 
void reshapeMeshVertically (int numRows)
 
QSize size () const
 
int subdivideColumn (int leftColumn, qreal relProportionalT)
 
int subdivideColumn (qreal proportionalT)
 
int subdivideRow (int topRow, qreal relProportionalT)
 
int subdivideRow (qreal proportionalT)
 
void subdivideSegment (SegmentIndex index, qreal proportionalT)
 
void transform (const QTransform &t)
 
void transformSrcAndDst (const QTransform &t)
 
void translate (const QPointF &offset)
 

Static Public Member Functions

static QRectF calcTightSrcRectRangeInParamSpace (const KisBezierPatch &patch, const QRectF &srcSpaceRect, qreal srcPrecision)
 
static void transformPatch (const KisBezierPatch &patch, const QPoint &srcQImageOffset, const QImage &srcImage, const QPoint &dstQImageOffset, QImage *dstImage)
 
static void transformPatch (const KisBezierPatch &patch, KisPaintDeviceSP srcDevice, KisPaintDeviceSP dstDevice)
 

Private Member Functions

patch_const_iterator hitTestPatchImpl (const QPointF &pt, QPointF *localPointResult=0) const
 

Friends

KRITAIMAGE_EXPORT bool loadValue (const QDomElement &parent, KisBezierTransformMesh *mesh)
 
KRITAIMAGE_EXPORT void saveValue (QDomElement *parent, const QString &tag, const KisBezierTransformMesh &mesh)
 

Additional Inherited Members

- Public Types inherited from KisBezierMeshDetails::Mesh< NodeArg, PatchArg >
using control_point_const_iterator = control_point_iterator_impl<true>
 
using control_point_iterator = control_point_iterator_impl<false>
 
using ControlType = typename ControlPointIndex::ControlType
 
using Node = NodeArg
 
using Patch = PatchArg
 
using patch_const_iterator = patch_iterator_impl<true>
 
using patch_iterator = patch_iterator_impl<false>
 
using segment_const_iterator = segment_iterator_impl<true>
 
using segment_iterator = segment_iterator_impl<false>
 
using SegmentIndex = std::pair<NodeIndex, int>
 
- Protected Attributes inherited from KisBezierMeshDetails::Mesh< NodeArg, PatchArg >
std::vector< qreal > m_columns
 
std::vector< Node > m_nodes
 
QRectF m_originalRect
 
std::vector< qreal > m_rows
 
QSize m_size
 

Detailed Description

Definition at line 17 of file KisBezierTransformMesh.h.

Constructor & Destructor Documentation

◆ KisBezierTransformMesh() [1/2]

KisBezierTransformMeshDetail::KisBezierTransformMesh::KisBezierTransformMesh ( )
inline

Definition at line 20 of file KisBezierTransformMesh.h.

21 {
22 }

◆ KisBezierTransformMesh() [2/2]

KisBezierTransformMeshDetail::KisBezierTransformMesh::KisBezierTransformMesh ( const QRectF & srcRect,
const QSize & size = QSize(2,2) )
inline

Definition at line 23 of file KisBezierTransformMesh.h.

24 : KisBezierMesh(srcRect, size)
25 {
26 }
KisBezierMesh
KisBezierMeshDetails::Mesh< KisBezierMeshDetails::BaseMeshNode, KisBezierPatch > KisBezierMesh
Definition KisBezierMesh.h:1553

Member Function Documentation

◆ approxChangeRect()

QRect KisBezierTransformMesh::approxChangeRect ( const QRect & rc) const

Definition at line 333 of file KisBezierTransformMesh.cpp.

334{
335 QRect result;
336
337 const QRect affectedPatches = hitTestPatchInSourceSpace(rc);
338
339 for (int row = affectedPatches.top(); row <= affectedPatches.bottom(); row++) {
340 for (int column = affectedPatches.left(); column <= affectedPatches.right(); column++) {
341 const KisBezierPatch patch = *find(PatchIndex(column, row));
342 const QRectF srcRect = QRectF(rc) & patch.srcBoundingRect();
343 const QRectF paramRect = calcTightSrcRectRangeInParamSpace(patch, srcRect, 0.1);
344
345 KisSampleRectIterator paramRectSampler(paramRect);
346 QRect patchResultRect;
347 QRectF stepRect;
348
349 while (1) {
350 for (int i = 0; i < 10; i++) {
351 const QPointF sampledParamPoint = *paramRectSampler++;
352 const QPointF globalPoint = patch.localToGlobal(sampledParamPoint);
353 KisAlgebra2D::accumulateBounds(globalPoint, &stepRect);
354 }
355
356 const QRect alignedRect = stepRect.toAlignedRect();
357
358 if (!alignedRect.isEmpty() && alignedRect == patchResultRect) {
359 break;
360 }
361
362 patchResultRect = alignedRect;
363
364 if (paramRectSampler.numSamples() > 2000) {
365 qWarning() << "KisBezierTransformMesh::approxChangeRect: the algorithm hasn't converged!"
366 << ppVar(result) << ppVar(patchResultRect) << ppVar(stepRect);
367 break;
368 }
369 }
370
371 result |= patchResultRect;
372 }
373 }
374
375 return result;
376}
KisBezierMeshDetails::Mesh::find
control_point_iterator find(const ControlPointIndex &index)
Definition KisBezierMesh.h:1000
KisBezierPatch::localToGlobal
QPointF localToGlobal(const QPointF &pt) const
Definition KisBezierPatch.cpp:29
KisBezierPatch::srcBoundingRect
QRectF srcBoundingRect() const
Definition KisBezierPatch.cpp:25
KisBezierTransformMeshDetail::KisBezierTransformMesh::calcTightSrcRectRangeInParamSpace
static QRectF calcTightSrcRectRangeInParamSpace(const KisBezierPatch &patch, const QRectF &srcSpaceRect, qreal srcPrecision)
Definition KisBezierTransformMesh.cpp:383
ppVar
#define ppVar(var)
Definition kis_debug.h:155
KisAlgebra2D::accumulateBounds
void accumulateBounds(const Point &pt, Rect *bounds)
Definition kis_algebra_2d.h:227

References KisAlgebra2D::accumulateBounds(), calcTightSrcRectRangeInParamSpace(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::find(), hitTestPatchInSourceSpace(), KisBezierPatch::localToGlobal(), KisSampleRectIterator::numSamples(), ppVar, and KisBezierPatch::srcBoundingRect().

◆ approxNeedRect()

QRect KisBezierTransformMesh::approxNeedRect ( const QRect & rc) const

First, try to approximate the bounding need rect by sampling control points. That is the main property of bezier curves: the resulting curve is always contained inside the control polygon.

TODO: sample the whole wrapping polygon in a more uniform way, that is, sample the whole perimeter of the patch.

the number of points that has actually been sampled from the destination rect

We don't warn if the "found" rect is empty, that is a perfectly valid case.

Definition at line 132 of file KisBezierTransformMesh.cpp.

133{
134 QRect result;
135
136 const QRect sampleRect = rc & dstBoundingRect().toAlignedRect();
137 if (sampleRect.isEmpty()) return result;
138
139 const QRectF unitRect(0, 0, 1, 1);
140 const int samplesLimit = sampleRect.width() * sampleRect.height() / 2;
141
142 QRectF stepRect;
143
144 {
155 const QRectF dstRect = rc;
156
157 auto tryAddHandle = [&dstRect, &stepRect] (const KisBezierPatch &patch, KisBezierPatch::ControlPointType controlType) {
158
159 auto fetchLocalPoint =
160 [] (const KisBezierPatch &patch,
161 KisBezierPatch::ControlPointType c0,
162 KisBezierPatch::ControlPointType c1,
163 KisBezierPatch::ControlPointType c2,
164 KisBezierPatch::ControlPointType c3) {
165
166 const qreal handleLength = kisDistance(patch.points[c0], patch.points[c1]);
167 const qreal totalLength = handleLength +
168 kisDistance(patch.points[c1], patch.points[c2]) +
169 kisDistance(patch.points[c2], patch.points[c3]);
170
171 return KisAlgebra2D::lerp(patch.originalRect.topLeft(), patch.originalRect.topRight(),
172 handleLength / totalLength);
173 };
174
175 if (dstRect.contains(patch.points[controlType])) {
176 QPointF localPoint;
177
178 switch (controlType) {
179 case KisBezierPatch::TL:
180 localPoint = patch.originalRect.topLeft();
181 break;
182 case KisBezierPatch::TL_HC: {
183 localPoint = fetchLocalPoint(patch,
184 KisBezierPatch::TL,
185 KisBezierPatch::TL_HC,
186 KisBezierPatch::TR_HC,
187 KisBezierPatch::TR);
188 break;
189 }
190 case KisBezierPatch::TL_VC:
191 localPoint = fetchLocalPoint(patch,
192 KisBezierPatch::TL,
193 KisBezierPatch::TL_VC,
194 KisBezierPatch::BL_VC,
195 KisBezierPatch::BL);
196 break;
197 case KisBezierPatch::TR:
198 localPoint = patch.originalRect.topRight();
199 break;
200 case KisBezierPatch::TR_HC:
201 localPoint = fetchLocalPoint(patch,
202 KisBezierPatch::TR,
203 KisBezierPatch::TR_HC,
204 KisBezierPatch::TL_HC,
205 KisBezierPatch::TL);
206 break;
207 case KisBezierPatch::TR_VC:
208 localPoint = fetchLocalPoint(patch,
209 KisBezierPatch::TR,
210 KisBezierPatch::TR_VC,
211 KisBezierPatch::BR_VC,
212 KisBezierPatch::BR);
213
214 break;
215 case KisBezierPatch::BL:
216 localPoint = patch.originalRect.bottomLeft();
217 break;
218 case KisBezierPatch::BL_HC:
219 localPoint = fetchLocalPoint(patch,
220 KisBezierPatch::BL,
221 KisBezierPatch::BL_HC,
222 KisBezierPatch::BR_HC,
223 KisBezierPatch::BR);
224 break;
225 case KisBezierPatch::BL_VC:
226 localPoint = fetchLocalPoint(patch,
227 KisBezierPatch::BL,
228 KisBezierPatch::BL_VC,
229 KisBezierPatch::TL_VC,
230 KisBezierPatch::TL);
231 break;
232 case KisBezierPatch::BR:
233 localPoint = patch.originalRect.bottomRight();
234 break;
235 case KisBezierPatch::BR_HC:
236 localPoint = fetchLocalPoint(patch,
237 KisBezierPatch::BR,
238 KisBezierPatch::BR_HC,
239 KisBezierPatch::BL_HC,
240 KisBezierPatch::BL);
241 break;
242 case KisBezierPatch::BR_VC:
243 localPoint = fetchLocalPoint(patch,
244 KisBezierPatch::BR,
245 KisBezierPatch::BR_VC,
246 KisBezierPatch::TR_VC,
247 KisBezierPatch::TR);
248
249 break;
250 }
251
252 KisAlgebra2D::accumulateBounds(localPoint, &stepRect);
253 }
254 };
255
256 for (auto it = beginPatches(); it != endPatches(); ++it) {
257 tryAddHandle(*it, KisBezierPatch::TL);
258 tryAddHandle(*it, KisBezierPatch::TL_HC);
259 tryAddHandle(*it, KisBezierPatch::TL_VC);
260
261 tryAddHandle(*it, KisBezierPatch::TR);
262 tryAddHandle(*it, KisBezierPatch::TR_HC);
263 tryAddHandle(*it, KisBezierPatch::TR_VC);
264
265 tryAddHandle(*it, KisBezierPatch::BL);
266 tryAddHandle(*it, KisBezierPatch::BL_HC);
267 tryAddHandle(*it, KisBezierPatch::BL_VC);
268
269 tryAddHandle(*it, KisBezierPatch::BR);
270 tryAddHandle(*it, KisBezierPatch::BR_HC);
271 tryAddHandle(*it, KisBezierPatch::BR_VC);
272 }
273 }
274
275 KisSampleRectIterator dstRectSampler(sampleRect);
276 KisBezierPatch patch = *beginPatches();
277 KisBezierPatchParamToSourceSampler patchSampler(patch);
278
281 int hitPoints = 0;
282
283 while (1) {
284 for (int i = 0; i < 10; i++) {
285 const QPointF dstPoint = *dstRectSampler++;
286
287 if (patch.dstBoundingRect().contains(dstPoint)) {
288 const QPointF localPoint = patch.globalToLocal(dstPoint);
289 if (unitRect.contains(localPoint)) {
290 KisAlgebra2D::accumulateBounds(patchSampler.point(localPoint), &stepRect);
291 hitPoints++;
292 continue;
293 }
294 }
295
296 {
297 QPointF localPoint;
298 auto it = hitTestPatchImpl(dstPoint, &localPoint);
299 if (it != endPatches()) {
300 patch = *it;
301 patchSampler = KisBezierPatchParamToSourceSampler(patch);
302
303 KisAlgebra2D::accumulateBounds(patchSampler.point(localPoint), &stepRect);
304 hitPoints++;
305 }
306 }
307 }
308
309 QRect alignedRect = stepRect.toAlignedRect();
310
311 if (hitPoints > 20 && !alignedRect.isEmpty() && alignedRect == result) {
312 break;
313 }
314
315 result = alignedRect;
316
317 if (dstRectSampler.numSamples() > qMin(2000, samplesLimit)) {
322 if (!result.isEmpty()) {
323 qWarning() << "KisBezierTransformMesh::approxNeedRect: the algorithm hasn't converged!"
324 << ppVar(hitPoints) << ppVar(stepRect) << ppVar(alignedRect) << ppVar(result);
325 }
326 break;
327 }
328 }
329
330 return result;
331}
dstPoint
QPointF dstPoint
Definition KisBezierUtils.cpp:504
KisBezierMeshDetails::Mesh::endPatches
patch_iterator endPatches()
Definition KisBezierMesh.h:980
KisBezierMeshDetails::Mesh::beginPatches
patch_iterator beginPatches()
Definition KisBezierMesh.h:976
KisBezierPatch::dstBoundingRect
QRectF dstBoundingRect() const
Definition KisBezierPatch.cpp:15
KisBezierPatch::points
std::array< QPointF, 12 > points
Definition KisBezierPatch.h:36
KisBezierPatch::globalToLocal
QPointF globalToLocal(const QPointF &pt) const
Definition KisBezierPatch.cpp:34
KisBezierTransformMeshDetail::KisBezierTransformMesh::hitTestPatchImpl
patch_const_iterator hitTestPatchImpl(const QPointF &pt, QPointF *localPointResult=0) const
Definition KisBezierTransformMesh.cpp:16
kisDistance
qreal kisDistance(const QPointF &pt1, const QPointF &pt2)
Definition kis_global.h:190
KisAlgebra2D::lerp
Point lerp(const Point &pt1, const Point &pt2, qreal t)
Definition kis_algebra_2d.h:74

References KisAlgebra2D::accumulateBounds(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::beginPatches(), KisBezierPatch::BL, KisBezierPatch::BL_HC, KisBezierPatch::BL_VC, KisBezierPatch::BR, KisBezierPatch::BR_HC, KisBezierPatch::BR_VC, KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::dstBoundingRect(), KisBezierPatch::dstBoundingRect(), dstPoint, KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::endPatches(), KisBezierPatch::globalToLocal(), hitTestPatchImpl(), kisDistance(), KisAlgebra2D::lerp(), KisSampleRectIterator::numSamples(), KisBezierPatch::originalRect, KisBezierPatchParamToSourceSampler::point(), KisBezierPatch::points, ppVar, KisBezierPatch::TL, KisBezierPatch::TL_HC, KisBezierPatch::TL_VC, KisBezierPatch::TR, KisBezierPatch::TR_HC, and KisBezierPatch::TR_VC.

◆ calcTightSrcRectRangeInParamSpace()

QRectF KisBezierTransformMesh::calcTightSrcRectRangeInParamSpace ( const KisBezierPatch & patch,
const QRectF & srcSpaceRect,
qreal srcPrecision )
static

Approximate the param-space rect that corresponds to srcSpaceRect in the source-space. The resulting param-space rect will fully cover the source-space rect (and will be bigger).

Definition at line 383 of file KisBezierTransformMesh.cpp.

384{
385 using KisBezierUtils::Range;
386 using KisBezierUtils::calcTightSrcRectRangeInParamSpace1D;
387
388 KIS_ASSERT_RECOVER_NOOP(patch.srcBoundingRect().contains(srcSpaceRect));
389
390 KisBezierPatchParamToSourceSampler sampler(patch);
391
392 auto xSampler = [sampler] (qreal xParam) -> Range {
393 return sampler.xRange(xParam);
394 };
395
396 auto ySampler = [sampler] (qreal yParam) -> Range {
397 return sampler.yRange(yParam);
398 };
399
400 Range externalRangeX;
401 Range internalRangeX;
402
403 Range externalRangeY;
404 Range internalRangeY;
405
406 std::tie(externalRangeX, internalRangeX) =
407 calcTightSrcRectRangeInParamSpace1D({0.0, 1.0},
408 Range::fromRectX(patch.originalRect),
409 Range::fromRectX(srcSpaceRect),
410 xSampler, srcPrecision);
411
412 std::tie(externalRangeY, internalRangeY) =
413 calcTightSrcRectRangeInParamSpace1D({0.0, 1.0},
414 Range::fromRectY(patch.originalRect),
415 Range::fromRectY(srcSpaceRect),
416 ySampler, srcPrecision);
417
418 return Range::makeRectF(externalRangeX, externalRangeY);
419}
KIS_ASSERT_RECOVER_NOOP
#define KIS_ASSERT_RECOVER_NOOP(cond)
Definition kis_assert.h:97
KisBezierUtils::calcTightSrcRectRangeInParamSpace1D
std::pair< Range, Range > calcTightSrcRectRangeInParamSpace1D(const Range &searchParamRange, const Range &searchSrcRange, const Range &rect, Func func, qreal srcPrecision, std::optional< Range > squeezeRange=std::nullopt)
Definition KisBezierPatchParamSpaceUtils.h:135

References KisBezierUtils::calcTightSrcRectRangeInParamSpace1D(), KIS_ASSERT_RECOVER_NOOP, KisBezierPatch::originalRect, KisBezierPatch::srcBoundingRect(), KisBezierPatchParamToSourceSampler::xRange(), and KisBezierPatchParamToSourceSampler::yRange().

◆ hitTestPatch()

KisBezierTransformMesh::PatchIndex KisBezierTransformMesh::hitTestPatch ( const QPointF & pt,
QPointF * localPointResult = 0 ) const

Definition at line 43 of file KisBezierTransformMesh.cpp.

44{
45 return hitTestPatchImpl(pt, localPointResult).patchIndex();
46}
KisBezierMeshDetails::Mesh::patch_iterator_impl::patchIndex
Mesh::PatchIndex patchIndex() const
Definition KisBezierMesh.h:272

References hitTestPatchImpl(), and KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::patch_iterator_impl< is_const >::patchIndex().

◆ hitTestPatchImpl()

KisBezierTransformMesh::patch_const_iterator KisBezierTransformMesh::hitTestPatchImpl ( const QPointF & pt,
QPointF * localPointResult = 0 ) const
private

Definition at line 16 of file KisBezierTransformMesh.cpp.

17{
18 auto result = endPatches();
19
20 const QRectF unitRect(0, 0, 1, 1);
21
22 for (auto it = beginPatches(); it != endPatches(); ++it) {
23 Patch patch = *it;
24
25 if (patch.dstBoundingRect().contains(pt)) {
26 const QPointF localPos = KisBezierUtils::calculateLocalPos(patch.points, pt);
27
28 if (unitRect.contains(localPos)) {
29
30 if (localPointResult) {
31 *localPointResult = localPos;
32 }
33
34 result = it;
35 break;
36 }
37 }
38 }
39
40 return result;
41}
KisBezierUtils::calculateLocalPos
QPointF calculateLocalPos(const std::array< QPointF, 12 > &points, const QPointF &globalPoint)
calculates local (u,v) coordinates of the patch corresponding to globalPoint
Definition KisBezierUtils.cpp:910

References KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::beginPatches(), KisBezierUtils::calculateLocalPos(), and KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::endPatches().

◆ hitTestPatchInSourceSpace()

QRect KisBezierTransformMesh::hitTestPatchInSourceSpace ( const QRectF & rect) const

Definition at line 48 of file KisBezierTransformMesh.cpp.

49{
50 const QRectF searchRect = rect & m_originalRect;
51
52 if (searchRect.isEmpty()) return QRect();
53
54 const QPointF proportionalTL = KisAlgebra2D::absoluteToRelative(searchRect.topLeft(), m_originalRect);
55 const QPointF proportionalBR = KisAlgebra2D::absoluteToRelative(searchRect.bottomRight(), m_originalRect);
56
57 const auto topItY = prev(upper_bound(m_rows.begin(), prev(m_rows.end()), proportionalTL.y()));
58 const int topRow = distance(m_rows.begin(), topItY);
59
60 const auto leftItX = prev(upper_bound(m_columns.begin(), prev(m_columns.end()), proportionalTL.x()));
61 const int leftColumn = distance(m_columns.begin(), leftItX);
62
63 const auto bottomItY = prev(upper_bound(m_rows.begin(), prev(m_rows.end()), proportionalBR.y()));
64 const int bottomRow = distance(m_rows.begin(), bottomItY);
65
66 const auto rightItX = prev(upper_bound(m_columns.begin(), prev(m_columns.end()), proportionalBR.x()));
67 const int rightColumn = distance(m_columns.begin(), rightItX);
68
69 return QRect(leftColumn, topRow,
70 rightColumn - leftColumn + 1,
71 bottomRow - topRow + 1);
72}
distance
qreal distance(const QPointF &p1, const QPointF &p2)
Definition KoCurveFit.cpp:84
KisBezierMeshDetails::Mesh::m_rows
std::vector< qreal > m_rows
Definition KisBezierMesh.h:1285
KisBezierMeshDetails::Mesh::m_columns
std::vector< qreal > m_columns
Definition KisBezierMesh.h:1286
KisAlgebra2D::absoluteToRelative
QPointF absoluteToRelative(const QPointF &pt, const QRectF &rc)
Definition kis_algebra_2d.h:615

References KisAlgebra2D::absoluteToRelative(), distance(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::m_columns, KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::m_originalRect, and KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::m_rows.

◆ transformMesh() [1/2]

void KisBezierTransformMesh::transformMesh ( const QPoint & srcQImageOffset,
const QImage & srcImage,
const QPoint & dstQImageOffset,
QImage * dstImage ) const

Definition at line 118 of file KisBezierTransformMesh.cpp.

119{
120 for (auto it = beginPatches(); it != endPatches(); ++it) {
121 transformPatch(*it, srcQImageOffset, srcImage, dstQImageOffset, dstImage);
122 }
123}
KisBezierTransformMeshDetail::KisBezierTransformMesh::transformPatch
static void transformPatch(const KisBezierPatch &patch, const QPoint &srcQImageOffset, const QImage &srcImage, const QPoint &dstQImageOffset, QImage *dstImage)
Definition KisBezierTransformMesh.cpp:74

References KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::beginPatches(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::endPatches(), and transformPatch().

◆ transformMesh() [2/2]

void KisBezierTransformMesh::transformMesh ( KisPaintDeviceSP srcDevice,
KisPaintDeviceSP dstDevice ) const

Definition at line 125 of file KisBezierTransformMesh.cpp.

126{
127 for (auto it = beginPatches(); it != endPatches(); ++it) {
128 transformPatch(*it, srcDevice, dstDevice);
129 }
130}

References KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::beginPatches(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::endPatches(), and transformPatch().

◆ transformPatch() [1/2]

void KisBezierTransformMesh::transformPatch ( const KisBezierPatch & patch,
const QPoint & srcQImageOffset,
const QImage & srcImage,
const QPoint & dstQImageOffset,
QImage * dstImage )
static

Definition at line 74 of file KisBezierTransformMesh.cpp.

75{
76 QVector<QPointF> originalPointsLocal;
77 QVector<QPointF> transformedPointsLocal;
78 QSize gridSize;
79
80 patch.sampleRegularGrid(gridSize, originalPointsLocal, transformedPointsLocal, QPointF(8,8));
81
82 const QRect dstBoundsI = patch.dstBoundingRect().toAlignedRect();
83 const QRect imageSize = QRect(dstQImageOffset, dstImage->size());
84 KIS_SAFE_ASSERT_RECOVER_NOOP(imageSize.contains(dstBoundsI));
85
86 {
87 GridIterationTools::QImagePolygonOp polygonOp(srcImage, *dstImage, srcQImageOffset, dstQImageOffset);
88
89 GridIterationTools::RegularGridIndexesOp indexesOp(gridSize);
90 GridIterationTools::iterateThroughGrid
91 <GridIterationTools::AlwaysCompletePolygonPolicy>(polygonOp, indexesOp,
92 gridSize,
93 originalPointsLocal,
94 transformedPointsLocal);
95 }
96}
KisBezierPatch::sampleRegularGrid
void sampleRegularGrid(QSize &gridSize, QVector< QPointF > &origPoints, QVector< QPointF > &transfPoints, const QPointF &dstStep) const
Definition KisBezierPatch.cpp:39
KIS_SAFE_ASSERT_RECOVER_NOOP
#define KIS_SAFE_ASSERT_RECOVER_NOOP(cond)
Definition kis_assert.h:130
GridIterationTools::iterateThroughGrid
void iterateThroughGrid(PolygonOp &polygonOp, IndexesOp &indexesOp, const QSize &gridSize, const QVector< QPointF > &originalPoints, const QVector< QPointF > &transformedPoints)
Definition kis_grid_interpolation_tools.h:601

References KisBezierPatch::dstBoundingRect(), GridIterationTools::iterateThroughGrid(), KIS_SAFE_ASSERT_RECOVER_NOOP, and KisBezierPatch::sampleRegularGrid().

◆ transformPatch() [2/2]

void KisBezierTransformMesh::transformPatch ( const KisBezierPatch & patch,
KisPaintDeviceSP srcDevice,
KisPaintDeviceSP dstDevice )
static

Definition at line 98 of file KisBezierTransformMesh.cpp.

99{
100 QVector<QPointF> originalPointsLocal;
101 QVector<QPointF> transformedPointsLocal;
102 QSize gridSize;
103
104 patch.sampleRegularGrid(gridSize, originalPointsLocal, transformedPointsLocal, QPointF(8,8));
105
106 {
107 GridIterationTools::PaintDevicePolygonOp polygonOp(srcDevice, dstDevice);
108
109 GridIterationTools::RegularGridIndexesOp indexesOp(gridSize);
110 GridIterationTools::iterateThroughGrid
111 <GridIterationTools::AlwaysCompletePolygonPolicy>(polygonOp, indexesOp,
112 gridSize,
113 originalPointsLocal,
114 transformedPointsLocal);
115 }
116}

References GridIterationTools::iterateThroughGrid(), and KisBezierPatch::sampleRegularGrid().

Friends And Related Symbol Documentation

◆ loadValue

KRITAIMAGE_EXPORT bool loadValue ( const QDomElement & parent,
KisBezierTransformMesh * mesh )
friend

◆ saveValue

KRITAIMAGE_EXPORT void saveValue ( QDomElement * parent,
const QString & tag,
const KisBezierTransformMesh & mesh )
friend
The documentation for this class was generated from the following files: