File indexing completed on 2024-12-22 04:14:22

 /*
  * SPDX-FileCopyrightText: 2008 Cyrille Berger <cberger@cberger.net>
  * SPDX-FileCopyrightText: 2010 Geoffry Song <goffrie@gmail.com>
  * SPDX-FileCopyrightText: 2014 Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  * SPDX-FileCopyrightText: 2017 Scott Petrovic <scottpetrovic@gmail.com>
  *
  *  SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 #include "CurvilinearPerspectiveAssistant.h"
 
 #include "kis_debug.h"
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QPainterPath>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 #include <kis_algebra_2d.h>
 
 #include <math.h>
 #include <limits>
 
 CurvilinearPerspectiveAssistant::CurvilinearPerspectiveAssistant()
     : KisPaintingAssistant("curvilinear-perspective", i18n("Curvilinear Perspective assistant"))
 {
 }
 
 CurvilinearPerspectiveAssistant::CurvilinearPerspectiveAssistant(const CurvilinearPerspectiveAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisPaintingAssistant(rhs, handleMap)
 {
 }
 
 KisPaintingAssistantSP CurvilinearPerspectiveAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new CurvilinearPerspectiveAssistant(*this, handleMap));
 }
 
 void CurvilinearPerspectiveAssistant::adjustLine(QPointF &point, QPointF &strokeBegin)
 {
     point = QPointF();
     strokeBegin = QPointF();
 }
 
 void CurvilinearPerspectiveAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     Q_UNUSED(cached);
     Q_UNUSED(updateRect);
 
     gc.save();
     gc.resetTransform();
     
     if (isSnappingActive()) {
 
         QTransform initialTransform = converter->documentToWidgetTransform();
         QPainterPath baseGuidePath;
         QPainterPath mouseGuidePath;
 
         gc.setTransform(initialTransform);
 
         /*
          * Curvilinear perspective is created by circular arcs that intersect 2 vanishing points.
          * As such, the center of the circle and the radius of the circle need to be determined.
          * 
          * Create guidelines by selecting incremental multipliers for the assistant size between [-1, 1),
          * and calculating the center location and radius of the circle to include the point 
          * at the location specified by the multiplier (the "arbitary point").
          * 
          * Formulas: 
          * Radius^2 = HalfHandleDist^2 + CenterDist^2 (b.c. The circle must include both vanishing points.)
          * Radius^2 = (CenterDist + Multiplier * HalfHandleDist)^2 (b.c. The circle must include the arbitrary point)
          * 
          * Solve for CenterDist and Radius:
          * CenterDist = HalfHandleDist * (1 - Multipler * Multiplier) / ( 2 * Multiplier)
          * Radius     = HalfHandleDist * (1 + Multipler * Multiplier) / ( 2 * Multiplier)
          * 
          */
         
         QPointF p1 = *handles()[0];
         QPointF p2 = *handles()[1];
 
         double deltaX = p2.x() - p1.x();
         double deltaY = p2.y() - p1.y();
 
         // Copied from Two-Point Perspective's fading effect for approaching vanishing points.
         // Set up the fading effect for the grid lines
         // Needed so the grid density doesn't look distracting
         QColor color = effectiveAssistantColor();
         QGradient fade = QLinearGradient(
             QPointF(p1.x() - deltaY, p1.y() + deltaX), 
             QPointF(p1.x() + deltaY, p1.y() - deltaX));
         
         color.setAlphaF(0.0);
         fade.setColorAt(0.42, effectiveAssistantColor());
         fade.setColorAt(0.5, color);
         fade.setColorAt(0.58, effectiveAssistantColor());
         const QPen pen = gc.pen();
         const QBrush new_brush = QBrush(fade);
         int width = 0;
         const QPen new_pen = QPen(new_brush, width, pen.style());
         gc.setPen(new_pen);
 
         double handleDistance = KisAlgebra2D::norm(QPointF(deltaX, deltaY));
         double halfHandleDist = handleDistance / 2.0;
 
         double avgX = deltaX / 2.0 + p1.x();
         double avgY = deltaY / 2.0 + p1.y();
 
         // Rotate 90 degrees by formula: (-y, x)
         // Then normalize vector.
         double dirX = -deltaY / handleDistance;
         double dirY = deltaX / handleDistance;
 
         int resolution = halfHandleDist / 3;
 
         if(assistantVisible) {
             
             for(int i = -resolution; i < resolution; i++) {
                 // If i = 0, the circle would be infinitely far away with an infinite radius (aka a line)
                 if(i == 0) {
                     baseGuidePath.moveTo(QPointF(p1.x() - deltaX*2, p1.y() - deltaY*2));
                     baseGuidePath.lineTo(QPointF(p2.x() + deltaX*2, p2.y() + deltaY*2));
                     continue;
                 }
                 // Map loop iterator to multiplier. This line gives the depth-like effect.
                 double mult = 1.0 / i;
                 // Use formula to calculate CenterDist
                 double centerDist = halfHandleDist * (1 - pow2(mult)) / (2*mult);
 
                 // Use the distance to the center (from the average point) to calculate the center location.
                 double circleCenterX = centerDist * dirX + avgX;
                 double circleCenterY = centerDist * dirY + avgY;
                 // Use formula to calculate Radius
                 double radius = halfHandleDist * (1 + pow2(mult)) / (2*mult);
 
                 baseGuidePath.addEllipse(QPointF(circleCenterX, circleCenterY), radius, radius);
 
             }
             gc.drawPath(baseGuidePath);//drawPath(gc, baseGuidePath);
         }
         
         if(previewVisible) {
             // Draw guideline for the mouse, based on mouse position.
             QPointF mousePos = effectiveBrushPosition(converter, canvas);
             // Get location on the screen of handles.
             QPointF screenP1 = initialTransform.map(*handles()[0]);
             QPointF screenP2 = initialTransform.map(*handles()[1]);
             // Don't draw if mouse is too close to vanishing points (will flicker if not)
             // Use distance squared to avoid expensive sqrt.
             if(
                 kisSquareDistance(mousePos, screenP2) > 9 &&
                 kisSquareDistance(mousePos, screenP1) > 9
             ) {
                 QLineF circle = identifyCircle(initialTransform.inverted().map(mousePos));
                 double radius = circle.length();
                 mouseGuidePath.addEllipse(circle.p1(), radius, radius);
             }
 
             gc.drawPath(mouseGuidePath);//drawPath(gc, mouseGuidePath);
         }
 
     }
     gc.restore();
 
     //KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 
 }
 
 void CurvilinearPerspectiveAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     Q_UNUSED(gc);
     Q_UNUSED(converter);
     Q_UNUSED(assistantVisible);
 }
 
 QLineF CurvilinearPerspectiveAssistant::identifyCircle(const QPointF thirdPoint) {
     /*
     * Calculate center location and radius for an arbitrary point (usually the mouse location).
     * Given Formulas:
     * Radius^2 = HalfHandleDist^2 + CenterDist^2
     * avgX + CenterDist * dirX = CenterX
     * avgY + CenterDist * dirY = CenterY
     * 
     * For ease of use, let BetaX = MouseX - AvgX, BetaY = MouseY - AvgY
     * Calculated Formula for CenterDist:
     * CenterDist = (BetaX^2 + BetaY^2 - HalfHandleDist^2) / (2 * DirY * BetaX + 2 * DirY * BetaY)
     * 
     * Returns line from center to the arbitrary point.
     * 
     */
     QPointF p1 = *handles()[0];
     QPointF p2 = *handles()[1];
 
     double deltaX = p2.x() - p1.x();
     double deltaY = p2.y() - p1.y();
 
     double handleDistance = KisAlgebra2D::norm(QPointF(deltaX, deltaY));
     double halfHandleDist = handleDistance / 2.0;
 
     double avgX = deltaX / 2.0 + p1.x();
     double avgY = deltaY / 2.0 + p1.y();
 
     double dirX = -deltaY / handleDistance;
     double dirY = deltaX / handleDistance;
 
     double betaX = thirdPoint.x() - avgX;
     double betaY = thirdPoint.y() - avgY;
 
     double centerDist = 
         (pow2(betaX) + pow2(betaY) - pow2(halfHandleDist)) 
         / 
         (2 * dirX * betaX + 2 * dirY * betaY);
     
     double circleCenterX = centerDist*dirX + avgX;
     double circleCenterY = centerDist*dirY + avgY;
     return QLineF(QPointF(circleCenterX, circleCenterY), thirdPoint);
 }
 
 QPointF CurvilinearPerspectiveAssistant::adjustPosition(const QPointF& pt, const QPointF& strokeBegin, const bool /*snapToAny*/, qreal /*moveThresholdPt*/)
 {
     // Get the center and radius for the given point
     QLineF initialCircle = identifyCircle(strokeBegin);
 
     // Set the new point onto the circle.
     QLineF magnetizedCircle(initialCircle.p1(), pt);
     magnetizedCircle.setLength(initialCircle.length());
 
     return magnetizedCircle.p2();
 
 }
 
 QPointF CurvilinearPerspectiveAssistant::getDefaultEditorPosition() const
 {
     return (*handles()[0] + *handles()[1]) * 0.5;
 }
 
 bool CurvilinearPerspectiveAssistant::isAssistantComplete() const
 {
     return handles().size() >= 2;
 }
 
 
 CurvilinearPerspectiveAssistantFactory::CurvilinearPerspectiveAssistantFactory()
 {
 }
 
 CurvilinearPerspectiveAssistantFactory::~CurvilinearPerspectiveAssistantFactory()
 {
 }
 
 QString CurvilinearPerspectiveAssistantFactory::id() const
 {
     return "curvilinear-perspective";
 }
 
 QString CurvilinearPerspectiveAssistantFactory::name() const
 {
     return i18n("Curvilinear Perspective");
 }
 
 KisPaintingAssistant* CurvilinearPerspectiveAssistantFactory::createPaintingAssistant() const
 {
     return new CurvilinearPerspectiveAssistant;
 }