#include "tools/tool.h"
#include "tundo.h"
#include "tproperty.h"
#include "tools/cursors.h"
#include "toonz/autoclose.h"
#include "ttoonzimage.h"
#include "toonz/toonzimageutils.h"
#include "tenv.h"
#include "tools/toolutils.h"
#include "toonz/txshsimplelevel.h"
#include "toonz/ttileset.h"
#include "toonz/levelproperties.h"
#include "toonz/stage2.h"
#include "tvectorimage.h"
#include "toonz/strokegenerator.h"
#include "tstroke.h"
#include "drawutil.h"
#include "tinbetween.h"
#include "toonz/txsheethandle.h"
#include "toonz/tframehandle.h"
#include "toonz/tcolumnhandle.h"
#include "toonz/tpalettehandle.h"
#include "toonz/txshlevelhandle.h"
#include "tools/toolhandle.h"
// For Qt translation support
#include <QCoreApplication>
using namespace ToolUtils;
TEnv::StringVar AutocloseVectorType("InknpaintAutocloseVectorType", "Normal");
TEnv::DoubleVar AutocloseDistance("InknpaintAutocloseDistance", 10.0);
TEnv::DoubleVar AutocloseAngle("InknpaintAutocloseAngle", 60.0);
TEnv::IntVar AutocloseRange("InknpaintAutocloseRange", 0);
TEnv::IntVar AutocloseOpacity("InknpaintAutocloseOpacity", 1);
#define NORMAL_CLOSE L"Normal"
#define RECT_CLOSE L"Rectangular"
#define FREEHAND_CLOSE L"Freehand"
#define POLYLINE_CLOSE L"Polyline"
namespace {
//============================================================
class AutocloseParameters {
public:
int m_closingDistance, m_inkIndex, m_opacity;
double m_spotAngle;
AutocloseParameters()
: m_closingDistance(0), m_inkIndex(0), m_spotAngle(0), m_opacity(1) {}
};
//============================================================
class RasterAutocloseUndo final : public TRasterUndo {
AutocloseParameters m_params;
std::vector<TAutocloser::Segment> m_segments;
public:
RasterAutocloseUndo(TTileSetCM32 *tileSet, const AutocloseParameters ¶ms,
const std::vector<TAutocloser::Segment> &segments,
TXshSimpleLevel *level, const TFrameId &frameId)
: TRasterUndo(tileSet, level, frameId, false, false, 0)
, m_segments(segments)
, m_params(params) {}
//-------------------------------------------------------------------
void redo() const override {
TToonzImageP image = getImage();
if (!image) return;
TAutocloser ac(image->getRaster(), m_params.m_closingDistance,
m_params.m_spotAngle, m_params.m_inkIndex,
m_params.m_opacity);
ac.draw(m_segments);
ToolUtils::updateSaveBox();
/*-- Viewerを更新させるため --*/
TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();
notifyImageChanged();
}
//-------------------------------------------------------------------
int getSize() const override {
return sizeof(*this) + TRasterUndo::getSize();
}
QString getToolName() override { return QString("Autoclose Tool"); }
int getHistoryType() override { return HistoryType::AutocloseTool; }
};
} // namespace
//============================================================
class RasterTapeTool final : public TTool {
Q_DECLARE_TR_FUNCTIONS(RasterTapeTool)
bool m_selecting;
TRectD m_selectingRect;
TRectD m_firstRect;
TPointD m_firstPoint;
bool m_firstFrameSelected;
TXshSimpleLevelP m_level;
// TBoolProperty m_isRect;
TEnumProperty m_closeType;
TDoubleProperty m_distance;
TDoubleProperty m_angle;
TStyleIndexProperty m_inkIndex;
TIntProperty m_opacity;
TPropertyGroup m_prop;
TBoolProperty m_multi;
TFrameId m_firstFrameId, m_veryFirstFrameId;
bool m_isXsheetCell;
std::pair<int, int> m_currCell;
// Aggiunte per disegnare il lazzo a la polyline
StrokeGenerator m_track;
TPointD m_firstPos;
TPointD m_mousePosition;
double m_thick;
TStroke *m_stroke;
TStroke *m_firstStroke;
std::vector<TPointD> m_polyline;
bool m_firstTime;
public:
RasterTapeTool()
: TTool("T_Tape")
, m_closeType("Type:") // W_ToolOptions_CloseType
, m_distance("Distance:", 1, 100, 10) // W_ToolOptions_Distance
, m_angle("Angle:", 1, 180, 60) // W_ToolOptions_Angle
, m_inkIndex("Style Index:", L"current") // W_ToolOptions_InkIndex
, m_opacity("Opacity:", 1, 255, 255)
, m_multi("Frame Range", false) // W_ToolOptions_FrameRange
, m_selecting(false)
, m_selectingRect()
, m_firstRect()
, m_level(0)
, m_firstFrameSelected(false)
, m_isXsheetCell(false)
, m_currCell(-1, -1)
, m_firstPos()
, m_mousePosition()
, m_thick(0.5)
, m_stroke(0)
, m_firstStroke(0)
, m_firstTime(true) {
bind(TTool::ToonzImage);
m_prop.bind(m_closeType);
m_closeType.addValue(NORMAL_CLOSE);
m_closeType.addValue(RECT_CLOSE);
m_closeType.addValue(FREEHAND_CLOSE);
m_closeType.addValue(POLYLINE_CLOSE);
m_prop.bind(m_multi);
m_prop.bind(m_distance);
m_prop.bind(m_angle);
m_prop.bind(m_inkIndex);
m_prop.bind(m_opacity);
m_multi.setId("FrameRange");
m_closeType.setId("Type");
}
//------------------------------------------------------------
ToolType getToolType() const override { return TTool::LevelWriteTool; }
//------------------------------------------------------------
void updateTranslation() override {
m_closeType.setQStringName(tr("Type:"));
m_closeType.setItemUIName(NORMAL_CLOSE, tr("Normal"));
m_closeType.setItemUIName(RECT_CLOSE, tr("Rectangular"));
m_closeType.setItemUIName(FREEHAND_CLOSE, tr("Freehand"));
m_closeType.setItemUIName(POLYLINE_CLOSE, tr("Polyline"));
m_distance.setQStringName(tr("Distance:"));
m_inkIndex.setQStringName(tr("Style Index:"));
m_inkIndex.setValue(tr("current").toStdWString());
m_opacity.setQStringName(tr("Opacity:"));
m_multi.setQStringName(tr("Frame Range"));
m_angle.setQStringName(tr("Angle:"));
}
//------------------------------------------------------------
void leftButtonDrag(const TPointD &pos, const TMouseEvent &e) override {
if (m_closeType.getValue() == RECT_CLOSE) {
if (!m_selecting) return;
m_selectingRect.x1 = pos.x;
m_selectingRect.y1 = pos.y;
invalidate();
} else if (m_closeType.getValue() == FREEHAND_CLOSE) {
freehandDrag(pos);
invalidate();
}
}
//------------------------------------------------------------
/*-- AutoCloseが実行されたらtrue,実行されなければfalseを返す --*/
bool applyAutoclose(const TToonzImageP &ti, const TRectD &selRect = TRectD(),
TStroke *stroke = 0) {
if (!ti) return false;
// inizializzo gli AutocloseParameters
AutocloseParameters params;
params.m_closingDistance = (int)(m_distance.getValue());
params.m_spotAngle = (int)(m_angle.getValue());
params.m_opacity = m_opacity.getValue();
std::string inkString = ::to_string(m_inkIndex.getValue());
int inkIndex =
TTool::getApplication()
->getCurrentLevelStyleIndex(); // TApp::instance()->getCurrentPalette()->getStyleIndex();
if (isInt(inkString)) inkIndex = std::stoi(inkString);
params.m_inkIndex = inkIndex;
TPoint delta;
TRasterCM32P ras, raux = ti->getRaster();
if (m_closeType.getValue() == RECT_CLOSE && raux && !selRect.isEmpty()) {
TRectD selArea = selRect;
if (selRect.x0 > selRect.x1) {
selArea.x1 = selRect.x0;
selArea.x0 = selRect.x1;
}
if (selRect.y0 > selRect.y1) {
selArea.y1 = selRect.y0;
selArea.y0 = selRect.y1;
}
TRect myRect(ToonzImageUtils::convertWorldToRaster(selArea, ti));
ras = raux->extract(myRect);
delta = myRect.getP00();
} else if ((m_closeType.getValue() == FREEHAND_CLOSE ||
m_closeType.getValue() == POLYLINE_CLOSE) &&
stroke) {
TRectD selArea = stroke->getBBox();
TRect myRect(ToonzImageUtils::convertWorldToRaster(selArea, ti));
ras = raux->extract(myRect);
delta = myRect.getP00();
} else
ras = raux;
if (!ras) return false;
TAutocloser ac(ras, params.m_closingDistance, params.m_spotAngle,
params.m_inkIndex, params.m_opacity);
std::vector<TAutocloser::Segment> segments;
ac.compute(segments);
if ((m_closeType.getValue() == FREEHAND_CLOSE ||
m_closeType.getValue() == POLYLINE_CLOSE) &&
stroke)
checkSegments(segments, stroke, raux, delta);
std::vector<TAutocloser::Segment> segments2(segments);
/*-- segmentが取得できなければfalseを返す --*/
if (segments2.empty()) return false;
int i;
if (delta != TPoint(0, 0))
for (i = 0; i < (int)segments2.size(); i++) {
segments2[i].first += delta;
segments2[i].second += delta;
}
TTileSetCM32 *tileSet = new TTileSetCM32(raux->getSize());
for (i = 0; i < (int)segments2.size(); i++) {
TRect bbox(segments2[i].first, segments2[i].second);
bbox = bbox.enlarge(2);
tileSet->add(raux, bbox);
}
TXshSimpleLevel *sl =
TTool::getApplication()->getCurrentLevel()->getSimpleLevel();
TFrameId id = getCurrentFid();
TUndoManager::manager()->add(
new RasterAutocloseUndo(tileSet, params, segments2, sl, id));
ac.draw(segments);
ToolUtils::updateSaveBox();
return true;
}
//------------------------------------------------------------
inline TRectD interpolateRect(const TRectD &r1, const TRectD &r2, double t) {
return TRectD(r1.x0 + (r2.x0 - r1.x0) * t, r1.y0 + (r2.y0 - r1.y0) * t,
r1.x1 + (r2.x1 - r1.x1) * t, r1.y1 + (r2.y1 - r1.y1) * t);
}
//============================================================
void multiApplyAutoclose(TFrameId firstFid, TFrameId lastFid,
TRectD firstRect, TRectD lastRect,
TStroke *firstStroke = 0, TStroke *lastStroke = 0) {
bool backward = false;
if (firstFid > lastFid) {
std::swap(firstFid, lastFid);
backward = true;
}
assert(firstFid <= lastFid);
std::vector<TFrameId> allFids;
m_level->getFids(allFids);
std::vector<TFrameId>::iterator i0 = allFids.begin();
while (i0 != allFids.end() && *i0 < firstFid) i0++;
if (i0 == allFids.end()) return;
std::vector<TFrameId>::iterator i1 = i0;
while (i1 != allFids.end() && *i1 <= lastFid) i1++;
assert(i0 < i1);
std::vector<TFrameId> fids(i0, i1);
int m = fids.size();
assert(m > 0);
TVectorImageP firstImage;
TVectorImageP lastImage;
if ((m_closeType.getValue() == FREEHAND_CLOSE ||
m_closeType.getValue() == POLYLINE_CLOSE) &&
firstStroke && lastStroke) {
TStroke *first = new TStroke(*firstStroke);
TStroke *last = new TStroke(*lastStroke);
firstImage = new TVectorImage();
lastImage = new TVectorImage();
firstImage->addStroke(first);
lastImage->addStroke(last);
}
TUndoManager::manager()->beginBlock();
for (int i = 0; i < m; ++i) {
TFrameId fid = fids[i];
TToonzImageP img = (TToonzImageP)m_level->getFrame(fid, true);
if (!img) continue;
double t = m > 1 ? (double)i / (double)(m - 1) : 0.5;
if (m_closeType.getValue() == RECT_CLOSE)
applyAutoclose(img, interpolateRect(firstRect, lastRect, t));
else if ((m_closeType.getValue() == FREEHAND_CLOSE ||
m_closeType.getValue() == POLYLINE_CLOSE) &&
firstStroke && lastStroke)
doClose(t, img, firstImage, lastImage);
m_level->getProperties()->setDirtyFlag(true);
}
TUndoManager::manager()->endBlock();
TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();
// TNotifier::instance()->notify(TLevelChange());
// TNotifier::instance()->notify(TStageChange());
}
//----------------------------------------------------------------------
void multiApplyAutoclose(TFrameId firstFrameId, TFrameId lastFrameId) {
int r0 = firstFrameId.getNumber();
int r1 = lastFrameId.getNumber();
if (r0 > r1) {
std::swap(r0, r1);
std::swap(firstFrameId, lastFrameId);
}
if ((r1 - r0) < 2) return;
TUndoManager::manager()->beginBlock();
for (int i = r0; i <= r1; ++i) {
TFrameId fid(i);
TImageP img = m_level->getFrame(fid, true);
applyAutoclose(img);
}
TUndoManager::manager()->endBlock();
TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();
// TNotifier::instance()->notify(TLevelChange());
// TNotifier::instance()->notify(TStageChange());
}
//----------------------------------------------------------------------
void leftButtonUp(const TPointD &pos, const TMouseEvent &e) override {
TToonzImageP ti = TToonzImageP(getImage(true));
if (!ti) return;
/*-- Rectの座標の向きを揃える --*/
if (m_selectingRect.x0 > m_selectingRect.x1)
std::swap(m_selectingRect.x1, m_selectingRect.x0);
if (m_selectingRect.y0 > m_selectingRect.y1)
std::swap(m_selectingRect.y1, m_selectingRect.y0);
TTool::Application *app = TTool::getApplication();
m_selecting = false;
TRasterCM32P ras;
if (m_closeType.getValue() == RECT_CLOSE) {
if (m_multi.getValue()) {
if (m_firstFrameSelected) {
multiApplyAutoclose(m_firstFrameId, getFrameId(), m_firstRect,
m_selectingRect);
invalidate(m_selectingRect.enlarge(2));
if (e.isShiftPressed()) {
m_firstRect = m_selectingRect;
m_firstFrameId = getFrameId();
} else {
if (m_isXsheetCell) {
app->getCurrentColumn()->setColumnIndex(m_currCell.first);
app->getCurrentFrame()->setFrame(m_currCell.second);
} else
app->getCurrentFrame()->setFid(m_veryFirstFrameId);
resetMulti();
}
} else {
m_isXsheetCell = app->getCurrentFrame()->isEditingScene();
// if (m_isXsheetCell)
m_currCell = std::pair<int, int>(getColumnIndex(), this->getFrame());
}
return;
}
/*-- AutoCloseが実行されたか判定する --*/
if (!applyAutoclose(ti, m_selectingRect)) {
if (m_stroke) {
delete m_stroke;
m_stroke = 0;
}
invalidate();
return;
}
invalidate();
notifyImageChanged();
} else if (m_closeType.getValue() == FREEHAND_CLOSE) {
closeFreehand(pos);
if (m_multi.getValue())
multiAutocloseRegion(m_stroke, e);
else
applyAutoclose(ti, TRectD(), m_stroke);
m_track.clear();
invalidate();
}
if (m_stroke) {
delete m_stroke;
m_stroke = 0;
}
}
//------------------------------------------------------------
void draw() override {
double pixelSize2 = getPixelSize() * getPixelSize();
m_thick = sqrt(pixelSize2) / 2.0;
if (m_closeType.getValue() == RECT_CLOSE) {
TPixel color = ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg
? TPixel32::White
: TPixel32::Black;
if (m_multi.getValue() && m_firstFrameSelected)
drawRect(m_firstRect, color, 0x3F33, true);
if (m_selecting || (m_multi.getValue() && !m_firstFrameSelected))
drawRect(m_selectingRect, color, 0x3F33, true);
}
if ((m_closeType.getValue() == FREEHAND_CLOSE ||
m_closeType.getValue() == POLYLINE_CLOSE) &&
m_multi.getValue() && m_firstStroke) {
TPixel color = ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg
? TPixel32::White
: TPixel32::Black;
tglColor(color);
drawStrokeCenterline(*m_firstStroke, 1);
}
if (m_closeType.getValue() == POLYLINE_CLOSE && !m_polyline.empty()) {
TPixel color = ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg
? TPixel32::White
: TPixel32::Black;
tglColor(color);
tglDrawCircle(m_polyline[0], 2);
glBegin(GL_LINE_STRIP);
for (UINT i = 0; i < m_polyline.size(); i++) tglVertex(m_polyline[i]);
tglVertex(m_mousePosition);
glEnd();
} else if (m_closeType.getValue() == FREEHAND_CLOSE && !m_track.isEmpty()) {
TPixel color = ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg
? TPixel32::White
: TPixel32::Black;
tglColor(color);
m_track.drawAllFragments();
} else if (m_multi.getValue() && m_firstFrameSelected)
drawCross(m_firstPoint, 5);
}
//------------------------------------------------------------
bool onPropertyChanged(std::string propertyName) override {
if (propertyName == m_closeType.getName()) {
AutocloseVectorType = ::to_string(m_closeType.getValue());
resetMulti();
}
else if (propertyName == m_distance.getName())
AutocloseDistance = m_distance.getValue();
else if (propertyName == m_angle.getName())
AutocloseAngle = m_angle.getValue();
else if (propertyName == m_inkIndex.getName()) {
}
else if (propertyName == m_opacity.getName())
AutocloseOpacity = m_opacity.getValue();
else if (propertyName == m_multi.getName()) {
AutocloseRange = (int)((m_multi.getValue()));
resetMulti();
}
if (ToonzCheck::instance()->getChecks() & ToonzCheck::eAutoclose)
notifyImageChanged();
return true;
}
//----------------------------------------------------------------------
void resetMulti() {
m_firstFrameSelected = false;
m_firstRect.empty();
m_firstPoint = TPointD();
m_selectingRect.empty();
TTool::Application *app = TTool::getApplication();
m_level = app->getCurrentLevel()->getLevel()
? app->getCurrentLevel()->getSimpleLevel()
: 0;
m_firstFrameId = m_veryFirstFrameId = getFrameId();
m_firstStroke = 0;
}
//----------------------------------------------------------------------
void onImageChanged() override {
if (!m_multi.getValue()) return;
TTool::Application *app = TTool::getApplication();
TXshSimpleLevel *xshl = 0;
if (app->getCurrentLevel()->getLevel())
xshl = app->getCurrentLevel()->getSimpleLevel();
if (!xshl || m_level.getPointer() != xshl ||
(m_closeType.getValue() == RECT_CLOSE && m_selectingRect.isEmpty()) ||
((m_closeType.getValue() == FREEHAND_CLOSE ||
m_closeType.getValue() == POLYLINE_CLOSE) &&
!m_firstStroke))
resetMulti();
else if (m_firstFrameId == getFrameId())
m_firstFrameSelected = false; // nel caso sono passato allo stato 1 e
// torno all'immagine iniziale, torno allo
// stato iniziale
else { // cambio stato.
m_firstFrameSelected = true;
if (m_closeType.getValue() == RECT_CLOSE) {
assert(!m_selectingRect.isEmpty());
m_firstRect = m_selectingRect;
}
}
}
//----------------------------------------------------------------------
void leftButtonDown(const TPointD &pos, const TMouseEvent &) override {
TToonzImageP ti = TToonzImageP(getImage(true));
if (!ti) return;
if (m_closeType.getValue() == RECT_CLOSE) {
m_selecting = true;
m_selectingRect.x0 = pos.x;
m_selectingRect.y0 = pos.y;
m_selectingRect.x1 = pos.x + 1;
m_selectingRect.y1 = pos.y + 1;
return;
} else if (m_closeType.getValue() == FREEHAND_CLOSE) {
startFreehand(pos);
return;
} else if (m_closeType.getValue() == POLYLINE_CLOSE) {
addPointPolyline(pos);
return;
} else if (m_closeType.getValue() == NORMAL_CLOSE) {
if (m_multi.getValue()) {
TTool::Application *app = TTool::getApplication();
if (m_firstFrameSelected) {
multiApplyAutoclose(m_firstFrameId, getFrameId());
invalidate();
if (m_isXsheetCell) {
app->getCurrentColumn()->setColumnIndex(m_currCell.first);
app->getCurrentFrame()->setFrame(m_currCell.second);
} else
app->getCurrentFrame()->setFid(m_veryFirstFrameId);
resetMulti();
} else {
m_isXsheetCell = app->getCurrentFrame()->isEditingScene();
// if (m_isXsheetCell)
m_currCell = std::pair<int, int>(getColumnIndex(), getFrame());
m_firstFrameSelected = true;
m_firstPoint = pos;
}
invalidate();
return;
}
m_selecting = false;
applyAutoclose(ti);
invalidate();
notifyImageChanged();
}
}
//----------------------------------------------------------------------
void leftButtonDoubleClick(const TPointD &pos,
const TMouseEvent &e) override {
TToonzImageP ti = TToonzImageP(getImage(true));
if (m_closeType.getValue() == POLYLINE_CLOSE && ti) {
closePolyline(pos);
std::vector<TThickPoint> strokePoints;
for (UINT i = 0; i < m_polyline.size() - 1; i++) {
strokePoints.push_back(TThickPoint(m_polyline[i], 1));
strokePoints.push_back(
TThickPoint(0.5 * (m_polyline[i] + m_polyline[i + 1]), 1));
}
strokePoints.push_back(TThickPoint(m_polyline.back(), 1));
m_polyline.clear();
m_stroke = new TStroke(strokePoints);
assert(m_stroke->getPoint(0) == m_stroke->getPoint(1));
if (m_multi.getValue())
multiAutocloseRegion(m_stroke, e);
else
applyAutoclose(ti, TRectD(), m_stroke);
invalidate();
}
if (m_stroke) {
delete m_stroke;
m_stroke = 0;
}
}
//----------------------------------------------------------------------
void mouseMove(const TPointD &pos, const TMouseEvent &e) override {
if (m_closeType.getValue() == POLYLINE_CLOSE) {
m_mousePosition = pos;
invalidate();
}
}
//----------------------------------------------------------------------
void onEnter() override {
// getApplication()->editImage();
}
//----------------------------------------------------------------------
TPropertyGroup *getProperties(int targetType) override { return &m_prop; }
//----------------------------------------------------------------------
void onActivate() override {
if (m_firstTime) {
m_closeType.setValue(::to_wstring(AutocloseVectorType.getValue()));
m_distance.setValue(AutocloseDistance);
m_angle.setValue(AutocloseAngle);
m_opacity.setValue(AutocloseOpacity);
m_multi.setValue(AutocloseRange ? 1 : 0);
m_firstTime = false;
}
// getApplication()->editImage();
resetMulti();
}
//----------------------------------------------------------------------
void onDeactivate() override {}
//----------------------------------------------------------------------
int getCursorId() const override {
int ret = ToolCursor::TapeCursor;
if (m_closeType.getValue() == FREEHAND_CLOSE)
ret = ret | ToolCursor::Ex_FreeHand;
else if (m_closeType.getValue() == POLYLINE_CLOSE)
ret = ret | ToolCursor::Ex_PolyLine;
else if (m_closeType.getValue() == RECT_CLOSE)
ret = ret | ToolCursor::Ex_Rectangle;
if (ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg)
ret = ret | ToolCursor::Ex_Negate;
return ret;
}
//----------------------------------------------------------------------
//! Viene aggiunto \b pos a \b m_track e disegnato il primo pezzetto del
//! lazzo. Viene inizializzato \b m_firstPos
void startFreehand(const TPointD &pos) {
m_track.clear();
m_firstPos = pos;
double pixelSize2 = getPixelSize() * getPixelSize();
m_track.add(TThickPoint(pos, m_thick), pixelSize2);
}
//------------------------------------------------------------------
//! Viene aggiunto \b pos a \b m_track e disegnato un altro pezzetto del
//! lazzo.
void freehandDrag(const TPointD &pos) {
double pixelSize2 = getPixelSize() * getPixelSize();
m_track.add(TThickPoint(pos, m_thick), pixelSize2);
}
//------------------------------------------------------------------
//! Viene chiuso il lazzo (si aggiunge l'ultimo punto ad m_track) e viene
//! creato lo stroke rappresentante il lazzo.
void closeFreehand(const TPointD &pos) {
if (m_track.isEmpty()) return;
double pixelSize2 = getPixelSize() * getPixelSize();
m_track.add(TThickPoint(m_firstPos, m_thick), pixelSize2);
m_track.filterPoints();
double error = (30.0 / 11) * sqrt(pixelSize2);
m_stroke = m_track.makeStroke(error);
m_stroke->setStyle(1);
}
//------------------------------------------------------------------
//! Viene aggiunto un punto al vettore m_polyline.
void addPointPolyline(const TPointD &pos) {
m_firstPos = pos;
m_polyline.push_back(pos);
}
//------------------------------------------------------------------
//! Agginge l'ultimo pos a \b m_polyline e chiude la spezzata (aggiunge \b
//! m_polyline.front() alla fine del vettore)
void closePolyline(const TPointD &pos) {
if (m_polyline.size() <= 1) return;
if (m_polyline.back() != pos) m_polyline.push_back(pos);
if (m_polyline.back() != m_polyline.front())
m_polyline.push_back(m_polyline.front());
invalidate();
}
//-------------------------------------------------------------------
//! Elimina i segmenti che non sono contenuti all'interno dello stroke!!!
void checkSegments(std::vector<TAutocloser::Segment> &segments,
TStroke *stroke, const TRasterCM32P &ras,
const TPoint &delta) {
TVectorImage vi;
TStroke *app = new TStroke();
*app = *stroke;
app->transform(TTranslation(convert(ras->getCenter())));
vi.addStroke(app);
vi.findRegions();
std::vector<TAutocloser::Segment>::iterator it = segments.begin();
for (; it < segments.end(); it++) {
if (it == segments.end()) break;
int i;
bool isContained = false;
for (i = 0; i < (int)vi.getRegionCount(); i++) {
TRegion *reg = vi.getRegion(i);
if (reg->contains(convert(it->first + delta)) &&
reg->contains(convert(it->second + delta))) {
isContained = true;
break;
}
}
if (!isContained) {
it = segments.erase(it);
if (it != segments.end() && it != segments.begin())
it--;
else if (it == segments.end())
break;
}
}
}
//-------------------------------------------------------------------
void multiAutocloseRegion(TStroke *stroke, const TMouseEvent &e) {
TTool::Application *app = TTool::getApplication();
if (m_firstStroke) {
multiApplyAutoclose(m_firstFrameId, getFrameId(), TRectD(), TRectD(),
m_firstStroke, stroke);
invalidate();
if (e.isShiftPressed()) {
delete m_firstStroke;
m_firstStroke = new TStroke(*stroke);
m_firstFrameId = getFrameId();
} else {
if (m_isXsheetCell) {
app->getCurrentColumn()->setColumnIndex(m_currCell.first);
app->getCurrentFrame()->setFrame(m_currCell.second);
} else
app->getCurrentFrame()->setFid(m_veryFirstFrameId);
resetMulti();
}
} else {
m_isXsheetCell = app->getCurrentFrame()->isEditingScene();
// if (m_isXsheetCell)
m_currCell = std::pair<int, int>(getColumnIndex(), getFrame());
m_firstStroke = new TStroke(*stroke);
}
return;
}
//------------------------------------------------------------------------
void doClose(double t, const TImageP &img, const TVectorImageP &firstImage,
const TVectorImageP &lastImage) {
if (t == 0)
applyAutoclose(img, TRectD(), firstImage->getStroke(0));
else if (t == 1)
applyAutoclose(img, TRectD(), lastImage->getStroke(0));
else {
assert(firstImage->getStrokeCount() == 1);
assert(lastImage->getStrokeCount() == 1);
TVectorImageP vi = TInbetween(firstImage, lastImage).tween(t);
assert(vi->getStrokeCount() == 1);
applyAutoclose(img, TRectD(), vi->getStroke(0));
}
}
//-------------------------------------------------------------------
} rasterTapeTool;