patternselectiontransformation.cpp

#include "patternselectiontransformation.h"
#include "patternselection.h"
#include "pattern.h"
#include "ui/graphicsview.h"
#include "ui/flatsurfaceitem.h"
#include "abstracthelper.h"
#include "ui/mainwindow.h"
#include "contourhelper.h"
#include <QGraphicsScene>
#include <QMouseEvent>
#include <QToolButton>
#include <QStatusBar>
#include <QBitmap>
#include <QtMath>

#define PREVIEW_ALPHA (200)
#define FLOAT_DISPLAY_PRECISION (2)
#define PEN_THICKNESS (2)

// -----------------------------------------------------------------------------
std::tuple<float, float> PatternSelectionTransformation::predictInitialAlignment() const
{
  /// todo:
  const cv::Mat1b gray_mask = cv::imread("tmp/0040/ornament1-mask.png", cv::IMREAD_GRAYSCALE);
  const PolygonPoints reference_polygon_pts = base::ContourHelper::extractMainContourF(base::BinaryMask(gray_mask), false, -1, cv::CHAIN_APPROX_SIMPLE);

  const cv::Point2f reference_center_pt = base::ContourHelper::contourCenter(reference_polygon_pts);
  const cv::Point2f reference_extreme_pt = mostExcentricPoint(reference_polygon_pts, reference_center_pt);
  const cv::Point2f reference_to_extreme_pt = reference_extreme_pt-reference_center_pt;
  const float reference_orientation = atan2f(reference_to_extreme_pt.y, reference_to_extreme_pt.x);

  const cv::Point2f polygon_center_pt = pattern_selection_->polygonCenter();
  const cv::Point2f polygon_extreme_pt = mostExcentricPoint(pattern_selection_->polygonPoints(), polygon_center_pt);
  const cv::Point2f polygon_to_extreme_pt = polygon_extreme_pt-polygon_center_pt;
  const float polygon_orientation = atan2f(polygon_to_extreme_pt.y, polygon_to_extreme_pt.x);

  const float orientation_diff = reference_orientation-polygon_orientation;
  const float r_extreme_ref = sqrtf(reference_to_extreme_pt.x*reference_to_extreme_pt.x+reference_to_extreme_pt.y*reference_to_extreme_pt.y);
  const float r_extreme_poly = sqrtf(polygon_to_extreme_pt.x*polygon_to_extreme_pt.x+polygon_to_extreme_pt.y*polygon_to_extreme_pt.y);
  const float ref_to_polygon_ratio = r_extreme_ref/r_extreme_poly;
  return {orientation_diff, ref_to_polygon_ratio};
}

// -----------------------------------------------------------------------------
cv::Point2f PatternSelectionTransformation::mostExcentricPoint(const PolygonPoints &polygon_pts, cv::Point2f polygon_center)
{
  float max_radius = 0;
  cv::Point2f max_radius_pt;
  for(const cv::Point2f &polygon_pt : polygon_pts)
  {
    const cv::Point2f diff = polygon_pt-polygon_center;
    const float radius = sqrtf(diff.x*diff.x+diff.y*diff.y);
    if(radius > max_radius)
    {
      max_radius = radius;
      max_radius_pt = polygon_pt;
    }
  }
  return max_radius_pt;
}

// -----------------------------------------------------------------------------
void PatternSelectionTransformation::init(float initial_orientation, float initial_scale, bool flipped)
{
  assert(pattern_selection_);
  QImage pattern_img_ = base::Image(pattern_selection_->pattern()->image());
  assert(pattern_img_.sizeInBytes());
  pattern_img_ = pattern_img_.convertToFormat(QImage::Format_ARGB32);
  preview_pixmap_ = QPixmap::fromImage(pattern_img_);
  preview_pixmap_.setMask(QBitmap(base::Image(cv::Size2i(pattern_img_.size().width(), pattern_img_.size().height()), CV_8UC1, UCHAR_MAX - PREVIEW_ALPHA)));
  if(flipped)
  {
    static const bool mirror_horizontally = true;
    static const bool mirror_vertically = false;
    preview_pixmap_ = QPixmap::fromImage(QImage(preview_pixmap_.toImage()).mirrored(mirror_horizontally, mirror_vertically));
    MainWindow::instance()->flipSelectionButton()->setChecked(true);
  }

  const QSize img_size = preview_pixmap_.size();
  const QPointF origin = pattern_selection_->origin();
  preview_item_group_ = new QGraphicsItemGroup();
  preview_item_pixmap_ = new QGraphicsPixmapItem(preview_pixmap_);
  preview_item_group_->addToGroup(preview_item_pixmap_);
  preview_rect_item_ = new QGraphicsRectItem(preview_pixmap_.rect());
  preview_rect_item_->setPen(scaledPen(MainWindow::instance()->graphicsView()->currentScale()));
  preview_item_group_->addToGroup(preview_rect_item_);
  preview_item_group_->setPos(origin - 0.5*QPointF(img_size.width(), img_size.height()));
  preview_item_group_->setTransformOriginPoint(0.5*QPointF(img_size.width(), img_size.height()));
  preview_item_group_->setScale(qreal(initial_scale));
  preview_item_group_->setRotation(qRadiansToDegrees(-qreal(initial_orientation)));
  pattern_selection_->scene()->addItem(preview_item_group_);

  drawAngleIndicator(initial_orientation, img_size.width()*initial_scale);
}

