bool FullColorBrushTool::onPropertyChanged(string propertyName)
{
m_minThick = m_thickness.getValue().first;
m_maxThick = m_thickness.getValue().second;
if (propertyName == "Hardness:" || propertyName == "Thickness") {
m_brushPad = ToolUtils::getBrushPad(m_thickness.getValue().second, m_hardness.getValue() * 0.01);
TRectD rect(m_brushPos - TPointD(m_maxThick + 2, m_maxThick + 2),
m_brushPos + TPointD(m_maxThick + 2, m_maxThick + 2));
invalidate(rect);
}
/*if(propertyName == "Hardness:" || propertyName == "Opacity:")
setWorkAndBackupImages();*/
FullcolorBrushMinSize = m_minThick;
FullcolorBrushMaxSize = m_maxThick;
FullcolorPressureSensibility = m_pressure.getValue();
FullcolorBrushHardness = m_hardness.getValue();
FullcolorMinOpacity = m_opacity.getValue().first;
FullcolorMaxOpacity = m_opacity.getValue().second;
if (propertyName == "Preset:") {
loadPreset();
getApplication()->getCurrentTool()->notifyToolChanged();
return true;
}
if (m_preset.getValue() != CUSTOM_WSTR) {
m_preset.setValue(CUSTOM_WSTR);
getApplication()->getCurrentTool()->notifyToolChanged();
}
return true;
}
void CameraTestTool::drawClosestFieldCamera(double pixelSize) {
CleanupParameters *cp =
CleanupSettingsModel::instance()->getCurrentParameters();
double zoom = cp->m_closestField / cp->m_camera.getSize().lx;
if (areAlmostEqual(zoom, 1.0, 1e-2)) return;
TRectD rect(cp->m_camera.getStageRect());
rect = rect.enlarge((zoom - 1) * (rect.x1 - rect.x0 + 1) / 2.0,
(zoom - 1) * (rect.y1 - rect.y0 + 1) / 2.0);
glColor3d(0.0, 0.0, 1.0);
glLineStipple(1, 0xFFFF);
glEnable(GL_LINE_STIPPLE);
// box
glBegin(GL_LINE_STRIP);
glVertex2d(rect.x0, rect.y0);
glVertex2d(rect.x0, rect.y1 - pixelSize);
glVertex2d(rect.x1 - pixelSize, rect.y1 - pixelSize);
glVertex2d(rect.x1 - pixelSize, rect.y0);
glVertex2d(rect.x0, rect.y0);
glEnd();
glDisable(GL_LINE_STIPPLE);
// camera name
TPointD pos = rect.getP01() + TPointD(0, 4);
glPushMatrix();
glTranslated(pos.x, pos.y, 0);
glScaled(2, 2, 2);
tglDrawText(TPointD(), "Closest Field");
glPopMatrix();
}
TToneCurveParam::TToneCurveParam() : TParam() {
m_toneChannel = RGBA;
std::vector<TPointD> points;
// Inserisco dei punti fuori dal range(0-255) perche' mi consentono di gestire
// i primi punti come speciali.
points.push_back(TPointD(-40, 0));
points.push_back(TPointD(-20, 0));
points.push_back(TPointD(-20, 0));
points.push_back(TPointD(0, 0));
points.push_back(TPointD(16, 16));
points.push_back(TPointD(239, 239));
points.push_back(TPointD(255, 255));
points.push_back(TPointD(275, 255));
points.push_back(TPointD(275, 255));
points.push_back(TPointD(295, 255));
m_rgbaParamSet = new TParamSet("redgreenbluealphachannel");
m_rgbParamSet = new TParamSet("redgreenbluechannel");
m_rParamSet = new TParamSet("redchannel");
m_gParamSet = new TParamSet("greenchannel");
m_bParamSet = new TParamSet("bluechannel");
m_aParamSet = new TParamSet("alphachannel");
m_isLinear = new TBoolParam(false);
int i;
for (i = 0; i < (int)points.size(); i++) {
m_rgbaParamSet->addParam(new TPointParam(points[i]), "point");
m_rgbParamSet->addParam(new TPointParam(points[i]), "point");
m_rParamSet->addParam(new TPointParam(points[i]), "point");
m_gParamSet->addParam(new TPointParam(points[i]), "point");
m_bParamSet->addParam(new TPointParam(points[i]), "point");
m_aParamSet->addParam(new TPointParam(points[i]), "point");
}
}
Deformation::Deformation()
: m_selected(-1)
{
m_controlPoints.resize(6);
m_controlPoints[0] = TPointD(-250, 100);
m_controlPoints[2] = TPointD(0, -300);
m_controlPoints[4] = TPointD(250, 100);
for (int i = 0; i < 6; i += 2)
m_controlPoints[i + 1] = m_controlPoints[i];
}
void OnionSkinMask::clear() {
m_fos.clear();
m_mos.clear();
m_shiftTraceStatus = DISABLED;
m_ghostAff[0] = TAffine();
m_ghostAff[1] = TAffine();
m_ghostCenter[0] = TPointD();
m_ghostCenter[1] = TPointD();
m_ghostFrame[0] = 0;
m_ghostFrame[1] = 0;
}
void checkPolyline(const vector<T3DPointD> &p)
{
int ret;
if (p.size() < 3)
return;
TPointD p1;
TPointD p2;
int pointSize = (int)p.size() - 1;
for (int i = 0; i < pointSize; i++) {
for (int j = i + 1; j < pointSize; j++) {
vector<DoublePair> res;
p1 = TPointD(p[i].x, p[i].y);
p2 = TPointD(p[i + 1].x, p[i + 1].y);
TSegment s0(p1, p2);
p1 = TPointD(p[j].x, p[j].y);
p2 = TPointD(p[j + 1].x, p[j + 1].y);
TSegment s1(p1, p2);
ret = intersect(s0, s1, res);
if (ret)
assert(
(ret == 1) &&
(areAlmostEqual(res[0].first, 1) ||
areAlmostEqual(res[0].first, 0)) &&
(areAlmostEqual(res[0].second, 1) ||
areAlmostEqual(res[0].second, 0)));
}
}
p1 = TPointD(p.back().x, p.back().y);
p2 = TPointD(p[0].x, p[0].y);
TSegment s0(p1, p2);
for (int j = 0; j < pointSize; j++) {
vector<DoublePair> res;
p1 = TPointD(p[j].x, p[j].y);
p2 = TPointD(p[j + 1].x, p[j + 1].y);
TSegment s1(p1, p2);
ret = intersect(s0, s1, res);
if (ret)
assert(
(ret == 1) &&
(areAlmostEqual(res[0].first, 1) ||
areAlmostEqual(res[0].first, 0)) &&
(areAlmostEqual(res[0].second, 1) ||
areAlmostEqual(res[0].second, 0)));
}
}
TStageObjectSpline::TStageObjectSpline()
: TSmartObject(m_classCode)
, m_stroke(0)
, m_dagNodePos(TConst::nowhere)
, m_id(-1)
, m_idBase(std::to_string(idBaseCode++))
, m_name("")
, m_isOpened(false) {
double d = 30;
std::vector<TThickPoint> points;
points.push_back(TPointD(0, 0));
points.push_back(TPointD(d, 0));
points.push_back(TPointD(2.0 * d, 0));
m_stroke = new TStroke(points);
}
MagicWandFx()
: m_tolerance(15.0), m_blurRadius(0.0), m_point(TPointD(0, 0))
{
m_contiguous = TBoolParamP(true);
m_antialiased = TBoolParamP(true);
m_euclideanD = TBoolParamP(true);
m_preMolt = TBoolParamP(true);
m_isShiftPressed = TBoolParamP(false);
m_isAltPressed = TBoolParamP(false);
addParam("Tolerance", m_tolerance);
addParam("Feather", m_blurRadius);
addParam("Point", m_point);
addParam("Contiguous", m_contiguous);
addParam("Antialias", m_antialiased);
addParam("EuclideanD", m_euclideanD);
addParam("PreMultiply", m_preMolt);
addParam("isShiftPressed", m_isShiftPressed);
addParam("isAltPressed", m_isAltPressed);
addInputPort("Source", m_input);
m_tolerance->setValueRange(0, 255);
m_blurRadius->setValueRange(0, 100);
}
/*! Add to current trasformation matrix a \b delta traslation.
*/
void ImageViewer::panQt(const QPoint &delta) {
if (delta == QPoint()) return;
// stop panning when the image is at the edge of window
QPoint delta_(delta.x(), delta.y());
TToonzImageP timg = (TToonzImageP)m_image;
TRasterImageP rimg = (TRasterImageP)m_image;
if (timg || rimg) {
bool isXPlus = delta.x() > 0;
bool isYPlus = delta.y() > 0;
TDimension imgSize((timg) ? timg->getSize() : rimg->getRaster()->getSize());
int subSampling = (timg) ? timg->getSubsampling() : rimg->getSubsampling();
TPointD cornerPos = TPointD(imgSize.lx * ((isXPlus) ? -1 : 1),
imgSize.ly * ((isYPlus) ? 1 : -1)) *
(0.5 / (double)subSampling);
cornerPos = m_viewAff * cornerPos;
if ((cornerPos.x > 0) == isXPlus) delta_.setX(0);
if ((cornerPos.y < 0) == isYPlus) delta_.setY(0);
}
setViewAff(TTranslation(delta_.x(), -delta_.y()) * m_viewAff);
update();
}
void ToonzExt::OverallDesigner::draw(ToonzExt::StraightCornerDeformation *sd)
{
#ifdef _DEBUG
glPushMatrix();
{
this->setPosition();
glColor3d(0.0, 1.0, 1.0);
glBegin(GL_LINE_STRIP);
tglVertex(TPointD(0.0, 0.0));
tglVertex(TPointD(8.0, 12.0));
tglVertex(TPointD(16.0, 0.0));
glEnd();
}
glPopMatrix();
#endif
}
TVectorImageP Naa2TlvConverter::vectorize(const TToonzImageP &ti) {
CenterlineConfiguration conf;
if (!ti) return TVectorImageP();
TPalette *palette = ti->getPalette();
VectorizerCore vc;
TAffine dpiAff;
double factor = Stage::inch;
double dpix = factor / 72, dpiy = factor / 72;
ti->getDpi(dpix, dpiy);
TPointD center = ti->getRaster()->getCenterD();
if (dpix != 0.0 && dpiy != 0.0) dpiAff = TScale(factor / dpix, factor / dpiy);
factor = norm(dpiAff * TPointD(1, 0));
conf.m_affine = dpiAff * TTranslation(-center);
conf.m_thickScale = factor;
conf.m_leaveUnpainted = false;
conf.m_makeFrame = true;
conf.m_penalty = 0.0;
conf.m_despeckling = 0;
TImageP img(ti.getPointer());
TVectorImageP vi = vc.vectorize(img, conf, palette);
vi->setPalette(palette);
return vi;
}
void StylePickerTool::mouseMove(const TPointD &pos, const TMouseEvent &e) {
if (!m_passivePick.getValue()) return;
/*--- PassiveにStyleを拾う機能 ---*/
PaletteController *controller =
TTool::getApplication()->getPaletteController();
TImageP image = getImage(false);
TToonzImageP ti = image;
TVectorImageP vi = image;
TXshSimpleLevel *level =
getApplication()->getCurrentLevel()->getSimpleLevel();
if ((!ti && !vi) || !level || !m_viewer->getGeometry().contains(pos)) {
controller->notifyStylePassivePicked(-1, -1, -1);
return;
}
int subsampling = level->getImageSubsampling(getCurrentFid());
StylePicker picker(image);
TPointD pickPos(TScale(1.0 / subsampling) * pos + TPointD(-0.5, -0.5));
int inkStyleId =
picker.pickStyleId(pickPos, getPixelSize() * getPixelSize(), 1);
int paintStyleId =
picker.pickStyleId(pickPos, getPixelSize() * getPixelSize(), 0);
int tone = picker.pickTone(pickPos);
controller->notifyStylePassivePicked(inkStyleId, paintStyleId, tone);
}
RippleFx()
: m_intensity(20)
, m_gridStep(2)
, m_center(TPointD(0.0, 0.0))
, m_period(100) // args, "Period")
, m_count(2) // args, "Count")
, m_cycle(0.0)
, m_scaleX(100.0)
, m_scaleY(100.0)
, m_angle(0.0)
, m_sharpen(false) {
m_center->getX()->setMeasureName("fxLength");
m_center->getY()->setMeasureName("fxLength");
m_period->setMeasureName("fxLength");
addInputPort("Source", m_warped);
bindParam(this, "period", m_period);
bindParam(this, "count", m_count);
bindParam(this, "cycle", m_cycle);
bindParam(this, "center", m_center);
bindParam(this, "scalex", m_scaleX);
bindParam(this, "scaley", m_scaleY);
bindParam(this, "angle", m_angle);
bindParam(this, "intensity", m_intensity);
bindParam(this, "sensitivity", m_gridStep);
bindParam(this, "sharpen", m_sharpen);
m_intensity->setValueRange(-1000, 1000);
m_gridStep->setValueRange(2, 20);
m_period->setValueRange(0, (std::numeric_limits<double>::max)());
m_cycle->setValueRange(0, (std::numeric_limits<double>::max)());
m_count->setValueRange(0, (std::numeric_limits<double>::max)());
m_angle->setMeasureName("angle");
}
BodyHighLightFx()
: m_point(TPointD(10.0, 10.0))
, m_mode(new TIntEnumParam(OVER, "Over"))
, m_transparency(0.5)
, m_blur(2.0)
, m_color(TPixel32::White)
, m_invert(false) {
m_point->getX()->setMeasureName("fxLength");
m_point->getY()->setMeasureName("fxLength");
m_blur->setMeasureName("fxLength");
bindParam(this, "mode", m_mode);
bindParam(this, "point", m_point);
bindParam(this, "transparency", m_transparency);
bindParam(this, "blur", m_blur);
bindParam(this, "color", m_color);
bindParam(this, "invert", m_invert);
addInputPort("Source", m_input);
m_transparency->setValueRange(0.0, 1.0);
m_blur->setValueRange(0, (std::numeric_limits<double>::max)());
m_color->enableMatte(false);
m_mode->addItem(ADD, "Add");
m_mode->addItem(SUBTRACT, "Subtract");
m_mode->addItem(MULTIPLY, "Multiply");
m_mode->addItem(LIGHTEN, "Lighten");
m_mode->addItem(DARKEN, "Darken");
}
void ToonzExt::OverallDesigner::draw(ToonzExt::SmoothDeformation *sd)
{
#ifdef _DEBUG
glPushMatrix();
{
this->setPosition();
TCubic c;
c.setP0(TPointD(0.0, 0.0));
c.setP1(TPointD(4.0, 12.0));
c.setP2(TPointD(12.0, 12.0));
c.setP3(TPointD(16.0, 0.0));
glColor3d(1.0, 0.0, 1.0);
tglDraw(c, 100, GL_LINE);
}
glPopMatrix();
#endif
}
double computeStep(const TThickQuadratic &quad, double pixelSize) {
TThickPoint cp0 = quad.getThickP0(), cp1 = quad.getThickP1(),
cp2 = quad.getThickP2();
TQuadratic q1(TPointD(cp0.x, cp0.y), TPointD(cp1.x, cp1.y),
TPointD(cp2.x, cp2.y)),
q2(TPointD(cp0.y, cp0.thick), TPointD(cp1.y, cp1.thick),
TPointD(cp2.y, cp2.thick)),
q3(TPointD(cp0.x, cp0.thick), TPointD(cp1.x, cp1.thick),
TPointD(cp2.x, cp2.thick));
return std::min({computeStep(q1, pixelSize), computeStep(q2, pixelSize),
computeStep(q3, pixelSize)});
}
void stroke_autofill_learn(const TVectorImageP &imgToLearn, TStroke *stroke) {
if (!imgToLearn || !stroke || stroke->getControlPointCount() == 0) return;
TVectorImage appImg;
TStroke *appStroke = new TStroke(*stroke);
appImg.addStroke(appStroke);
appImg.findRegions();
double pbx, pby;
double totalArea = 0;
pbx = pby = 0;
if (!regionsReference.isEmpty()) regionsReference.clear();
int i, j, index = 0;
for (i = 0; i < (int)imgToLearn->getRegionCount(); i++) {
TRegion *currentRegion = imgToLearn->getRegion(i);
for (j = 0; j < (int)appImg.getRegionCount(); j++) {
TRegion *region = appImg.getRegion(j);
if (contains(region, currentRegion)) {
scanRegion(currentRegion, index, regionsReference, region->getBBox());
index++;
int k, subRegionCount = currentRegion->getSubregionCount();
for (k = 0; k < subRegionCount; k++) {
TRegion *subRegion = currentRegion->getSubregion(k);
if (contains(region, subRegion))
scanSubRegion(subRegion, index, regionsReference,
region->getBBox());
}
}
}
}
QMap<int, Region>::Iterator it;
for (it = regionsReference.begin(); it != regionsReference.end(); it++) {
pbx += it.value().m_barycentre.x;
pby += it.value().m_barycentre.y;
totalArea += it.value().m_area;
}
if (totalArea > 0)
referenceB = TPointD(pbx / totalArea, pby / totalArea);
else
referenceB = TPointD(0.0, 0.0);
}
void FullColorBrushTool::leftButtonDrag(const TPointD &pos, const TMouseEvent &e)
{
m_brushPos = m_mousePos = pos;
TRasterImageP ri = (TRasterImageP)getImage(true);
if (!ri)
return;
double maxThickness = m_thickness.getValue().second;
double thickness = m_pressure.getValue() ? computeThickness(e.m_pressure, m_thickness) : maxThickness;
double opacity = (m_pressure.getValue() ? computeThickness(e.m_pressure, m_opacity) : m_opacity.getValue().second) * 0.01;
TDimension size = m_workRaster->getSize();
TPointD rasCenter = TPointD(size.lx * 0.5, size.ly * 0.5);
TThickPoint point(pos + rasCenter, thickness);
TThickPoint old = m_points.back();
if (norm2(point - old) < 4)
return;
TThickPoint mid((old + point) * 0.5, (point.thick + old.thick) * 0.5);
m_points.push_back(mid);
m_points.push_back(point);
TRect bbox;
int m = m_points.size();
TRectD invalidateRect;
if (m == 3) {
// ho appena cominciato. devo disegnare un segmento
TThickPoint pa = m_points.front();
vector<TThickPoint> points;
points.push_back(pa);
points.push_back(mid);
invalidateRect = ToolUtils::getBounds(points, maxThickness);
bbox = m_brush->getBoundFromPoints(points);
updateWorkAndBackupRasters(bbox + m_lastRect);
m_tileSaver->save(bbox);
m_brush->addArc(pa, (pa + mid) * 0.5, mid, m_oldOpacity, opacity);
m_lastRect += bbox;
} else {
// caso generale: disegno un arco
vector<TThickPoint> points;
points.push_back(m_points[m - 4]);
points.push_back(old);
points.push_back(mid);
invalidateRect = ToolUtils::getBounds(points, maxThickness);
bbox = m_brush->getBoundFromPoints(points);
updateWorkAndBackupRasters(bbox + m_lastRect);
m_tileSaver->save(bbox);
m_brush->addArc(m_points[m - 4], old, mid, m_oldOpacity, opacity);
m_lastRect += bbox;
}
m_oldOpacity = opacity;
m_brush->updateDrawing(ri->getRaster(), m_backUpRas, m_currentColor, bbox, m_opacity.getValue().second * 0.01);
invalidate(invalidateRect.enlarge(2) - rasCenter);
m_strokeRect += bbox;
}
void TScannerParameters::setPaperFormat(std::string paperFormat) {
TPaperFormatManager *formatManager = TPaperFormatManager::instance();
assert(formatManager->isValidFormat(paperFormat));
if (!formatManager->isValidFormat(paperFormat))
paperFormat = formatManager->getDefaultFormat();
m_paperFormat = paperFormat;
TDimensionD d = TPaperFormatManager::instance()->getSize(paperFormat);
m_scanArea = TRectD(TPointD(0, 0), d);
cropScanArea();
if (m_cropBox == TRectD()) m_cropBox = m_scanArea;
}
bool circumCenter(TPointD &out, const TPointD &a, const TPointD &b, const TPointD &c)
{
double d = 2 * (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
if (fabs(d) < 0.0001) {
out = TPointD();
return false;
}
out.x = ((a.y * a.y + a.x * a.x) * (b.y - c.y) + (b.y * b.y + b.x * b.x) * (c.y - a.y) + (c.y * c.y + c.x * c.x) * (a.y - b.y)) / d;
out.y = ((a.y * a.y + a.x * a.x) * (c.x - b.x) + (b.y * b.y + b.x * b.x) * (a.x - c.x) + (c.y * c.y + c.x * c.x) * (b.x - a.x)) / d;
return true;
}
StageSchematicScene::StageSchematicScene(QWidget *parent)
: SchematicScene(parent), m_nextNodePos(0, 0), m_xshHandle(0), m_objHandle(0), m_colHandle(0), m_sceneHandle(0), m_frameHandle(0), m_gridDimension(eSmall), m_showLetterOnPortFlag(ShowLetterOnOutputPortOfStageNode!=0)
{
QPointF sceneCenter = sceneRect().center();
m_firstPos = TPointD(sceneCenter.x(), sceneCenter.y());
m_selection = new StageObjectSelection();
connect(m_selection, SIGNAL(doCollapse(QList<TStageObjectId>)), this, SLOT(onCollapse(QList<TStageObjectId>)));
connect(m_selection, SIGNAL(doExplodeChild(QList<TStageObjectId>)), this, SIGNAL(doExplodeChild(QList<TStageObjectId>)));
connect(this, SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged()));
m_highlightedLinks.clear();
}
void CameraTestTool::drawCleanupCamera(double pixelSize) {
CleanupParameters *cp =
CleanupSettingsModel::instance()->getCurrentParameters();
TRectD rect = cp->m_camera.getStageRect();
glColor3d(1.0, 0.0, 0.0);
glLineStipple(1, 0xFFFF);
glEnable(GL_LINE_STIPPLE);
// box
glBegin(GL_LINE_STRIP);
glVertex2d(rect.x0, rect.y0);
glVertex2d(rect.x0, rect.y1 - pixelSize);
glVertex2d(rect.x1 - pixelSize, rect.y1 - pixelSize);
glVertex2d(rect.x1 - pixelSize, rect.y0);
glVertex2d(rect.x0, rect.y0);
glEnd();
// central cross
double dx = 0.05 * rect.getP00().x;
double dy = 0.05 * rect.getP00().y;
tglDrawSegment(TPointD(-dx, -dy), TPointD(dx, dy));
tglDrawSegment(TPointD(-dx, dy), TPointD(dx, -dy));
glDisable(GL_LINE_STIPPLE);
// camera name
TPointD pos = rect.getP01() + TPointD(0, 4);
glPushMatrix();
glTranslated(pos.x, pos.y, 0);
glScaled(2, 2, 2);
tglDrawText(TPointD(), "Cleanup Camera");
glPopMatrix();
}
/*! rgb picking
*/
void ImageViewer::pickColor(QMouseEvent *event, bool putValueToStyleEditor) {
if (!m_isHistogramEnable) return;
if (!m_histogramPopup->isVisible()) return;
QPoint curPos = event->pos() * getDevPixRatio();
// avoid to pick outside of the flip
if ((!m_image) || !rect().contains(curPos)) {
// throw transparent color
m_histogramPopup->updateInfo(TPixel32::Transparent, TPointD(-1, -1));
return;
}
StylePicker picker(m_image);
TPoint mousePos = TPoint(curPos.x(), height() - 1 - curPos.y());
TRectD area = TRectD(mousePos.x, mousePos.y, mousePos.x, mousePos.y);
if (m_lutCalibrator && m_lutCalibrator->isValid()) m_fbo->bind();
const TPixel32 pix = picker.pickColor(area);
if (m_lutCalibrator && m_lutCalibrator->isValid()) m_fbo->release();
QPoint viewP = mapFrom(this, curPos);
TPointD pos = getViewAff().inv() *
TPointD(viewP.x() - width() / 2, -viewP.y() + height() / 2);
TPointD imagePos = TPointD(0.5 * m_image->getBBox().getLx() + pos.x,
0.5 * m_image->getBBox().getLy() + pos.y);
if (m_image->getBBox().contains(imagePos)) {
// throw the picked color to the histogram
m_histogramPopup->updateInfo(pix, imagePos);
// throw it to the style editor as well
if (putValueToStyleEditor) setPickedColorToStyleEditor(pix);
} else {
// throw transparent color if picking outside of the image
m_histogramPopup->updateInfo(TPixel32::Transparent, TPointD(-1, -1));
}
}
void ShiftTraceTool::clearData() {
m_ghostIndex = 0;
m_curveStatus = NoCurve;
m_gadget = NoGadget;
m_highlightedGadget = NoGadget;
m_box = TRectD();
for (int i = 0; i < 2; i++) {
m_row[i] = -1;
m_aff[i] = TAffine();
m_center[i] = TPointD();
}
}
void StageSchematicScene::updateScene()
{
clearAllItems();
QPointF firstPos = sceneRect().center();
m_nextNodePos = TPointD(firstPos.x(), firstPos.y());
TStageObjectTree *pegTree = m_xshHandle->getXsheet()->getStageObjectTree();
m_nodeTable.clear();
m_GroupTable.clear();
m_groupEditorTable.clear();
m_gridDimension = pegTree->getDagGridDimension();
QMap<int, QList<TStageObject *>> groupedObj;
QMap<int, QList<SchematicNode *>> editedGroup;
// in order to draw the position-specified nodes first
QList<int> modifiedNodeIds;
for (int i = 0; i < pegTree->getStageObjectCount(); i++) {
TStageObject *pegbar = pegTree->getStageObject(i);
if (pegbar->getDagNodePos() == TConst::nowhere)
modifiedNodeIds.push_back(i);
else
modifiedNodeIds.push_front(i);
}
for (int i = 0; i < modifiedNodeIds.size(); i++) {
TStageObject *pegbar = pegTree->getStageObject(modifiedNodeIds.at(i));
if (pegbar->isGrouped() && !pegbar->isGroupEditing()) {
groupedObj[pegbar->getGroupId()].push_back(pegbar);
continue;
}
StageSchematicNode *node = addStageSchematicNode(pegbar);
if (node != 0) {
m_nodeTable[pegbar->getId()] = node;
if (pegbar->isGrouped())
editedGroup[pegbar->getEditingGroupId()].append(node);
}
}
//Motion Path
m_splineTable.clear();
for (int i = 0; i < pegTree->getSplineCount(); i++) {
TStageObjectSpline *spline = pegTree->getSpline(i);
StageSchematicSplineNode *node = addSchematicSplineNode(spline);
if (node != 0) {
m_splineTable[spline] = node;
connect(node, SIGNAL(currentObjectChanged(const TStageObjectId &, bool)), this,
SLOT(onCurrentObjectChanged(const TStageObjectId &, bool)));
}
}
void rect_autofill_learn(const TVectorImageP &imgToLearn, const TRectD &rect)
{
if (rect.getLx() * rect.getLy() < MIN_SIZE) return;
double pbx, pby;
double totalArea = 0;
pbx = pby = 0;
if (!regionsReference.isEmpty()) regionsReference.clear();
int i, index = 0, regionCount = imgToLearn->getRegionCount();
for (i = 0; i < regionCount; i++) {
TRegion *region = imgToLearn->getRegion(i);
if (rect.contains(region->getBBox())) {
scanRegion(region, index, regionsReference, rect);
index++;
}
int j, subRegionCount = region->getSubregionCount();
for (j = 0; j < subRegionCount; j++) {
TRegion *subRegion = region->getSubregion(j);
if (rect.contains(subRegion->getBBox()))
scanSubRegion(subRegion, index, regionsReference, rect);
}
}
QMap<int, Region>::Iterator it;
for (it = regionsReference.begin(); it != regionsReference.end(); it++) {
pbx += it.value().m_barycentre.x;
pby += it.value().m_barycentre.y;
totalArea += it.value().m_area;
}
if (totalArea > 0)
referenceB = TPointD(pbx / totalArea, pby / totalArea);
else
referenceB = TPointD(0.0, 0.0);
}
void FullColorBrushTool::leftButtonDown(const TPointD &pos, const TMouseEvent &e)
{
m_brushPos = m_mousePos = pos;
Viewer *viewer = getViewer();
if (!viewer)
return;
TRasterImageP ri = (TRasterImageP)getImage(true);
if (!ri)
ri = (TRasterImageP)touchImage();
if (!ri)
return;
TRasterP ras = ri->getRaster();
TDimension dim = ras->getSize();
if (!(m_workRaster && m_backUpRas))
setWorkAndBackupImages();
m_workRaster->lock();
double maxThick = m_thickness.getValue().second;
double thickness = m_pressure.getValue() ? computeThickness(e.m_pressure, m_thickness) : maxThick;
double opacity = (m_pressure.getValue() ? computeThickness(e.m_pressure, m_opacity) : m_opacity.getValue().second) * 0.01;
TPointD rasCenter = TPointD(dim.lx * 0.5, dim.ly * 0.5);
TThickPoint point(pos + rasCenter, thickness);
TPointD halfThick(maxThick * 0.5, maxThick * 0.5);
TRectD invalidateRect(pos - halfThick, pos + halfThick);
m_points.clear();
m_points.push_back(point);
m_tileSet = new TTileSetFullColor(ras->getSize());
m_tileSaver = new TTileSaverFullColor(ras, m_tileSet);
double hardness = m_hardness.getValue() * 0.01;
m_brush = new BluredBrush(m_workRaster, maxThick, m_brushPad, hardness == 1.0);
m_strokeRect = m_brush->getBoundFromPoints(m_points);
updateWorkAndBackupRasters(m_strokeRect);
m_tileSaver->save(m_strokeRect);
m_brush->addPoint(point, opacity);
m_brush->updateDrawing(ras, m_backUpRas, m_currentColor, m_strokeRect, m_opacity.getValue().second * 0.01);
m_oldOpacity = opacity;
m_lastRect = m_strokeRect;
invalidate(invalidateRect.enlarge(2));
}
void CameraTestTool::leftButtonUp(const TPointD &pos, const TMouseEvent &) {
// Reset full commit status - invokes preview rebuild on its own.
CleanupSettingsModel::instance()->setCommitMask(
CleanupSettingsModel::FULLPROCESS);
CleanupParameters *cp =
CleanupSettingsModel::instance()->getCurrentParameters();
/*-- カメラ位置移動のUndo --*/
if (m_scaling == eNoScale) {
/*-- 値が変わったらUndoを登録 --*/
if (m_firstCameraOffset.x != cp->m_offx ||
m_firstCameraOffset.y != cp->m_offy) {
UndoCameraTestMove *undo = new UndoCameraTestMove(
m_firstCameraOffset, TPointD(cp->m_offx, cp->m_offy), cp);
TUndoManager::manager()->add(undo);
}
}
/*-- サイズ変更のUndo --*/
else {
if (m_firstSize.lx != cp->m_camera.getSize().lx ||
m_firstSize.ly != cp->m_camera.getSize().ly) {
UndoCameraTestScale *undo = new UndoCameraTestScale(
m_firstRes, m_firstSize, cp->m_camera.getRes(),
cp->m_camera.getSize(), cp);
TUndoManager::manager()->add(undo);
}
}
m_firstPos = TPointD(-1, -1);
m_firstCameraOffset = TPointD(0, 0);
m_firstRes = TDimension(0, 0);
m_firstSize = TDimensionD(0, 0);
m_lastPos = TPointD(-1, -1);
m_dragged = false;
}
void CameraTestTool::draw() {
double pixelSize = getPixelSize();
glPushMatrix();
CleanupParameters *cp =
CleanupSettingsModel::instance()->getCurrentParameters();
glTranslated(-0.5 * cp->m_offx * Stage::inch, -0.5 * cp->m_offy * Stage::inch,
0);
drawCleanupCamera(pixelSize);
// drawClosestFieldCamera(pixelSize);
TRectD r(cp->m_camera.getStageRect());
TPointD size(10, 10);
double pixelSize4 = 4.0 * pixelSize;
tglColor(TPixel::Red);
ToolUtils::drawSquare(r.getP00(), pixelSize4, TPixel::Red);
ToolUtils::drawSquare(r.getP01(), pixelSize4, TPixel::Red);
ToolUtils::drawSquare(r.getP10(), pixelSize4, TPixel::Red);
ToolUtils::drawSquare(r.getP11(), pixelSize4, TPixel::Red);
TPointD center(0.5 * (r.getP00() + r.getP11()));
ToolUtils::drawSquare(TPointD(center.x, r.y0), pixelSize4,
TPixel::Red); // draw M0 handle
ToolUtils::drawSquare(TPointD(r.x1, center.y), pixelSize4,
TPixel::Red); // draw 1M handle
ToolUtils::drawSquare(TPointD(center.x, r.y1), pixelSize4,
TPixel::Red); // draw M1 handle
ToolUtils::drawSquare(TPointD(r.x0, center.y), pixelSize4,
TPixel::Red); // draw 0M handle
glPopMatrix();
}
void CameraTestTool::leftButtonDown(const TPointD &pos, const TMouseEvent &e) {
m_firstPos = m_lastPos = pos;
/*-- カメラオフセットの初期値の取得 --*/
CleanupParameters *cp =
CleanupSettingsModel::instance()->getCurrentParameters();
if (m_scaling == eNoScale)
m_firstCameraOffset = TPointD(cp->m_offx, cp->m_offy);
/*-- サイズ変更のUndoのために値を格納 --*/
else {
m_firstRes = cp->m_camera.getRes();
m_firstSize = cp->m_camera.getSize();
}
// Limit commits to the sole interface updates. This is necessary since drags
// would otherwise trigger full preview re-processings.
CleanupSettingsModel::instance()->setCommitMask(
CleanupSettingsModel::INTERFACE);
}
