patternselection.cpp

#include "patternselection.h"
#include "ui/mainwindow.h"
#include "ui/graphicsview.h"
#include "ui/flatsurfaceitem.h"
#include "ui/patternselectionpolygon.h"
#include "pattern.h"
#include "patternselectiontransformation.h"
#include <QGraphicsScene>
#include <QGraphicsPixmapItem>

#define JSON_KEY_ROTATION ("rotation")
#define JSON_KEY_SCALE ("scale")
#define JSON_KEY_FLIPPED ("flipped")
#define JSON_KEY_FACE_IDXS ("faceIdxs")
#define JSON_KEY_POLYGON_PTS ("polygonPts")


// -----------------------------------------------------------------------------
cv::Point2f PatternSelection::polygonCenter(const PolygonPoints &polygon_pts)
{
  PolygonPoint center_pt = PolygonPoint(0, 0);
  if(!polygon_pts.size()) return center_pt;

  for(const PolygonPoint &polygon_pt : polygon_pts)
    center_pt += polygon_pt;
  return center_pt * (1.0/polygon_pts.size());
}

// -----------------------------------------------------------------------------
PatternSelection::PatternSelection(QGraphicsScene *scene, Pattern *pattern, const PolygonPoints &polygon_pts) :
  pattern_(pattern),
  scene_(scene),
  polygon_pts_(polygon_pts),
  polygon_center_(polygonCenter(polygon_pts_)),
  orientation_(0), flipped_(false), scale_(1.0f),
  selected_faces_(std::set<base::he::Face*>()),
  selected_faces_idxs_(std::set<std::size_t>()),
  polygon_item_(nullptr),
  active_transformation_(nullptr)
{
  static const uint indicator_radius = 20;
  const QPointF pt1(qreal(polygon_center_.x), qreal(polygon_center_.y));
  const QPointF pt2(pt1.x() + indicator_radius*cos(qreal(orientation_)+M_PI_2),
                    pt1.y() + indicator_radius*sin(qreal(orientation_)+M_PI_2));
  const QPen pen2(QBrush(Qt::white), 3, Qt::SolidLine, Qt::RoundCap);

  addKeyValuePair(JSON_KEY_ROTATION, std::make_shared<base::json::JsonNumber>(orientation_));
  addKeyValuePair(JSON_KEY_SCALE, std::make_shared<base::json::JsonNumber>(scale_));
  addKeyValuePair(JSON_KEY_FLIPPED, std::make_shared<base::json::JsonBoolean>(flipped_));
  std::vector<base::json::JsonElement::ptr>polygon_pt_elems = {};
  for(const PolygonPoint &pt : polygon_pts_)
  {
    polygon_pt_elems.push_back(std::make_shared<base::json::JsonArray>(std::vector<float>{pt.x, pt.y}));
  }
  addKeyValuePair(JSON_KEY_POLYGON_PTS, std::make_shared<base::json::JsonArray>(polygon_pt_elems));
  drawPolygon();
}

// -----------------------------------------------------------------------------
PatternSelection::PatternSelection(Pattern *pattern, const base::json::JsonObject::ptr json_obj) :
  pattern_(pattern),
  scene_(nullptr),
  polygon_pts_(PolygonPoints()),
  selected_faces_(std::set<base::he::Face*>()),
  selected_faces_idxs_(std::set<std::size_t>()),
  polygon_item_(nullptr),
  active_transformation_(nullptr)
{
  assert(json_obj->has(JSON_KEY_FLIPPED) && json_obj->getValue(JSON_KEY_FLIPPED)->type() == BOOLEAN);
  assert(json_obj->has(JSON_KEY_ROTATION) && json_obj->getValue(JSON_KEY_ROTATION)->type() == NUMBER);
  assert(json_obj->has(JSON_KEY_SCALE) && json_obj->getValue(JSON_KEY_SCALE)->type() == NUMBER);
  assert(json_obj->has(JSON_KEY_FACE_IDXS) && json_obj->getValue(JSON_KEY_FACE_IDXS)->type() == ARRAY);
  assert(json_obj->has(JSON_KEY_POLYGON_PTS) && json_obj->getValue(JSON_KEY_POLYGON_PTS)->type() == ARRAY);
  key_value_pairs_ = json_obj->keyValuePairs();

  flipped_ = *json_obj->getValue(JSON_KEY_FLIPPED)->boolean();
  orientation_ = *json_obj->getValue(JSON_KEY_ROTATION)->number();
  scale_ = *json_obj->getValue(JSON_KEY_SCALE)->number();

  for(base::json::JsonElement::ptr elem : *json_obj->getValue(JSON_KEY_FACE_IDXS)->array())
    selected_faces_idxs_.insert(*elem->number());
  enum {X, Y};
  for(base::json::JsonElement::ptr elem : *json_obj->getValue(JSON_KEY_POLYGON_PTS)->array())
  {
    const std::vector<float> coords = *elem->array();
    assert(coords.size() == 2);
    polygon_pts_.push_back({coords[X], coords[Y]});
  }
  polygon_center_ = polygonCenter(polygon_pts_);
}