// -----------------------------------------------------------------------------
void PatternSelectionTransformation::drawAngleIndicator(float angle, float preview_width)
{
  static const uint line_overhang = 50;

  const float preview_radius = preview_width/sqrtf(2.0f);
  const qreal inner_radius_start = qreal(preview_radius - std::abs(cosf(2*angle))*(preview_radius - preview_width/2));
  const qreal inner_radius_end = qreal(preview_width/2);
  const qreal arc_radius = qreal(preview_radius + float(line_overhang)/2);
  const qreal outer_radius = qreal(preview_radius + line_overhang);

  /// Remove current indication
  if(angle_indication_item_)
  {
    delete angle_indication_item_;
    angle_indication_item_ = nullptr;
  }

  /// don't draw indicator if angle is 0
  if(std::abs(angle) < std::numeric_limits<float>::epsilon()) return;

  const qreal cosine = cos(qreal(angle));
  const qreal sine = sin(qreal(-angle));
  const QPointF origin = pattern_selection_->origin();
  QPainterPath painter_path(QPointF(origin.x()+inner_radius_start, origin.y()));
  painter_path.lineTo(QPointF(origin.x() + outer_radius, origin.y()));
  painter_path.moveTo(QPointF(origin.x() + inner_radius_end*cosine, origin.y() + inner_radius_end*sine));
  painter_path.lineTo(QPointF(origin.x() + outer_radius*cosine, origin.y() + outer_radius*sine));
  painter_path.moveTo(QPointF(origin.x() + arc_radius, origin.y()));
  painter_path.arcTo(QRectF(origin.x() - arc_radius, origin.y() - arc_radius, 2*arc_radius, 2*arc_radius), 0, qRadiansToDegrees(qreal(angle)));

  angle_indication_item_ = new QGraphicsPathItem(painter_path);
  static_cast<QGraphicsPathItem*>(angle_indication_item_)->setPen(scaledPen(MainWindow::instance()->graphicsView()->currentScale()));
  pattern_selection_->scene()->addItem(angle_indication_item_);
}

// -----------------------------------------------------------------------------
QPen PatternSelectionTransformation::scaledPen(double scale)
{
  return QPen(QBrush(Qt::gray), PEN_THICKNESS*1.0/scale);
}

// -----------------------------------------------------------------------------
PatternSelectionTransformation::PatternSelectionTransformation(PatternSelection *pattern_selection) :
  current_state_(IDLE),
  pattern_selection_(pattern_selection),
  preview_pixmap_(QPixmap()),
  preview_item_pixmap_(nullptr),
  preview_item_group_(nullptr),
  angle_indication_item_(nullptr)
{
  float initial_orientation;
  float initial_scale;
  std::tie(initial_orientation, initial_scale) = predictInitialAlignment();
  init(initial_orientation, initial_scale, false);
}

// -----------------------------------------------------------------------------
PatternSelectionTransformation::PatternSelectionTransformation(PatternSelection *pattern_selection, float initial_orientation, float initial_scale, bool flipped) :
  current_state_(IDLE),
  pattern_selection_(pattern_selection),
  preview_pixmap_(QPixmap()),
  preview_item_pixmap_(nullptr),
  preview_item_group_(nullptr),
  angle_indication_item_(nullptr)
{
  init(initial_orientation, initial_scale, flipped);
}

// -----------------------------------------------------------------------------
PatternSelectionTransformation::~PatternSelectionTransformation()
{
  pattern_selection_->scene()->removeItem(preview_item_group_);
  pattern_selection_->scene()->removeItem(angle_indication_item_);
  delete preview_item_group_;
  delete angle_indication_item_;
}

// -----------------------------------------------------------------------------
void PatternSelectionTransformation::flipPreview()
{
  static const bool mirror_horizontally = true;
  static const bool mirror_vertically = false;
  preview_pixmap_ = QPixmap::fromImage(QImage(preview_pixmap_.toImage()).mirrored(mirror_horizontally, mirror_vertically));
  preview_item_pixmap_->setPixmap(preview_pixmap_);
  pattern_selection_->setFlipped(!pattern_selection_->flipped());
}

// -----------------------------------------------------------------------------
void PatternSelectionTransformation::mousePressEvent(const cv::Point2f &scene_pos)
{
  event_lock_.lock();
  previous_orientation_ = pattern_selection_->orientation();
  event_lock_.unlock();
  click_origin_ = scene_pos;
  current_state_ = TRANSFORM;
}

// -----------------------------------------------------------------------------
void PatternSelectionTransformation::mouseMoveEvent(const cv::Point2f &scene_pos)
{
  enum {X, Y};
  if(current_state_ == IDLE) return;

  event_lock_.lock();
  const float previous_orientation = previous_orientation_;
  const cv::Point2f preview_origin = pattern_selection_->polygonCenter();
  const cv::Vec2f to_origin = click_origin_-preview_origin;
  event_lock_.unlock();
  assert(!std::isnan(previous_orientation));

  const cv::Vec2f to_click = scene_pos-preview_origin;

  const float angle_to_origin = atan2f(to_origin[Y], to_origin[X]);
  const cv::Vec2f rotated_to_click = cv::Vec2f(to_click[X]*cosf(-angle_to_origin) - to_click[Y]*sinf(-angle_to_origin),
                                               to_click[X]*sinf(-angle_to_origin) + to_click[Y]*cosf(angle_to_origin));
  const float abs = std::sqrt((to_origin[X]*to_origin[X]+to_origin[Y]*to_origin[Y])
                             *(to_click[X]*to_click[X]+to_click[Y]*to_click[Y]));
  float cos_angle = (to_origin[X]*to_click[X]+to_origin[Y]*to_click[Y])/abs;
  cos_angle = std::min(cos_angle, 1.0f);
  cos_angle = std::max(cos_angle, -1.0f);
  float angle = acosf(cos_angle);
  assert(!isnanf(angle));

  /// norm to [0, 2pi]
  if(rotated_to_click[Y] < 0) angle = TWO_PIf - angle;
  const float new_orientation = TWO_PIf - std::fmod(angle+previous_orientation, TWO_PIf);
  assert(!std::isnan(qRadiansToDegrees(qreal(TWO_PIf-new_orientation))));

  pattern_selection_->setRotation(new_orientation);
  if(preview_item_group_) preview_item_group_->setRotation(qRadiansToDegrees(qreal(TWO_PIf-new_orientation)));

  const float original_radius = sqrtf(to_origin[X]*to_origin[X]+to_origin[Y]*to_origin[Y]);
  const float new_radius = sqrtf(to_click[X]*to_click[X]+to_click[Y]*to_click[Y]);
  const float new_scale = new_radius/original_radius;
  pattern_selection_->setScale(new_scale);
  if(preview_item_group_) preview_item_group_->setScale(qreal(new_scale));

  drawAngleIndicator(new_orientation, preview_pixmap_.size().width()*new_scale);
  const QString transform_string = QString::fromStdString("Transform r = "+base::AbstractHelper::formatFloat(qRadiansToDegrees(new_orientation), FLOAT_DISPLAY_PRECISION)+"°"
                                                         +", s = "+base::AbstractHelper::formatFloat(new_scale, FLOAT_DISPLAY_PRECISION));
  MainWindow::instance()->statusBar()->showMessage(transform_string);
}

// -----------------------------------------------------------------------------
void PatternSelectionTransformation::mouseReleaseEvent(const cv::Point2f&)
{
  current_state_ = IDLE;
  MainWindow::instance()->statusBar()->showMessage("");
}