// -----------------------------------------------------------------------------
PatternSelection::PatternSelection(const PatternSelection &pattern_selection)
{
  pattern_ = pattern_selection.pattern_;
  scene_ = pattern_selection.scene_;
  polygon_pts_ = pattern_selection.polygon_pts_;
  polygon_center_ = pattern_selection.polygon_center_;
  orientation_ = pattern_selection.orientation_;
  flipped_ = pattern_selection.flipped_;
  scale_ = pattern_selection.scale_;
  selected_faces_ = pattern_selection.selected_faces_;
  selected_faces_idxs_ = pattern_selection.selected_faces_idxs_;
  polygon_item_ = nullptr;
  active_transformation_ = nullptr;
  key_value_pairs_ = pattern_selection.key_value_pairs_;
}

// -----------------------------------------------------------------------------
PatternSelection::~PatternSelection()
{
  delete polygon_item_;
  if(active_transformation_)
    delete active_transformation_;
  for(std::set<base::he::Face*>::const_iterator face_it = selected_faces_.begin();
      face_it != selected_faces_.end();
      face_it++)
  {
    (*face_it)->setColor(base::he::Face::defaultColor());
  }
}

// -----------------------------------------------------------------------------
const PolygonPoints PatternSelection::polygonPoints() const
{
  return polygon_pts_;
}

// -----------------------------------------------------------------------------
cv::Point2f PatternSelection::polygonCenter() const
{
  return polygon_center_;
}

// -----------------------------------------------------------------------------
float PatternSelection::orientation() const
{
  return orientation_;
}

// -----------------------------------------------------------------------------
Pattern *PatternSelection::pattern() const
{
  return pattern_;
}

// -----------------------------------------------------------------------------
PatternSelectionPolygon *PatternSelection::polygonItem() const
{
  return polygon_item_;
}

// -----------------------------------------------------------------------------
QGraphicsScene *PatternSelection::scene() const
{
  return scene_;
}

// -----------------------------------------------------------------------------
QPointF PatternSelection::origin() const
{
  return QPointF(qreal(polygon_center_.x), qreal(polygon_center_.y));
}

// -----------------------------------------------------------------------------
bool PatternSelection::flipped() const
{
  return flipped_;
}

// -----------------------------------------------------------------------------
const std::set<base::he::Face *> PatternSelection::selectedFaces() const
{
  return selected_faces_;
}

// -----------------------------------------------------------------------------
PatternSelectionTransformation *PatternSelection::activeTransformation() const
{
  return active_transformation_;
}

// -----------------------------------------------------------------------------
void PatternSelection::drawPolygon()
{
  assert(scene_);
  const PolygonPoints mapped_points = polygon_pts_;
  QVector<QPointF> qpolygon_pts = QVector<QPointF>(int(mapped_points.size()));
  for(std::size_t polygon_idx = 0; polygon_idx < mapped_points.size(); polygon_idx++)
    qpolygon_pts[int(polygon_idx)] = QPointF(qreal(mapped_points[polygon_idx].x),
                                             qreal(mapped_points[polygon_idx].y));
  polygon_item_ = new PatternSelectionPolygon(QPolygonF(qpolygon_pts), this);
  scene_->addItem(polygon_item_);
}

// -----------------------------------------------------------------------------
void PatternSelection::setScene(QGraphicsScene *scene)
{
  scene_ = scene;
}

// -----------------------------------------------------------------------------
void PatternSelection::setRotation(float angle)
{
  orientation_ = angle;
  addKeyValuePair(JSON_KEY_ROTATION, std::make_shared<base::json::JsonNumber>(orientation_));
}

// -----------------------------------------------------------------------------
void PatternSelection::setFlipped(bool flipped)
{
  flipped_ = flipped;
  addKeyValuePair(JSON_KEY_FLIPPED, std::make_shared<base::json::JsonBoolean>(flipped_));
}

// -----------------------------------------------------------------------------
void PatternSelection::setScale(float scale)
{
  scale_ = scale;
  addKeyValuePair(JSON_KEY_SCALE, std::make_shared<base::json::JsonNumber>(scale_));
}

// -----------------------------------------------------------------------------
void PatternSelection::setActiveTransformation(PatternSelectionTransformation *active_tranformation)
{
  active_transformation_ = active_tranformation;
}

// -----------------------------------------------------------------------------
void PatternSelection::setSelectedFaces(const std::set<base::he::Face*> &selected_faces)
{
  selected_faces_ = selected_faces;

  std::vector<std::size_t> face_ids = {};
  for(std::set<base::he::Face*>::const_iterator face_it = selected_faces.begin(); face_it != selected_faces.end(); face_it++)
    face_ids.push_back((*face_it)->id());
  addKeyValuePair(JSON_KEY_FACE_IDXS, std::make_shared<base::json::JsonArray>(face_ids));
}

// -----------------------------------------------------------------------------
void PatternSelection::setActive()
{
  assert(polygon_item_ && !active_transformation_);
  polygon_item_->setActive();
  assert(active_transformation_ == nullptr);
  active_transformation_ = new PatternSelectionTransformation(this, orientation_, scale_, flipped_);
}

// -----------------------------------------------------------------------------
void PatternSelection::setInactive()
{
  polygon_item_->setInactive();
  delete active_transformation_;
  active_transformation_ = nullptr;
}

// -----------------------------------------------------------------------------
void PatternSelection::setSelectedFacesFromIdxs()
{
  const base::Mesh::ptr mesh = MainWindow::instance()->mesh();
  const base::Mesh::Faces faces = mesh->faces();

  for(std::set<std::size_t>::const_iterator idx_it = selected_faces_idxs_.begin();
      idx_it != selected_faces_idxs_.end();
      idx_it++)
  {
    assert(*idx_it < faces.size());
    selected_faces_.insert(faces[*idx_it]);
  }
}